¿La mejor manera de crear opciones de configuración personalizadas para mi aplicación Rails?

Necesito crear una opción de configuración para mi aplicación Rails. Puede ser el mismo para todos los ambientes. Descubrí que si lo configuro en 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 manera 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 archivo config.yml 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 puedes 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 inicialización es la siguiente (RAILS_ROOT & 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 utiliza Psych, lo que hace que las claves de combinación distingan entre mayúsculas y minúsculas, por lo que tendrás que cambiar tu archivo de configuración para tenerlo en cuenta, por ej.

 defaults: &DEFAULTS audiocast_uri_format: http://blablalba/blabbitybla/yadda development: <<: *DEFAULTS test: <<: *DEFAULTS production: <<: *DEFAULTS 

Rieles> = 4.2

Simplemente cree un archivo YAML en config/ directory, por ejemplo: config/neo4j.yml .

El contenido de neo4j.yml puede ser algo así como a continuación (para simplificar, utilicé 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 de la siguiente manera:

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

Más información

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

Conveniencia para cargar config / foo.yml para los envios Rails actuales


Si no quieres usar un archivo yaml

Como dice la guía oficial de Rails:

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

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 método config_for | Guía oficial de carriles

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: crea config / config.yml

 common: &common facebook: key: 'asdjhasxas' secret : 'xyz' twitter: key: 'asdjhasxas' secret : 'abx' development: <<: *common test: <<: *common production: <<: *common 

Paso 3: Obtenga 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 novedades en Rails 4.2 y 5, ahora puede hacer esto dentro de cualquiera de sus archivos config/**/*.rb :

 config.x.whatever = 42 

(y eso es un literal x allí, es decir, el config.x. literalmente debe ser eso, y luego puedes agregar lo que quieras después de la x )

… y esto estará disponible en tu aplicación como:

 Rails.configuration.x.whatever 

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

Solo algo de información extra 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 usando una clave de cadena o con una tecla 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 puramente una cosa conveniente, pero prefiero que mis llaves se representen como símbolos.

Utilizo algo similar a John for Rails 3.0 / 3.1, pero primero tengo que analizar el archivo erb:

 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 un yaml de configuración personalizado y cargarlo (y ponerlo a disposición de su aplicación) de forma similar a cómo database_configuration .

Crea tu *.yml , en mi caso necesitaba un archivo de configuración 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 carga 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] similar a cómo puede tener acceso a su database.yml por Rails.configuration.database_configuration[Rails.env]

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

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

Esto le permite luego referenciar los valores por símbolos como teclas, por ejemplo

 AppConfig[:twitter][:key] 

Esto parece más limpio para mis ojos.

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

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

ver 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 en que es una referencia simple a otro archivo. Se 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 la forma de Rails?”, Tal vez habrá una discusión sobre eso.

Prefiero acceder a la configuración a través de la stack de aplicaciones globales. 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 acceda con.

 MyAppName::Application.myconfig["yamlstuff"] 

Mi forma de cargar Configuraciones antes de que Rails se inicialice

Le permite usar la configuración en la inicialización de Rails y configurar las configuraciones 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 [’email’] o Configuración.email

Mi mejor forma de configuración personalizada, con 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] 

Crea 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