Rails 3 wersja kodu inicjującego jest następująca (rails_root & RAILS_ENV są przestarzałe)

APP_CONFIG = YAML.load_file(Rails.root.join('config', 'config.yml'))[Rails.env]

Również Ruby 1.9.3 używa Psych, co uwrażliwia wielkość liter kluczy scalających, więc musisz zmienić plik konfiguracyjny, aby wziąć to pod uwagę, np.

defaults: &DEFAULTS
  audiocast_uri_format: http://blablalba/blabbitybla/yadda

development:
  <<: *DEFAULTS

test:
  <<: *DEFAULTS

production:
  <<: *DEFAULTS

Szyny >= 4.2

Wystarczy utworzyć plik YAML do katalogu config/, na przykład: config/neo4j.yml.

Zawartość neo4j.yml może być taka jak poniżej (dla uproszczenia użyłem domyślnego dla wszystkich środowisk):

default: &default
  host: localhost
  port: 7474
  username: neo4j
  password: root

development:
  <<: *default

test:
  <<: *default

production:
  <<: *default

W config/application.rb:

module MyApp
  class Application < Rails::Application
    config.neo4j = config_for(:neo4j)
  end
end

Teraz Twój niestandardowy config jest dostępny jak poniżej:

Rails.configuration.neo4j['host'] #=>localhost
Rails.configuration.neo4j['port'] #=>7474

Więcej informacji

Rails oficjalny dokument API opisuje metodę config_for jako:

Wygoda załadunku config / foo.yml dla bieżącego Rails env.

Jeśli nie chcesz używać pliku yaml

Jak mówi oficjalny przewodnik Rails:

Możesz skonfigurować swój własny kod poprzez obiekt rails configuration z niestandardową konfiguracją pod właściwością config.x.

Przykład

config.x.payment_processing.schedule = :daily
config.x.payment_processing.retries  = 3
config.x.super_debugger = true

Te punkty konfiguracyjne są następnie dostępne poprzez konfigurację obiekt:

Rails.configuration.x.payment_processing.schedule # => :daily
Rails.configuration.x.payment_processing.retries  # => 3
Rails.configuration.x.super_debugger              # => true
Rails.configuration.x.super_debugger.not_set      # => nil

Oficjalne odniesienie do metody config_for | Official Rails Guide

Krok 1: Utwórz config/initializers / appconfig.rb

require 'ostruct'
require 'yaml'

all_config = YAML.load_file("#{Rails.root}/config/config.yml") || {}
env_config = all_config[Rails.env] || {}
AppConfig = OpenStruct.new(env_config)

Krok 2: Utwórz config / config.yml

common: &common
  facebook:
    key: 'asdjhasxas'
    secret : 'xyz'
  twitter:
    key: 'asdjhasxas'
    secret : 'abx'

development:
  <<: *common

test:
  <<: *common

production:
  <<: *common

Krok 3: Pobierz stałe w dowolnym miejscu kodu

facebook_key = AppConfig.facebook['key']
twitter_key  = AppConfig.twitter['key']

Chciałem tylko zaktualizować to dla najnowszych fajnych rzeczy w Rails 4.2 i 5, Teraz możesz to zrobić w dowolnym pliku config/**/*.rb:

config.x.whatever = 42

(i to jest literalne x tam, tj. config.x. dosłownie to musi być, a potem możesz dodać co chcesz po x)

...i to będzie dostępne w aplikacji jako:

Rails.configuration.x.whatever

Zobacz więcej tutaj: http://guides.rubyonrails.org/configuring.html#custom-configuration

Tylko kilka dodatkowych informacji na ten temat:

APP_CONFIG = YAML.load_file(Rails.root.join('config', 'config.yml'))[Rails.env].with_indifferent_access

".with_indifferent_access " umożliwia dostęp do wartości w hash za pomocą klucza łańcuchowego lub równoważnego klucza symbolu.

Np.
APP_CONFIG['audiocast_uri_format'] => 'http://blablalba/blabbitybla/yadda' APP_CONFIG[:audiocast_uri_format] => 'http://blablalba/blabbitybla/yadda'

Używam czegoś podobnego do Johna dla Rails 3.0/3.1, ale erb najpierw parsuje plik:

APP_CONFIG = YAML.load(ERB.new(File.new(File.expand_path('../config.yml', __FILE__)).read).result)[Rails.env]

To pozwala mi używać ERB w moim config, jeśli muszę, jak czytanie heroku redistogo url:

production:
  <<: *default
  redis:                  <%= ENV['REDISTOGO_URL'] %>

Rails 4

Aby utworzyć niestandardową konfigurację yaml i załadować ją (i udostępnić swojej aplikacji) w podobny sposób jak database_configuration.

Utwórz swój *.yml, w moim przypadku potrzebowałem pliku konfiguracyjnego redis.

config/redis.yml

default: &default
  host: localhost
  port: 6379

development:
  <<: *default

test:
  <<: *default

production:
  <<: *default
  host: <%= ENV['ELASTICACHE_HOST'] %>
  port: <%= ENV['ELASTICACHE_PORT'] %>

Następnie załaduj konfigurację

config/application.rb

module MyApp
  class Application < Rails::Application

    ## http://guides.rubyonrails.org/configuring.html#initialization-events
    config.before_initialize do
      Rails.configuration.redis_configuration = YAML.load_file("#{Rails.root}/config/redis.yml")
    end

  end
end

Dostęp do wartości:

Rails.configuration.redis_configuration[Rails.env] podobne do jak możesz mieć dostęp do swojego database.yml przez Rails.configuration.database_configuration[Rails.env]

Bazując na eleganckim rozwiązaniu Omer Aslam, postanowiłem zamienić klucze na symbole. Jedyna zmiana to:

all_config = YAML.load_file("#{Rails.root}/config/config.yml").with_indifferent_access || {}

Pozwala to na odwoływanie się do wartości za pomocą symboli jako kluczy, np.

AppConfig[:twitter][:key]

(Posted as an answer as my reputation isn 't such high to comment on Omer' s reply)

Lubię simpleconfig. Pozwala na konfigurację środowiska.

Zobacz moją odpowiedź na Gdzie najlepiej przechowywać parametry aplikacji: baza danych, plik, kod...?

Odmiana tego, co miałeś w tym, że jest to proste odniesienie do innego pliku. Widzi to środowisko.RB nie jest stale aktualizowany i nie ma sterty konkretnych rzeczy w aplikacji. Chociaż nie jest to konkretna odpowiedź na twoje pytanie " czy to droga szynowa?', być może będzie tam jakaś dyskusja na ten temat.

Preferuję dostęp do ustawień poprzez globalny stos aplikacji. Unikam nadmiernych zmiennych globalnych w zasięgu lokalnym.

Config/initializers / myconfig.rb

MyAppName::Application.define_singleton_method("myconfig") {YAML.load_file("#{Rails.root}/config/myconfig.yml") || {}}

I uzyskać do niego dostęp.

MyAppName::Application.myconfig["yamlstuff"]

Mój sposób na załadowanie ustawień przed zainicjalizowaniem Rails

Pozwala używać ustawień w inicjalizacji Rails i konfigurować ustawienia dla środowiska

# config/application.rb
Bundler.require(*Rails.groups)

mode = ENV['RAILS_ENV'] || 'development'
file = File.dirname(__FILE__).concat('/settings.yml')
Settings = YAML.load_file(file).fetch(mode)
Settings.define_singleton_method(:method_missing) {|name| self.fetch(name.to_s, nil)}

Można uzyskać ustawienia na dwa sposoby: Settings ['email'] lub Settings.e-mail

Mój najlepszy sposób na niestandardową konfigurację, z Komunikatem raise podczas ustawiania.yml zaginął.

Jest ładowany z niestandardowego inicjalizatora w config/initializers / custom_config.rb

setting_config = File.join(Rails.root,'config','setting.yml')
raise "#{setting_config} is missing!" unless File.exists? setting_config
config = YAML.load_file(setting_config)[Rails.env].symbolize_keys

@APP_ID = config[:app_id]
@APP_SECRET = config[:app_secret]

Utwórz YAML w config / setting.yml

development:
  app_id: 433387212345678
  app_secret: f43df96fc4f65904083b679412345678

test:
  app_id: 148166412121212
  app_secret: 7409bda8139554d11173a32222121212

production:
  app_id: 148166412121212
  app_secret: 7409bda8139554d11173a32222121212