rails initializers ruby-on-rails ruby configuration environment

ruby-on-rails - rails initializers



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

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?

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

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

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

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

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.

Prefiero acceder a la configuración a través de la pila 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"]

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)

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.

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

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]

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'']

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