Ruby on Rails 5.2 - Rails::Engine

वर्ग रेल :: इंजन




ruby

वर्ग रेल :: इंजन

जनक:
Railtie

Rails::Engine आपको एक विशिष्ट रेल एप्लिकेशन या कार्यक्षमता के सबसेट को लपेटने और अन्य अनुप्रयोगों के साथ या एक बड़े पैकेज्ड एप्लिकेशन के भीतर साझा करने की अनुमति देता है। प्रत्येक Rails::Application केवल एक इंजन है, जो सरल सुविधा और अनुप्रयोग साझाकरण के लिए अनुमति देता है।

किसी भी Rails::Engine भी एक Rails::Railtie , तो वही विधियाँ (जैसे कि rake_tasks और generators ) और कॉन्फ़िगरेशन विकल्प जो कि रेल में उपलब्ध हैं, का उपयोग इंजन में भी किया जा सकता है।

एक Engine बनाना

यदि आप एक मणि को एक इंजन के रूप में व्यवहार करना चाहते हैं, तो आपको इसके लिए एक Engine को अपने प्लगइन के Railtie फोल्डर के अंदर कहीं निर्दिष्ट करना होगा (इसी तरह कि हम किस प्रकार Railtie निर्दिष्ट करते हैं):

# lib/my_engine.rb
module MyEngine
  class Engine < Rails::Engine
  end
end

फिर यह सुनिश्चित करें कि यह फ़ाइल आपके config/application.rb (या आपके Gemfile ) में सबसे ऊपर लोड की गई है और यह स्वतः ही app अंदर मॉडल, कंट्रोलर और Gemfile को लोड कर देगी, config/routes.rb मार्गों पर लोड कर देगी Gemfile , config/locales/* पर लोकेशन लोड करें config/locales/* , और कार्य lib/tasks/* पर कार्य लोड करें।

Configuration

Railtie कॉन्फ़िगरेशन के अलावा, जो कि Rails::Engine में साझा किया जाता है, एक Rails::Engine आप eager_load_paths , eager_load_paths और eager_load_paths उपयोग कर सकते हैं, जो कि एक Railtie से अलग है, वर्तमान इंजन के लिए स्कोप किया गया है।

class MyEngine < Rails::Engine
  # Add a load path for this specific Engine
  config.autoload_paths << File.expand_path("lib/some/path", __dir__)

  initializer "my_engine.add_middleware" do |app|
    app.middleware.use MyEngine::Middleware
  end
end

Generators

आप config.generators विधि वाले इंजन के लिए जनरेटर सेट कर सकते हैं:

class MyEngine < Rails::Engine
  config.generators do |g|
    g.orm             :active_record
    g.template_engine :erb
    g.test_framework  :test_unit
  end
end

आप config.app_generators का उपयोग करके किसी एप्लिकेशन के लिए जनरेटर भी सेट कर सकते हैं:

class MyEngine < Rails::Engine
  # note that you can also pass block to app_generators in the same way you
  # can pass it to generators method
  config.app_generators.orm :datamapper
end

एप्लिकेशन और इंजन में लचीला पथ कॉन्फ़िगरेशन होता है, जिसका अर्थ है कि आपको app/controllers पर अपने नियंत्रकों को रखने की आवश्यकता नहीं है, लेकिन किसी भी स्थान पर जो आपको सुविधाजनक लगता है।

उदाहरण के लिए, मान लें कि आप अपने नियंत्रकों को lib/controllers में रखना चाहते हैं। आप इसे एक विकल्प के रूप में सेट कर सकते हैं:

class MyEngine < Rails::Engine
  paths["app/controllers"] = "lib/controllers"
end

आप अपने नियंत्रकों को app/controllers और lib/controllers दोनों से लोड कर सकते हैं:

class MyEngine < Rails::Engine
  paths["app/controllers"] << "lib/controllers"
end

एक इंजन में उपलब्ध रास्ते हैं:

class MyEngine < Rails::Engine
  paths["app"]                 # => ["app"]
  paths["app/controllers"]     # => ["app/controllers"]
  paths["app/helpers"]         # => ["app/helpers"]
  paths["app/models"]          # => ["app/models"]
  paths["app/views"]           # => ["app/views"]
  paths["lib"]                 # => ["lib"]
  paths["lib/tasks"]           # => ["lib/tasks"]
  paths["config"]              # => ["config"]
  paths["config/initializers"] # => ["config/initializers"]
  paths["config/locales"]      # => ["config/locales"]
  paths["config/routes.rb"]    # => ["config/routes.rb"]
end

Application वर्ग इस सेट में कुछ और पथ जोड़ता है। और आपके Application , app अंतर्गत सभी फ़ोल्डर स्वचालित रूप से लोड पथ में जुड़ जाते हैं। यदि आपके पास उदाहरण के लिए एक app/services फ़ोल्डर है, तो इसे डिफ़ॉल्ट रूप से जोड़ा जाएगा।

endpoint

एक इंजन भी एक रैक अनुप्रयोग हो सकता है। यह उपयोगी हो सकता है यदि आपके पास एक रैक अनुप्रयोग है जिसे आप Engine साथ लपेटना चाहते हैं और Engine कुछ विशेषताओं के साथ प्रदान करेंगे।

ऐसा करने के लिए, endpoint विधि का उपयोग करें:

module MyEngine
  class Engine < Rails::Engine
    endpoint MyRackApplication
  end
end

अब आप अपने इंजन को एप्लिकेशन के मार्गों में उसी तरह माउंट कर सकते हैं:

Rails.application.routes.draw do
  mount MyEngine::Engine => "/engine"
end

मिडिलवेयर स्टैक

इंजन के रूप में अब एक रैक समापन बिंदु हो सकता है, इसमें एक मिडलवेयर स्टैक भी हो सकता है। उपयोग बिल्कुल Application के समान है:

module MyEngine
  class Engine < Rails::Engine
    middleware.use SomeMiddleware
  end
end

मार्गों

यदि आप एक समापन बिंदु निर्दिष्ट नहीं करते हैं, तो मार्गों को डिफ़ॉल्ट समापन बिंदु के रूप में उपयोग किया जाएगा। आप उन्हें वैसे ही उपयोग कर सकते हैं जैसे आप किसी एप्लिकेशन के मार्गों का उपयोग करते हैं:

# ENGINE/config/routes.rb
MyEngine::Engine.routes.draw do
  get "/" => "posts#index"
end

माउंट प्राथमिकता

ध्यान दें कि अब आपके आवेदन में एक से अधिक राउटर हो सकते हैं, और कई राउटर के माध्यम से अनुरोधों को पारित करने से बचना बेहतर है। इस स्थिति पर विचार करें:

Rails.application.routes.draw do
  mount MyEngine::Engine => "/blog"
  get "/blog/omg" => "main#omg"
end

MyEngine /blog पर मुहिम MyEngine है, और /blog/omg अनुप्रयोग के नियंत्रक को /blog/omg अंक। ऐसी स्थिति में, /blog/omg लिए अनुरोध MyEngine माध्यम से MyEngine , और यदि Engine के मार्गों में ऐसा कोई मार्ग नहीं है, तो इसे main#omg भेजा जाएगा। यह स्वैप करने के लिए बेहतर है कि:

Rails.application.routes.draw do
  get "/blog/omg" => "main#omg"
  mount MyEngine::Engine => "/blog"
end

अब, Engine को केवल अनुरोध प्राप्त होंगे जो Application द्वारा नियंत्रित नहीं किए गए थे।

Engine नाम

कुछ ऐसे स्थान हैं जहाँ एक इंजन का नाम उपयोग किया जाता है:

  • मार्ग: जब आप माउंट के साथ एक Engine mount(MyEngine::Engine => '/my_engine') , इसका उपयोग इस प्रकार किया जाता है :as विकल्प

  • माइग्रेशन स्थापित करने के लिए रेक कार्य my_engine:install:migrations

Engine नाम डिफ़ॉल्ट रूप से वर्ग नाम के आधार पर निर्धारित किया जाता है। MyEngine::Engine यह my_engine_engine होगा। आप engine_name पद्धति का उपयोग करके इसे मैन्युअल रूप से बदल सकते हैं:

module MyEngine
  class Engine < Rails::Engine
    engine_name "my_engine"
  end
end

पृथक Engine

आम तौर पर जब आप किसी इंजन के अंदर कंट्रोलर, हेल्पर्स और मॉडल बनाते हैं, तो उनके साथ ऐसा व्यवहार किया जाता है मानो वे एप्लिकेशन के अंदर बनाए गए हों। इसका अर्थ है कि एप्लिकेशन से सभी हेल्पर्स और नामित मार्ग आपके इंजन के नियंत्रकों के लिए भी उपलब्ध होंगे।

हालांकि, कभी-कभी आप अपने इंजन को एप्लिकेशन से अलग करना चाहते हैं, खासकर यदि आपके इंजन का अपना राउटर है। ऐसा करने के लिए, आपको बस isolate_namespace कॉल isolate_namespace । इस विधि के लिए आपको एक मॉड्यूल पास करना होगा जहाँ आपके सभी नियंत्रकों, सहायकों और मॉडलों को नेस्टेड किया जाना चाहिए:

module MyEngine
  class Engine < Rails::Engine
    isolate_namespace MyEngine
  end
end

इस तरह के इंजन के साथ, MyEngine मॉड्यूल के अंदर जो कुछ भी है, वह एप्लिकेशन से अलग हो जाएगा।

इस नियंत्रक पर विचार करें:

module MyEngine
  class FooController < ActionController::Base
  end
end

यदि MyEngine इंजन को अलग-थलग के रूप में चिह्नित किया जाता है, तो FooController केवल FooController से सहायकों तक MyEngine , और MyEngine::Engine.routes से MyEngine::Engine.routes

अगली चीज जो पृथक इंजनों में बदलती है वह मार्गों का व्यवहार है। आम तौर पर, जब आप अपने नियंत्रकों को नामांकित करते हैं, तो आपको संबंधित मार्गों को नामांकित करने की भी आवश्यकता होती है। एक पृथक इंजन के साथ, इंजन का नाम स्थान स्वचालित रूप से लागू होता है, इसलिए आपको इसे अपने मार्गों में स्पष्ट रूप से निर्दिष्ट करने की आवश्यकता नहीं है:

MyEngine::Engine.routes.draw do
  resources :articles
end

यदि MyEngine अलग है, तो ऊपर दिए गए मार्ग MyEngine::ArticlesController को इंगित करेंगे। आपको my_engine_articles_path जैसे लंबे url सहायकों का उपयोग करने की आवश्यकता नहीं है। इसके बजाय, आपको बस articles_path उपयोग करना चाहिए_ जैसे कि आप अपने मुख्य आवेदन के साथ करेंगे।

इस व्यवहार को फ्रेमवर्क के अन्य भागों के अनुरूप बनाने के लिए, पृथक इंजनों का ActiveModel::Naming पर भी प्रभाव पड़ता है। एक सामान्य रेल एप्लिकेशन में, जब आप एक ActiveModel::Naming मॉडल का उपयोग करते हैं जैसे कि Namespace::Article , ActiveModel::Naming उपसर्ग "नामस्थान" के साथ नाम उत्पन्न करेगा। एक अलग इंजन में, उपसर्ग url सहायकों और प्रपत्र फ़ील्ड में, सुविधा के लिए छोड़ा जाएगा।

polymorphic_url(MyEngine::Article.new)
# => "articles_path" # not "my_engine_articles_path"

form_for(MyEngine::Article.new) do
  text_field :title # => <input type="text" name="article[title]" id="article_title" />
end

इसके अतिरिक्त, एक अलग इंजन अपने नाम स्थान के अनुसार अपना नाम निर्धारित करेगा, इसलिए MyEngine::Engine.engine_name "my_engine" लौटाएगा। यह MyEngine.table_name_prefix को "my_engine_" पर भी सेट करेगा, उदाहरण के लिए कि MyEngine::Article डिफ़ॉल्ट रूप से my_engine_articles डेटाबेस तालिका का उपयोग करेगा।

इंजन के बाहर Engine के मार्गों का उपयोग करना

चूंकि अब आप एप्लिकेशन के मार्गों के अंदर इंजन को माउंट कर सकते हैं, इसलिए आपके पास अनुप्रयोग के अंदर Engine के url_helpers तक सीधी पहुंच नहीं है। जब आप किसी एप्लिकेशन के मार्गों में इंजन को माउंट करते हैं, तो आपको ऐसा करने के लिए एक विशेष सहायक बनाया जाता है। ऐसे परिदृश्य पर विचार करें:

# config/routes.rb
Rails.application.routes.draw do
  mount MyEngine::Engine => "/my_engine", as: "my_engine"
  get "/foo" => "foo#index"
end

अब, आप अपने आवेदन के अंदर my_engine सहायक का उपयोग कर सकते हैं:

class FooController < ApplicationController
  def index
    my_engine.root_url # => /my_engine/
  end
end

एक main_app सहायक भी है जो आपको इंजन के अंदर एप्लिकेशन के मार्गों तक पहुंच प्रदान करता है:

module MyEngine
  class BarController
    def index
      main_app.foo_path # => /foo
    end
  end
end

ध्यान दें :as माउंट करने के लिए दिए गए विकल्प के :as में engine_name डिफ़ॉल्ट रूप में लेता है, इसलिए अधिकांश समय आप बस इसे छोड़ सकते हैं।

अंत में, यदि आप polymorphic_url का उपयोग करके किसी इंजन के मार्ग पर एक url उत्पन्न करना चाहते हैं, तो आपको इंजन सहायक को भी पास करना होगा। मान लीजिए कि आप इंजन के किसी एक रूट की ओर इशारा करते हुए एक फॉर्म बनाना चाहते हैं। आपको बस इतना करना होगा कि url के लिए विशेषताओं वाले पहले तत्व के रूप में सहायक को पास करें:

form_for([my_engine, @user])

यह कोड उचित मार्ग उत्पन्न करने के लिए my_engine.user_path(@user) का उपयोग करेगा।

पृथक इंजन के सहायक

कभी-कभी आप इंजन को अलग करना चाह सकते हैं, लेकिन इसके लिए परिभाषित किए गए सहायकों का उपयोग करें। यदि आप केवल कुछ विशिष्ट सहायकों को साझा करना चाहते हैं, तो आप उन्हें अनुप्रयोग के सहायकों को ApplicationController में जोड़ सकते हैं:

class ApplicationController < ActionController::Base
  helper MyEngine::SharedEngineHelper
end

यदि आप इंजन के सभी सहायक शामिल करना चाहते हैं, तो आप इंजन के उदाहरण पर सहायक विधि का उपयोग कर सकते हैं:

class ApplicationController < ActionController::Base
  helper MyEngine::Engine.helpers
end

इसमें इंजन की निर्देशिका से सभी सहायक शामिल होंगे। ध्यान रखें कि इसमें हेल्पर_मेथोड या अन्य समान समाधानों के साथ नियंत्रकों में परिभाषित सहायक शामिल नहीं हैं, केवल सहायक निर्देशिका में परिभाषित सहायक शामिल किए जाएंगे।

माइग्रेशन और बीज डेटा

इंजन का अपना माइग्रेशन हो सकता है। माइग्रेशन के लिए डिफ़ॉल्ट पथ बिल्कुल वैसा ही है जैसा अनुप्रयोग में है: db/migrate

एप्लिकेशन में इंजन के माइग्रेशन का उपयोग करने के लिए आप नीचे दिए गए रेक कार्य का उपयोग कर सकते हैं, जो उन्हें एप्लिकेशन के डीआईआर में कॉपी करता है:

rake ENGINE_NAME:install:migrations

ध्यान दें कि कुछ माइग्रेशन को छोड़ दिया जा सकता है यदि एक ही नाम वाला माइग्रेशन पहले से ही एप्लिकेशन में मौजूद है। ऐसी स्थिति में आपको यह तय करना होगा कि उस माइग्रेशन को छोड़ना है या एप्लिकेशन में माइग्रेशन को फिर से नाम देना है और माइग्रेशन को फिर से कॉपी करना है।

यदि आपके इंजन में माइग्रेशन है, तो आप db/seeds.rb फ़ाइल में डेटाबेस के लिए डेटा तैयार करना चाहते हैं। आप उस डेटा को load_seed पद्धति का उपयोग करके लोड कर सकते हैं, जैसे

MyEngine::Engine.load_seed

प्राथमिकता लोड हो रही है

इंजन की प्राथमिकता बदलने के लिए आप मुख्य एप्लिकेशन में config.railties_order का उपयोग कर सकते हैं। यह लोडिंग व्यू, हेल्पर्स, एसेट्स और इंजन या एप्लिकेशन से संबंधित अन्य सभी फाइलों को प्राथमिकता से प्रभावित करेगा।

# load Blog::Engine with highest priority, followed by application and other railties
config.railties_order = [Blog::Engine, :main_app, :all]

गुण

बुलाया_फ्रॉम [आरडब्ल्यू]
पृथक [आरडब्ल्यू]
पृथक? [आरडब्ल्यू]

पब्लिक क्लास के तरीके

समापन बिंदु (समापन बिंदु = शून्य) स्रोत दिखाएं
# File railties/lib/rails/engine.rb, line 376
def endpoint(endpoint = nil)
  @endpoint ||= nil
  @endpoint = endpoint if endpoint
  @endpoint
end
# File railties/lib/rails/engine.rb, line 414
def find(path)
  expanded_path = File.expand_path path
  Rails::Engine.subclasses.each do |klass|
    engine = klass.instance
    return engine if File.expand_path(engine.root) == expanded_path
  end
  nil
end

दिए गए रास्ते के साथ इंजन ढूँढता है।

# File railties/lib/rails/engine.rb, line 372
def find_root(from)
  find_root_with_flag "lib", from
end
विरासत में मिला (आधार) दिखाएँ स्रोत
# File railties/lib/rails/engine.rb, line 358
def inherited(base)
  unless base.abstract_railtie?
    Rails::Railtie::Configuration.eager_load_namespaces << base

    base.called_from = begin
      call_stack = caller_locations.map { |l| l.absolute_path || l.path }

      File.dirname(call_stack.detect { |p| p !~ %r[railties[\w.-]*/lib/rails|rack[\w.-]*/lib/rack] })
    end
  end

  super
end
सुपरक्लास विधि कहता है
आइसोलेट_नैप्सस्पेस (mod) स्रोत दिखाएं
# File railties/lib/rails/engine.rb, line 382
def isolate_namespace(mod)
  engine_name(generate_railtie_name(mod.name))

  routes.default_scope = { module: ActiveSupport::Inflector.underscore(mod.name) }
  self.isolated = true

  unless mod.respond_to?(:railtie_namespace)
    name, railtie = engine_name, self

    mod.singleton_class.instance_eval do
      define_method(:railtie_namespace) { railtie }

      unless mod.respond_to?(:table_name_prefix)
        define_method(:table_name_prefix) { "#{name}_" }
      end

      unless mod.respond_to?(:use_relative_model_naming?)
        class_eval "def use_relative_model_naming?; true; end", __FILE__, __LINE__
      end

      unless mod.respond_to?(:railtie_helpers_paths)
        define_method(:railtie_helpers_paths) { railtie.helpers_paths }
      end

      unless mod.respond_to?(:railtie_routes_url_helpers)
        define_method(:railtie_routes_url_helpers) { |include_path_helpers = true| railtie.routes.url_helpers(include_path_helpers) }
      end
    end
  end
end
# File railties/lib/rails/engine.rb, line 427
def initialize
  @_all_autoload_paths = nil
  @_all_load_paths     = nil
  @app                 = nil
  @config              = nil
  @env_config          = nil
  @helpers             = nil
  @routes              = nil
  @app_build_lock      = Mutex.new
  super
end
सुपरक्लास विधि कहता है

सार्वजनिक प्रवृत्ति के तरीके

एप्लिकेशन () स्रोत दिखाएं
# File railties/lib/rails/engine.rb, line 505
def app
  @app || @app_build_lock.synchronize {
    @app ||= begin
      stack = default_middleware_stack
      config.middleware = build_middleware.merge_into(stack)
      config.middleware.build(endpoint)
    end
  }
end

इस इंजन के लिए अंतर्निहित रैक एप्लिकेशन लौटाता है।

# File railties/lib/rails/engine.rb, line 522
def call(env)
  req = build_request env
  app.call req.env
end

इस इंजन के लिए रैक एपीआई को परिभाषित करें।

# File railties/lib/rails/engine.rb, line 541
def config
  @config ||= Engine::Configuration.new(self.class.find_root(self.class.called_from))
end

इंजन के लिए कॉन्फ़िगरेशन ऑब्जेक्ट को परिभाषित करें।

# File railties/lib/rails/engine.rb, line 474
def eager_load!
  config.eager_load_paths.each do |load_path|
    matcher = /\A#{Regexp.escape(load_path.to_s)}\/(.*)\.rb\Z/
    Dir.glob("#{load_path}/**/*.rb").sort.each do |file|
      require_dependency file.sub(matcher, '\1')
    end
  end
end

उत्सुक ने सभी रूबी फ़ाइलों को उत्सुक_लोड पथों के अंदर लोड करके एप्लिकेशन को लोड किया।

समापन बिंदु () दिखाएँ स्रोत
# File railties/lib/rails/engine.rb, line 517
def endpoint
  self.class.endpoint || routes
end

इस इंजन के लिए समापन बिंदु देता है। यदि कोई भी पंजीकृत नहीं है, तो ActionDispatch :: रूटिंग :: रूटसेट में चूक।

# File railties/lib/rails/engine.rb, line 528
def env_config
  @env_config ||= {}
end

प्रत्येक कॉल पर जोड़े जाने वाले अतिरिक्त रैक env कॉन्फ़िगरेशन को परिभाषित करता है।

# File railties/lib/rails/engine.rb, line 488
def helpers
  @helpers ||= begin
    helpers = Module.new
    all = ActionController::Base.all_helpers_from_path(helpers_paths)
    ActionController::Base.modules_for_helpers(all).each do |mod|
      helpers.include(mod)
    end
    helpers
  end
end

इंजन के लिए परिभाषित सभी सहायकों के साथ एक मॉड्यूल लौटाता है।

# File railties/lib/rails/engine.rb, line 500
def helpers_paths
  paths["app/helpers"].existent
end

सभी पंजीकृत हेल्पर्स पथ लौटाता है।

load_console (ऐप = स्वयं) स्रोत दिखाएं
# File railties/lib/rails/engine.rb, line 441
def load_console(app = self)
  require "rails/console/app"
  require "rails/console/helpers"
  run_console_blocks(app)
  self
end

कंसोल को लोड करें और पंजीकृत हुक का आह्वान करें। अधिक जानकारी के लिए Rails::Railtie.console जाँच करें।

load_generators (ऐप = स्वयं) स्रोत दिखाएं
# File railties/lib/rails/engine.rb, line 465
def load_generators(app = self)
  require "rails/generators"
  run_generators_blocks(app)
  Rails::Generators.configure!(app.config.generators)
  self
end

लोड रेल जनरेटर और पंजीकृत हुक आह्वान। अधिक जानकारी के लिए Rails::Railtie.generators जाँच करें।

load_runner (ऐप = स्वयं) स्रोत दिखाएं
# File railties/lib/rails/engine.rb, line 450
def load_runner(app = self)
  run_runner_blocks(app)
  self
end

लोड रनर को लोड करें और पंजीकृत हुक का चालान करें। अधिक जानकारी के लिए Rails::Railtie.runner जाँच करें।

# File railties/lib/rails/engine.rb, line 549
def load_seed
  seed_file = paths["db/seeds.rb"].existent.first
  load(seed_file) if seed_file
end

Db / seeds.rb फ़ाइल से डेटा लोड करें। इसका उपयोग इंजनों के बीजों को लोड करने के लिए किया जा सकता है, जैसे:

ब्लॉग :: Engine.load_seed

load_tasks (ऐप = स्वयं) स्रोत दिखाएं
# File railties/lib/rails/engine.rb, line 457
def load_tasks(app = self)
  require "rake"
  run_tasks_blocks(app)
  self
end

रेक लोड करें, कार्यों को पंजीकृत करें और पंजीकृत हुक का आह्वान करें। अधिक जानकारी के लिए Rails::Railtie.rake_tasks चेक करें।

# File railties/lib/rails/engine.rb, line 483
def railties
  @railties ||= Railties.new
end
# File railties/lib/rails/engine.rb, line 534
def routes
  @routes ||= ActionDispatch::Routing::RouteSet.new_with_config(config)
  @routes.append(&Proc.new) if block_given?
  @routes
end

इस इंजन के लिए मार्गों को परिभाषित करता है। यदि कोई ब्लॉक मार्गों को दिया जाता है, तो इसे इंजन में जोड़ दिया जाता है।

निजी उदाहरण तरीके

load_config_initializer (initializer) स्रोत दिखाएं
# File railties/lib/rails/engine.rb, line 655
def load_config_initializer(initializer) # :doc:
  ActiveSupport::Notifications.instrument("load_config_initializer.railties", initializer: initializer) do
    load(initializer)
  end
end