Saya perlu membuat satu opsi konfigurasi untuk aplikasi Rails saya. Ini bisa sama untuk semua lingkungan. Saya menemukan bahwa jika saya mengaturnya environment.rb, itu tersedia dalam pandangan saya, yang persis seperti yang saya inginkan ...

environment.rb

AUDIOCAST_URI_FORMAT = http://blablalba/blabbitybla/yadda

Bagus sekali.

Namun, saya sedikit gelisah. Apakah ini cara yang baik untuk melakukannya? Apakah ada cara yang lebih modern?

Untuk konfigurasi aplikasi umum yang tidak perlu disimpan dalam tabel database, saya ingin membuat config.ymlfile di dalam direktori config . Sebagai contoh Anda, ini mungkin terlihat seperti ini:

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

development:
  <<: *defaults

test:
  <<: *defaults

production:
  <<: *defaults

File konfigurasi ini diambil dari penginisialisasi khusus di config / initializers :

# Rails 2
APP_CONFIG = YAML.load_file("#{RAILS_ROOT}/config/config.yml")[RAILS_ENV]

# Rails 3+
APP_CONFIG = YAML.load_file(Rails.root.join('config/config.yml'))[Rails.env]

Jika Anda menggunakan Rails 3, pastikan Anda tidak secara tidak sengaja menambahkan garis miring terkemuka ke jalur konfigurasi relatif Anda.

Anda kemudian dapat mengambil nilai menggunakan:

uri_format = APP_CONFIG['audiocast_uri_format']

Lihat Railscast ini untuk detail selengkapnya.

Versi Rails 3 kode initialiser adalah sebagai berikut (RAILS_ROOT & RAILS_ENV tidak digunakan lagi)

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

Selain itu, Ruby 1.9.3 menggunakan Psikologi yang membuat menggabungkan huruf besar-kecil sehingga Anda perlu mengubah file konfigurasi Anda untuk memperhitungkannya, misalnya

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

development:
  <<: *DEFAULTS

test:
  <<: *DEFAULTS

production:
  <<: *DEFAULTS

Rails> = 4.2

Hanya membuat YAMLfile ke config/direktori, misalnya: config/neo4j.yml.

Konten neo4j.ymldapat berupa sesuatu seperti di bawah ini (Untuk kesederhanaan, saya menggunakan default untuk semua lingkungan):

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

development:
  <<: *default

test:
  <<: *default

production:
  <<: *default

di config/application.rb:

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

Sekarang, konfigurasi khusus Anda dapat diakses seperti di bawah ini:

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

Info lebih lanjut

Dokumen API resmi Rails menjelaskan config_formetode sebagai:

Kenyamanan untuk memuat config / foo.yml untuk Rails saat ini env.

Jika Anda tidak ingin menggunakan yamlfile

Seperti yang dikatakan panduan resmi Rails:

Anda dapat mengonfigurasi kode Anda sendiri melalui objek konfigurasi Rails dengan konfigurasi khusus di bawah config.xproperti.

Contoh

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

Titik-titik konfigurasi ini kemudian tersedia melalui objek konfigurasi:

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

Referensi Resmi untuk config_formetode | Panduan Rel Resmi

Langkah 1: Buat 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)

Langkah 2: Buat config / config.yml

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

development:
  <<: *common

test:
  <<: *common

production:
  <<: *common

Langkah 3: Dapatkan konstanta di mana saja dalam kode

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

Saya hanya ingin memperbarui ini untuk hal-hal keren terbaru di Rails 4.2 dan 5, sekarang Anda dapat melakukan ini di dalam salah satu config/**/*.rbfile Anda :

config.x.whatever = 42

(dan itu literal xdi sana, mis. yang config.x.harfiah harus itu, dan kemudian Anda dapat menambahkan apa pun yang Anda inginkan setelahx )

... dan ini akan tersedia di aplikasi Anda sebagai:

Rails.configuration.x.whatever

Lihat lebih lanjut di sini: http://guides.rubyonrails.org/configuring.html#custom-configuration

Hanya beberapa info tambahan tentang topik ini:

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

".with_indifferent_access" memungkinkan Anda untuk mengakses nilai-nilai dalam hash menggunakan kunci string atau dengan kunci simbol yang setara.

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

Benar-benar hal yang mudah, tetapi saya lebih suka kunci saya direpresentasikan sebagai simbol.

Saya menggunakan sesuatu yang mirip dengan John for Rails 3.0 / 3.1, tapi saya harus parsing file terlebih dahulu:

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

Ini memungkinkan saya untuk menggunakan ERB dalam konfigurasi saya jika perlu, seperti membaca url redistogo heroku:

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

Rails 4

Untuk membuat yaml konfigurasi khusus dan memuatnya (dan membuatnya tersedia untuk aplikasi Anda) mirip dengan caranya database_configuration .

Buat Anda *.yml, dalam kasus saya, saya memerlukan file konfigurasi redis.

config/redis.yml

default: &default
  host: localhost
  port: 6379

development:
  <<: *default

test:
  <<: *default

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

Kemudian muat konfigurasi

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

Akses nilai-nilai:

Rails.configuration.redis_configuration[Rails.env]mirip dengan bagaimana Anda dapat memiliki akses ke database.ymloleh AndaRails.configuration.database_configuration[Rails.env]

Membangun solusi elegan Omer Aslam, saya memutuskan untuk mengubah kunci menjadi simbol. Satu-satunya perubahan adalah:

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

Ini memungkinkan Anda untuk kemudian merujuk nilai dengan simbol sebagai kunci, misalnya

AppConfig[:twitter][:key]

Ini terlihat lebih rapi di mataku.

(Diposting sebagai jawaban karena reputasi saya tidak cukup tinggi untuk mengomentari balasan Omer)

Saya suka simpleconfig . Ini memungkinkan Anda untuk memiliki konfigurasi per lingkungan.

lihat tanggapan saya terhadap Di mana tempat terbaik untuk menyimpan parameter aplikasi: database, file, kode ...?

Variasi untuk apa yang Anda miliki sebagai referensi sederhana ke file lain. Ia melihat bahwa environment.rb tidak selalu diperbarui dan tidak memiliki banyak hal khusus aplikasi di dalamnya. Meskipun bukan jawaban spesifik untuk pertanyaan Anda tentang 'apakah itu jalan Rails?', Mungkin akan ada beberapa diskusi di sana tentang itu.

Saya lebih suka mengakses pengaturan melalui tumpukan aplikasi global. Saya menghindari kelebihan variabel global dalam lingkup lokal.

config / initializers / myconfig.rb

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

Dan akses dengan.

MyAppName::Application.myconfig["yamlstuff"]

Cara saya memuat Pengaturan sebelum Rail diinisialisasi

Memungkinkan Anda menggunakan pengaturan dalam inisialisasi Rails dan mengonfigurasi pengaturan per lingkungan

# 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)}

Anda bisa mendapatkan pengaturan dengan dua cara: Pengaturan ['email'] atau Settings.email

Cara terbaik saya untuk konfigurasi kustom, dengan memunculkan pesan ketika setting.yml tidak ada.

akan dimuat dari penginisialisasi kustom di 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]

Buat YAML di config / setting.yml

development:
  app_id: 433387212345678
  app_secret: f43df96fc4f65904083b679412345678

test:
  app_id: 148166412121212
  app_secret: 7409bda8139554d11173a32222121212

production:
  app_id: 148166412121212
  app_secret: 7409bda8139554d11173a32222121212