Rail Loader

[Zareen Zapata]

Due to stipulated bending and stress limits it is recommended to install a ROLOAD unit every 10 m of rail length. The cranes are operated synchronously via radio remote control. If required, cranes can be controlled individually.

Colmar Railroad Loaders are used for the construction and maintenance of railway lines. The machines can be equipped with different accessories such as: Rail pinchers, hydraulic or mechanical frame beams for moving sleepers, tamping units, pinchers for different uses, hydraulic hammers, and hydraulics bush-grass cutters.

Colmar Railroad Loaders are made out of a strong electro welded steel and are outfitted with hydraulic systems made with high quality components. The Railroad Loaders are complete with security systems and can be adapted to work in different countries.

The Bulk Rail Loader and Unloader items will show a preview of the loader and
an image of a cargo wagon, to help position the loader correctly. The
concrete pad of the Bulk Rail Unloader serves a similar purpose.

Note that rails are placed every other tile, but cargo wagons in stations
stop every 7 tiles. Depending on the exact loader placement, it may appear
with two or three rail segments underneath. You cannot place a BRL if it
could not align with other rails.

BRLs are circuit-connectable chest entities that output their content. You
can connect them to Logistic Train Network stops to manage automatic creation
of transport orders. Sending a BRL the special "Disable rail loader" signal
will stop the BRL from loading/unloading a cargo wagon. Due to their speed,
you are likely to load or unload a few more items than expected.

Rail loaders and unloaders can fit 4 inserters or loaders on each side, for
an inherent 8 belts of throughput. If this is insufficient, you can add up to
4 chests to the corners of the loaders, and they will automatically push or
pull items into these chests. I recommend limiting these chests to just a few
stacks to prevent them from getting too out of balance.

With vanilla 1x1 chests, this system allows up to 12 belts of throughput, 6
per side. However, chests can be of any size. Interface chests can also be
logistics chests, if you wish to directly connect your bulk rail loaders to
your logistics network.

In an ordinary Ruby program, you explicitly load the files that define classes and modules you want to use. For example, the following controller refers to ApplicationController and Post, and you'd normally issue require calls for them:

On the other hand, those loaders do not manage anything else. In particular, they do not manage the Ruby standard library, gem dependencies, Rails components themselves, or even (by default) the application lib directory. That code has to be loaded as usual.

By default, Rails configures Zeitwerk to inflect file names with String#camelize. For example, it expects that app/controllers/users_controller.rb defines the constant UsersController because that is what "users_controller".camelize returns.

We refer to the list of application directories whose contents are to be autoloaded and (optionally) reloaded as autoload paths. For example, app/models. Such directories represent the root namespace: Object.

By default, the autoload paths of an application consist of all the subdirectories of app that exist when the application boots ---except for assets, javascript, and views--- plus the autoload paths of engines it might depend on.

Rails adds custom directories under app to the autoload paths automatically. For example, if your application has app/presenters, you don't need to configure anything in order to autoload presenters; it works out of the box.

You cannot autoload code in the autoload paths while the application boots. In particular, directly in config/initializers/*.rb. Please check Autoloading when the application boots down below for valid ways to do that.

The configuration method config.autoload_lib adds the lib directory to config.autoload_paths and config.eager_load_paths. It has to be invoked from config/application.rb or config/environments/*.rb, and it is not available for engines.

Making MoneySerializer reloadable would be confusing, because reloading an edited version would have no effect on that class object stored in Active Job. Indeed, if MoneySerializer was reloadable, starting with Rails 7 such initializer would raise a NameError.

There, the module object stored in MyDecoration by the time the initializer runs becomes an ancestor of ActionController::Base, and reloading MyDecoration is pointless, it won't affect that ancestor chain.

The method config.autoload_lib_once is similar to config.autoload_lib, except that it adds lib to config.autoload_once_paths instead. It has to be invoked from config/application.rb or config/environments/*.rb, and it is not available for engines.

Autoload paths are added to $LOAD_PATH by default. However, Zeitwerk uses absolute file names internally, and your application should not issue require calls for autoloadable files, so those directories are actually not needed there. You can opt out with this flag:

That may speed up legitimate require calls a bit since there are fewer lookups. Also, if your application uses Bootsnap, that saves the library from building unnecessary indexes, leading to lower memory usage.

More precisely, if the web server is running and application files have been modified, Rails unloads all autoloaded constants managed by the main autoloader just before the next request is processed. That way, application classes or modules used during that request will be autoloaded again, thus picking up their current implementation in the file system.

Reloading can be enabled or disabled. The setting that controls this behavior is config.enable_reloading, which is true by default in development mode, and false by default in production mode. For backwards compatibility, Rails also supports config.cache_classes, which is equivalent to !config.enable_reloading.

Rails uses an evented file monitor to detect files changes by default. It can be configured instead to detect file changes by walking the autoload paths. This is controlled by the config.file_watcher setting.

In a Rails console there is no file watcher active regardless of the value of config.enable_reloading. This is because, normally, it would be confusing to have code reloaded in the middle of a console session. Similar to an individual request, you generally want a console session to be served by a consistent, non-changing set of application classes and modules.

It is very important to understand that Ruby does not have a way to truly reload classes and modules in memory, and have that reflected everywhere they are already used. Technically, "unloading" the User class means removing the User constant via Object.send(:remove_const, "User").

Why? Initializers only run once, when the application boots. They do not run again on reloads. If an initializer used a reloadable class or module, edits to them would not be reflected in that initial code, thus becoming stale. Therefore, referring to reloadable constants during initialization is disallowed.

Some configurations take a class or module object, and they store it in a place that is not reloaded. It is important that these are not reloadable, because edits would not be reflected in those cached stale objects.

The easiest way to refer to those classes or modules during boot is to have them defined in a directory which does not belong to the autoload paths. For instance, lib is an idiomatic choice. It does not belong to the autoload paths by default, but it does belong to $LOAD_PATH. Just perform a regular require to load it.

In production-like environments it is generally better to load all the application code when the application boots. Eager loading puts everything in memory ready to serve requests right away, and it is also CoW-friendly.

Eager loading is controlled by the flag config.eager_load, which is disabled by default in all environments except production. When a Rake task gets executed, config.eager_load is overridden by config.rake_eager_load, which is false by default. So, by default, in production environments Rake tasks do not eager load the application.

In this example, we still want app/models/shapes/circle.rb to define Circle, not Shapes::Circle. This may be your personal preference to keep things simple, and also avoids refactors in existing code bases. The collapsing feature of Zeitwerk allows us to do that:

If models are added, modified, or deleted from the STI, reloading works as expected. However, if a new separate STI hierarchy is added to the application, you'll need to edit the initializer and restart the server.

By default, Rails uses String#camelize to know which constant a given file or directory name should define. For example, posts_controller.rb should define PostsController because that is what "posts_controller".camelize returns.

It could be the case that some particular file or directory name does not get inflected as you want. For instance, html_parser.rb is expected to define HtmlParser by default. What if you prefer the class to be HTMLParser? There are a few ways to customize this.

Doing so affects how Active Support inflects globally. That may be fine in some applications, but you can also customize how to camelize individual basenames independently from Active Support by passing a collection of overrides to the default inflectors:

That technique still depends on String#camelize, though, because that is what the default inflectors use as fallback. If you instead prefer not to depend on Active Support inflections at all and have absolute control over inflections, configure the inflectors to be instances of Zeitwerk::Inflector:

If an application does not use the once autoloader, the snippets above can go in config/initializers. For example, config/initializers/inflections.rb for the Active Support use case, or config/initializers/zeitwerk.rb for the other ones.

c80f0f1006