Je me demandais comment ajouter des variables de configuration personnalisées à une application rails et comment y accéder dans le contrôleur, par exemple, je veux pouvoir définir un répertoire de téléchargement dans les fichiers de configuration, dites development.rb et pouvoir y accéder dans l'un de mes contrôleurs.

Deuxièmement, je prévoyais d'avoir le support S3 pour les téléchargements dans mon application, si je voulais ajouter un fichier yaml avec l'accès s3, la clé secrète, comment l'initialiser dans mon application Rails et comment accéder aux valeurs que j'ai définies dans ce fichier de configuration.

Mise à jour 1

Très recommandé: je vais avec la gemme Rails Config de nos jours pour le contrôle à grain fin qu'elle fournit.

Update2

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

Bien que ma réponse d'origine ci-dessous fonctionne toujours, cette réponse est désormais obsolète. Je recommande de consulter les mises à jour 1 et 2.

Réponse originale:

Pour une solution rapide, regarder l' écran "Fichier de configuration YAML" casté par 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'objet de configuration d'application. La configuration peut être affectée dans les fichiers d'initialisation ou les fichiers d'environnement - disons 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, il suffit d'appeler la variable de configuration sans la définir:

Rails.configuration.custom_config_variable
=> :my_config_setting

MISE À JOUR Rails 4

Dans Rails 4, il existe une nouvelle façon 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_keypeut 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 / environnement.rb (ou dans config / environnements / .. pour cibler un environnement spécifique):

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

Cela sera accessible dans le contrôleur ou dans des vues comme celle-ci:

YourApp::Application.config.yourKey

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

Remarque : 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 Rails 4

En supposant que vous placez 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 de Rails.application.config_for :acmecharger acme.ymlet d'utiliser 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 AUTHENTICATIONconstant partout dans votre application:

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

4. puis ajouter passwords.yml à .gitignore : echo /config/passwords.yml >> .gitignore, créez un fichier exemple pour votre confort cp /config/passwords.yml /config/passwords.example.ymlet il suffit d' éditer le fichier exemple dans votre console de production avec des valeurs réelles de production.

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

config.x.whatever.you.want = 42

... et cela sera disponible dans votre application sous la forme:

Rails.configuration.x.whatever.you.want

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

Découvrez ce joyau soigné 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 paramètres YAML: Yettings

Il fonctionne de manière similaire au code de la réponse de khelll, mais vous n'avez qu'à ajouter ce fichier de configuration YAML:

app/config/yetting.yml

Le plugin crée dynamiquement une classe qui vous permet d'accéder aux paramètres YML en tant que méthodes de classe dans votre application, comme suit:

Yetting.your_setting

De plus, si vous souhaitez utiliser plusieurs fichiers de paramètres avec des noms uniques, vous pouvez les placer dans un sous-répertoire dans app / config comme ceci:

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 paramètres par défaut qui peuvent être remplacés par environnement. Vous pouvez également utiliser erb dans le fichier yml.

J'aime vraiment le bijou settingslogic . Très facile à installer et à utiliser.

https://github.com/binarylogic/settingslogic

Si vous utilisez Heroku ou avez besoin de conserver les paramètres de votre application comme variables d'environnement, la gemme figaro est très utile.

J'aime utiliser les paramètres 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 est le hachage ordonné ActiveSupport

Ce qui vous permet de définir votre configuration proprement à l'intérieur des 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érerais une bonne approche pour gérer la configuration dans votre application. Il existe trois règles de base:

• changez votre configuration pas un code;
• utiliser des configurations plutôt que des conditions;
• écrire du code qui signifie quelque chose.

Pour avoir une vue d'ensemble plus détaillée, suivez ce lien: Configuration correcte des rails