Necesito crear una opción de configuración para mi aplicación Rails. Puede ser igual para todos los entornos. Descubrí que si lo configuro environment.rb, está disponible en mis vistas, que es exactamente lo que quiero ...

environment.rb

AUDIOCAST_URI_FORMAT = http://blablalba/blabbitybla/yadda

Funciona genial.

Sin embargo, estoy un poco incómodo. ¿Es esta una buena forma de hacerlo? ¿Hay alguna manera que sea más moderna?

Para la configuración general de la aplicación que no necesita almacenarse en una tabla de base de datos, me gusta crear un config.ymlarchivo dentro del directorio de configuración . Para su ejemplo, podría verse así:

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

development:
  <<: *defaults

test:
  <<: *defaults

production:
  <<: *defaults

Este archivo de configuración se carga desde un inicializador personalizado en 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]

Si está utilizando Rails 3, asegúrese de no agregar accidentalmente una barra diagonal a su ruta de configuración relativa.

Luego puede recuperar el valor usando:

uri_format = APP_CONFIG['audiocast_uri_format']

Vea este Railscast para más detalles.

La versión de Rails 3 del código de inicializador es la siguiente (RAILS_ROOT y RAILS_ENV están en desuso)

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

Además, Ruby 1.9.3 usa Psych, que hace que las teclas de combinación distingan entre mayúsculas y minúsculas, por lo que deberá cambiar su archivo de configuración para tenerlo en cuenta, por ejemplo

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

development:
  <<: *DEFAULTS

test:
  <<: *DEFAULTS

production:
  <<: *DEFAULTS

Rieles> = 4.2

Basta con crear un YAMLarchivo en config/el directorio, por ejemplo: config/neo4j.yml.

El contenido de neo4j.ymlpuede ser algo como a continuación (por simplicidad, usé el valor predeterminado para todos los entornos):

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

development:
  <<: *default

test:
  <<: *default

production:
  <<: *default

en config/application.rb:

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

Ahora, su configuración personalizada es accesible como a continuación:

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

Más información

El documento API oficial de Rails describe el config_formétodo como:

Conveniencia para cargar config / foo.yml para el entorno actual de Rails.

Si no quieres usar un yamlarchivo

Como dice la guía oficial de Rails:

Puede configurar su propio código a través del objeto de configuración Rails con una configuración personalizada en la config.xpropiedad.

Ejemplo

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

Estos puntos de configuración están disponibles a través del objeto de configuración:

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

Referencia oficial para el config_formétodo | Guía oficial de rieles

Paso 1: Crear 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)

Paso 2: Crear config / config.yml

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

development:
  <<: *common

test:
  <<: *common

production:
  <<: *common

Paso 3: obtén constantes en cualquier parte del código

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

Solo quería actualizar esto para las últimas cosas interesantes en Rails 4.2 y 5, ahora puede hacerlo dentro de cualquiera de sus config/**/*.rbarchivos:

config.x.whatever = 42

(y ese es un literal xallí, es decir, config.x.literalmente debe ser eso, y luego puede agregar lo que quiera después del x)

... y esto estará disponible en su aplicación como:

Rails.configuration.x.whatever

Ver más aquí: http://guides.rubyonrails.org/configuring.html#custom-configuration

Solo información adicional sobre este tema:

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

".with_indifferent_access" le permite acceder a los valores en el hash utilizando una clave de cadena o con una clave de símbolo equivalente.

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

Es una cuestión de conveniencia, pero prefiero que mis teclas se representen como símbolos.

Utilizo algo similar a John para Rails 3.0 / 3.1, pero primero heb analizar el archivo:

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

Esto me permite usar ERB en mi configuración si es necesario, como leer la url de redistogo de heroku:

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

Rails 4

Para crear una configuración personalizada yaml y cargarla (y ponerla a disposición de su aplicación) similar a cómo database_configuration.

Crea tu *.yml, en mi caso necesitaba un archivo de configuración de redis.

config/redis.yml

default: &default
  host: localhost
  port: 6379

development:
  <<: *default

test:
  <<: *default

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

Luego cargue la configuración

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

Acceda a los valores:

Rails.configuration.redis_configuration[Rails.env]a semejante cómo se puede tener acceso a su database.ymlporRails.configuration.database_configuration[Rails.env]

Partiendo de la elegante solución de Omer Aslam, decidí convertir las teclas en símbolos. El único cambio es:

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

Esto le permite luego hacer referencia a valores mediante símbolos como teclas, por ejemplo

AppConfig[:twitter][:key]

Esto me parece más ordenado a mis ojos.

(Publicado como respuesta ya que mi reputación no es lo suficientemente alta como para comentar la respuesta de Omer)

Me gusta simpleconfig . Le permite tener una configuración por entorno.

vea mi respuesta a ¿Dónde está el mejor lugar para almacenar los parámetros de la aplicación: base de datos, archivo, código ...?

Una variación de lo que tenía es que es una simple referencia a otro archivo. Ve que environment.rb no se actualiza constantemente y no tiene un montón de cosas específicas de la aplicación. Aunque no es una respuesta específica a su pregunta de '¿es el camino de Rails?', Tal vez habrá alguna discusión al respecto.

Prefiero acceder a la configuración a través de la pila global de aplicaciones. Evito el exceso de variables globales en el ámbito local.

config / initializers / myconfig.rb

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

Y accede a él con.

MyAppName::Application.myconfig["yamlstuff"]

Mi forma de cargar la configuración antes de que Rails se inicialice

Le permite usar la configuración en la inicialización de Rails y configurar los ajustes por entorno

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

Puede obtener la configuración de dos maneras: Configuración ['correo electrónico'] o Configuración.email

Mi mejor forma de configuración personalizada, con un mensaje de aumento cuando falta setting.yml.

se carga desde un inicializador personalizado en 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]

Cree un YAML en config / setting.yml

development:
  app_id: 433387212345678
  app_secret: f43df96fc4f65904083b679412345678

test:
  app_id: 148166412121212
  app_secret: 7409bda8139554d11173a32222121212

production:
  app_id: 148166412121212
  app_secret: 7409bda8139554d11173a32222121212