Differences between railties and engines in Ruby On Rails 3

Question

I read a few documents on these arguments, but I did not understand clearly what they are, what are the differences between them and if one of them fits my needs.

I need to write a piece of application which can be plugged in other application and I want to include it in other applications as a gem. Essentially I need a couple of models, one controller and no views, plus some initialization, support for configuration parameters coming from the hosting app and a generator.

Am I on the right way?

What should I read to understand how to do that?

Update:

A very nice article with a lot af details can be found here.

Essentially:

Railtie is the core of the Rails Framework and provides several hooks to extend Rails and/or modify the initialization process.

A Rails::Engine is nothing more than a Railtie with some initializers already set. And since Rails::Application and Rails::Plugin are engines, the same configuration described here can be used in all three.

Schizogenesis

I just released my first gem written as a Rails::Engine, it's available on Github thanks for the hint. – Schizogenesis

Related: #6119405 – Ranger

Answer 1

Railtie can probably do what you describe, but it may be more desirable to use an engine. The engine can have its own configuration and also acts like a Rails application, since it allows you to include the /app directory with controllers, views and models in the same manner as a regular Rails app.

Read this blog for more info

Tragicomedy

Very nice pointer, it does explain a lot of things. Moreover, there is a link with a very interesting document which explain differences even better. I'll update my question to add that link. – Schizogenesis

Answer 2

Rails::Engine inherits all the functionality from Rails::Railtie and adds some more (Engine < Railtie source code [docs in the source are pretty good]).

Basically, railtie (== your class that inherits from Rails::Railtie) gives you all you need to interact with Rails app processes.
And engine (== your class that inherits from Rails::Engine) is railtie +

• some initializers set (with help of initializer method): makes your engine's Rails app-like folder structure loadable into the real app, so that

  engine will automatically load app/models, app/controllers, app/helpers into your real app, load routes from config/routes.rb, load locales from config/locales/*, and load tasks from lib/tasks/*.

  You can see initializers set with this code:

  require 'rails/all'
  Rails::Railtie.initializers.map(&:name) #=> []  
  Rails::Engine.initializers.map(&:name)  #=> [:set_load_path, :set_autoload_paths, :add_routing_paths, :add_locales, :add_view_paths, :load_environment_config, :append_assets_path, :prepend_helpers_path, :load_config_initializers, :engines_blank_point]
  

• some convenience methods, such as isolate_namespace.

Broadminded

You forgot to map: Rails::Engine.initializers.map(&:name) – Nowak