web-dev-qa-db-fra.com

Le meilleur moyen de créer des options de configuration personnalisées pour mon application Rails?

Je dois créer une option de configuration pour mon application Rails. Cela peut être la même pour tous les environnements. J'ai constaté que si je le configurais dans environment.rb, il était disponible dans mes vues, ce qui est exactement ce que je veux ...

environment.rb

AUDIOCAST_URI_FORMAT = http://blablalba/blabbitybla/yadda

Fonctionne très bien.

Cependant, je suis un peu inquiet. Est-ce une bonne façon de le faire? Y a-t-il un moyen plus branché?

ruby-on-railsrubyconfigurationenvironment
130
Ethan

Pour une configuration d'application générale qui n'a pas besoin d'être stockée dans une table de base de données, j'aime créer un fichier config.yml dans le répertoire config. Pour votre exemple, cela pourrait ressembler à ceci:

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

development:
  <<: *defaults

test:
  <<: *defaults

production:
  <<: *defaults

Ce fichier de configuration est chargé à partir d'un initialiseur personnalisé dans 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 vous utilisez Rails 3, veillez à ne pas ajouter accidentellement de barre oblique au chemin de configuration relatif.

Vous pouvez ensuite récupérer la valeur en utilisant:

uri_format = APP_CONFIG['audiocast_uri_format']

Voir ce Railscast pour plus de détails.

189
John Topley

La version Rails 3 du code d’initialisation est la suivante (Rails_ROOT & Rails_ENV sont obsolètes)

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

De plus, Ruby 1.9.3 utilise Psych qui rend les touches de fusion sensibles à la casse; vous devrez donc modifier votre fichier de configuration pour en tenir compte, par exemple.

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

development:
  <<: *DEFAULTS

test:
  <<: *DEFAULTS

production:
  <<: *DEFAULTS
82
David Burrows

Étape 1: Créer 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)

Étape 2: Créer config/config.yml 

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

development:
  <<: *common

test:
  <<: *common

production:
  <<: *common

Étape 3: Obtenez des constantes n'importe où dans le code 

facebook_key = AppConfig.facebook['key']
Twitter_key  = AppConfig.Twitter['key']
24
Omer Aslam

Je voulais juste mettre à jour ceci pour les dernières nouveautés intéressantes dans Rails 4.2 et 5, vous pouvez maintenant le faire dans n'importe lequel de vos fichiers config/**/*.rb:

config.x.whatever = 42

(et c'est une valeur x littérale, c'est-à-dire que le config.x. doit être littéralement ce que vous voulez, et vous pouvez ensuite ajouter ce que vous voulez après la x)

... et cela sera disponible dans votre application en tant que:

Rails.configuration.x.whatever

Voir plus ici: http://guides.rubyonrails.org/configuring.html#custom-configuration

18
smathy

Quelques informations supplémentaires sur ce sujet:

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

".with_indifferent_access" vous permet d'accéder aux valeurs du hachage en utilisant une clé de chaîne ou une clé de symbole équivalente.

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

Pour des raisons pratiques, mais je préfère que mes clés soient représentées par des symboles.

6
foomip

J'utilise quelque chose de similaire à John pour Rails 3.0/3.1, mais je dois d'abord analyser le fichier erb:

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

Cela me permet d’utiliser ERB dans ma configuration si besoin est, comme lire l’URL du redistogo de heroku:

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

Rails 4

Pour créer une configuration personnalisée yaml et la charger (et la rendre disponible pour votre application) de la même manière que database_configuration.

Créez votre *.yml, dans mon cas, j'avais besoin d'un fichier de configuration Redis.

config/redis.yml

default: &default
  Host: localhost
  port: 6379

development:
  <<: *default

test:
  <<: *default

production:
  <<: *default
  Host: <%= ENV['ELASTICACHE_Host'] %>
  port: <%= ENV['ELASTICACHE_PORT'] %>

Puis chargez la configuration

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

Accédez aux valeurs:

Rails.configuration.redis_configuration[Rails.env] similaire à la manière dont vous pouvez accéder à votre database.yml par Rails.configuration.database_configuration[Rails.env]

2
twmulloy

S'appuyant sur la solution élégante de Omer Aslam, j'ai décidé de convertir les clés en symboles. Le seul changement est:

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

Cela vous permet ensuite de référencer des valeurs par des symboles sous forme de clés, par exemple.

AppConfig[:Twitter][:key]

Cela semble plus propre à mes yeux.

(Posté comme une réponse car ma réputation n'est pas assez élevée pour commenter la réponse de Omer)

1
Kitebuggy

J'aime simpleconfig . Cela vous permet d'avoir une configuration par environnement.

0
Jerry Cheung

Ma façon de charger les paramètres avant l'initialisation de Rails

Vous permet d'utiliser les paramètres d'initialisation Rails et de configurer les paramètres par environnement

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

Vous pouvez obtenir les paramètres de deux manières: Paramètres ['email'] ou Settings.email

0
greenif

voir ma réponse à Où est le meilleur endroit pour stocker les paramètres d'application: base de données, fichier, code ...?

Une variation de ce que vous avez eu en ce sens qu'il s'agit d'une simple référence à un autre fichier. Il voit que environment.rb n'est pas constamment mis à jour et ne contient pas un tas de choses spécifiques aux applications. Bien que vous ne trouviez pas de réponse précise à votre question, est-ce que cela fera l’objet d’une discussion?.

0
Straff

Je préfère accéder aux paramètres via la pile d'applications globale. J'évite les excès de variables globales dans la portée locale.

config/initializers/myconfig.rb 

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

Et y accéder avec.

MyAppName::Application.myconfig["yamlstuff"]
0
6ft Dan

Mon meilleur moyen de personnaliser la configuration, avec un message de relance lorsque setting.yml est manquant.

est chargé à partir d'un initialiseur personnalisé dans 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]

Créez un fichier YAML dans config/setting.yml

development:
  app_id: 433387212345678
  app_secret: f43df96fc4f65904083b679412345678

test:
  app_id: 148166412121212
  app_secret: 7409bda8139554d11173a32222121212

production:
  app_id: 148166412121212
  app_secret: 7409bda8139554d11173a32222121212
0
Marcelo Austria