ruby-on-rails ruby - Comment définir des variables de configuration personnalisées dans des rails




example generate (13)

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 upload_directory 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, 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.


Answers

Jetez un coup d'œil à ce petit bijou: https://github.com/mislav/choices

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


J'ai créé un plugin simple pour les paramètres YAML: Yettings

Cela fonctionne de la même manière que le code dans la réponse de khelll, mais il suffit d'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 ceci:

Yetting.your_setting

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


Quelque chose que nous commençons à faire au travail est le Hash Commandé par ActiveSupport

Ce qui vous permet de définir votre configuration proprement 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']

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


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 / environments / .. pour cibler un environnement spécifique):

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

Ce sera accessible dans le contrôleur ou des 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 faire ceci:

dans config / environment.rb:

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

Je voulais juste mettre à jour ceci pour les dernières nouveautés de Rails 4.2, vous pouvez maintenant le faire dans 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



Dans 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.


Mise à jour 1

Très recommandé: Je vais avec Rails Config gem de nos jours pour le contrôle à grain fin qu'il fournit.

Update2

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 encore, 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

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


Depuis Rails 4.2, sans gems 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'
    
  1. touch config/initializers/constants.rb

    #config/initializers/constants.rb
    AUTHENTICATION = Rails.application.config_for :passwords
    
  1. et maintenant vous pouvez utiliser la constante AUTHENTICATION partout dans votre application:

    #rails c production
    :001> AUTHENTICATION['username'] => 'aa'
    
  2. puis ajoutez les mots de passe.yml à .gitignore : echo /config/passwords.yml >> .gitignore , créez un exemple de fichier pour votre confort cp /config/passwords.yml /config/passwords.example.yml puis modifiez simplement votre fichier d'exemple dans votre console de production avec des valeurs de production réelles.


Pour arrêter temporairement la console d'imprimer les valeurs de retour, vous pouvez émettre une instruction nil à la fin de votre boucle ou fonction, mais avant d'appuyer sur la touche de retour.

record.each do |r|
  puts r.properties
end; nil

Ou cela peut aussi être un chiffre si vous voulez réduire la saisie. Mais cela peut être déroutant dans des scénarios auxquels je ne peux pas penser.

record.each do |r|
  puts r.properties
end; 0






ruby-on-rails configuration