Mise à jour 1

Très recommandé: je vais avec Rails Config Gem de nos jours pour le contrôle fin fourni.

Mise à jour2

Si vous voulez une solution rapide, vérifiez la réponse de Jack Pratt ci-dessous.

Bien que ma réponse originale ci-dessous fonctionne toujours, cette réponse est maintenant obsolète. Je recommande de regarder les mises à jour 1 et 2.

Réponse originale:

Pour une solution rapide, regarder l’ écran “YAML Configuration File” de Ryan Bates devrait être très utile.

En résumé:

# config/initializers/load_config.rb APP_CONFIG = YAML.load_file("#{Rails.root}/config/config.yml")[Rails.env] # application.rb if APP_CONFIG['perform_authentication'] # Do stuff end 

Dans Rails 3, les données de configuration personnalisées spécifiques à l’application peuvent être placées dans l’object de configuration de l’application. La configuration peut être affectée dans les fichiers d’initialisation ou les fichiers d’environnement, par exemple pour une application donnée MyApp :

 MyApp::Application.config.custom_config_variable = :my_config_setting 

ou

 Rails.configuration.custom_config_variable = :my_config_setting 

Pour lire le paramètre, appelez simplement la variable de configuration sans la définir:

 Rails.configuration.custom_config_variable => :my_config_setting 

UPDATE Rails 4

Dans Rails 4, il existe une nouvelle méthode pour cela => http://guides.rubyonrails.org/configuring.html#custom-configuration

Dans Rails 3.0.5, l’approche suivante a fonctionné pour moi:

Dans config/environments/development.rb , écrivez

 config.custom_config_key = :config_value 

La valeur custom_config_key peut ensuite être référencée à partir d’autres fichiers en utilisant

 Rails.application.config.custom_config_key 

Cela fonctionne dans les rails 3.1:

dans config / environment.rb (ou dans config / environnements / .. pour cibler un environnement spécifique):

 YourApp::Application.config.yourKey = 'foo' 

Ce sera accessible dans le contrôleur ou les vues comme ceci:

 YourApp::Application.config.yourKey 

(Votre application doit être remplacée par le nom de votre application.)

Note : C’est du code Ruby, donc si vous avez beaucoup de clés de configuration, vous pouvez le faire:

dans config / environment.rb:

 YourApp::Application.configure do config.something = foo config..... config.... . config.... end 

Dans les rails 4

En supposant que vous mettez vos variables personnalisées dans un fichier yaml:

 # config/acme.yml development: :api_user: 'joe' :api_pass: 's4cret' :timeout: 20 

Créez un initialiseur pour les charger:

 # config/initializers/acme.rb acme_config = Rails.application.config_for :acme Rails.application.configure do config.acme = ActiveSupport::OrderedOptions.new config.acme.api_user = acme_config[:api_user] config.acme.api_pass = acme_config[:api_pass] config.acme.timeout = acme_config[:timeout] end 

Maintenant, n’importe où dans votre application, vous pouvez accéder à ces valeurs comme suit:

 Rails.configuration.acme.api_user 

Il est pratique que Rails.application.config_for :acme charge votre acme.yml et utilise l’environnement correct.

Depuis Rails 4.2, sans gemmes supplémentaires, vous pouvez charger config / hi.yml simplement en utilisant Rails.application.config_for :hi .

Par exemple:

1. touch config/passwords.yml

     #config/passwords.yml development: username: 'a' password: 'b' production: username: 'aa' password: 'bb' 

2. touch config/initializers/constants.rb

    #config/initializers/constants.rb AUTHENTICATION = Rails.application.config_for :passwords 

3. et maintenant vous pouvez utiliser AUTHENTICATION constante partout dans votre application:

    #rails c production :001> AUTHENTICATION['username'] => 'aa' 

4. puis ajoutez passwords.yml à .gitignore : echo /config/passwords.yml >> .gitignore , créez un exemple de fichier pour votre confort cp /config/passwords.yml /config/passwords.example.yml et modifiez simplement votre fichier exemple dans votre console de production avec les valeurs de production réelles.

Je voulais juste mettre à jour ceci pour les derniers trucs sympas dans Rails 4.2, vous pouvez maintenant le faire avec n’importe lequel de vos fichiers config/**/*.rb :

 config.x.whatever.you.want = 42 

… et ce sera disponible dans votre application comme:

 Rails.configuration.x.whatever.you.want 

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

Jetez un coup d’œil à ce joyau en faisant exactement cela: https://github.com/mislav/choices

De cette façon, vos données sensibles ne seront pas exposées dans les projets open source.

J’ai créé un plugin simple pour les parameters YAML: Yettings

Cela fonctionne de la même manière que le code dans la réponse de khelll, mais il vous suffit d’append ce fichier de configuration YAML:

 app/config/yetting.yml 

Le plug-in crée dynamicment une classe qui vous permet d’accéder aux parameters YML en tant que méthodes de classe dans votre application, comme ceci:

 Yetting.your_setting 

En outre, si vous souhaitez utiliser plusieurs fichiers de parameters avec des noms uniques, vous pouvez les placer dans un sous-répertoire de l’application / config comme suit:

 app/config/yettings/first.yml app/config/yettings/second.yml 

Ensuite, vous pouvez accéder aux valeurs comme ceci:

 FirstYetting.your_setting SecondYetting.your_setting 

Il vous fournit également des parameters par défaut qui peuvent être remplacés par environnement. Vous pouvez également utiliser erb dans le fichier yml.

J’aime vraiment la gemme settingslogic . Très facile à configurer et à utiliser.

https://github.com/binarylogic/settingslogic

Si vous utilisez Heroku ou si vous avez besoin de conserver les parameters de votre application en tant que variables d’environnement, le gem figaro est très utile.

J’aime utiliser les parameters de rails pour les valeurs de configuration globales qui doivent être modifiables via l’interface Web.

Quelque chose que nous commençons à faire au travail, c’est le hachage commandé ActiveSupport

Ce qui vous permet de définir correctement votre configuration dans les fichiers d’environnement, par exemple

 config.service = ActiveSupport::OrderedOptions.new config.service.api_key = ENV['SERVICE_API_KEY'] config.service.shared_secret = ENV['SERVICE_SHARED_SECRET'] 

Je suggère une bonne approche pour gérer la configuration dans votre application. Il y a trois règles de base:

• changer votre configuration pas un code;
• utiliser des configurations sur des conditions;
• écrire du code qui signifie quelque chose.

Pour avoir un aperçu plus détaillé, suivez ce lien: Configuration de Rails de la manière appropriée