ruby-on-rails - rails initializers

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

Question

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?

Answer 1

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

Answer 2

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

Answer 3

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

Answer 4

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

Answer 5

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.

Answer 6

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

Answer 7

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)

Answer 8

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.

Answer 9

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

Answer 10

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

Answer 11

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.

Answer 12

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]

Answer 13

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

Answer 14

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