Mi chiedevo come aggiungere variabili di configurazione personalizzate a un'applicazione rails e come accedervi nel controller, per esempio voglio essere in grado di definire una directory upload_directory nei file di configurazione dire development.rb ed essere in grado di accedervi in ​​uno dei miei controllori.

In secondo luogo, avevo in programma di avere il supporto S3 per i caricamenti nella mia applicazione, se volevo aggiungere un file yaml con accesso s3, chiave segreta, come posso inizializzarlo nella mia app Rails e come posso accedere ai valori che ho definito in quel file di configurazione.

Aggiornamento 1

Molto consigliato: oggi vado con la gemma di Rails Config per il controllo a grana fine che fornisce.

Update2

Se vuoi una soluzione rapida, controlla di seguito la risposta di Jack Pratt .

Anche se la mia risposta originale qui sotto funziona ancora, questa risposta è obsoleta. Consiglio di consultare gli aggiornamenti 1 e 2.

Risposta originale:

Per una soluzione rapida, guardare la schermata "File di configurazione YAML" trasmessa da Ryan Bates dovrebbe essere molto utile.

In sintesi:

# 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

In Rails 3, i dati di configurazione personalizzati specifici dell'applicazione possono essere inseriti nell'oggetto di configurazione dell'applicazione. La configurazione può essere assegnata nei file di inizializzazione o nei file di ambiente, ad esempio per una determinata applicazione MyApp:

MyApp::Application.config.custom_config_variable = :my_config_setting

o

Rails.configuration.custom_config_variable = :my_config_setting

Per leggere l'impostazione, è sufficiente chiamare la variabile di configurazione senza impostarla:

Rails.configuration.custom_config_variable
=> :my_config_setting

AGGIORNA Rotaie 4

In Rails 4 c'è un nuovo modo per questo => http://guides.rubyonrails.org/configuring.html#custom-configuration

In Rails 3.0.5, il seguente approccio ha funzionato per me:

In config/environments/development.rb, scrivi

config.custom_config_key = :config_value

È custom_config_keypossibile quindi fare riferimento al valore da altri file utilizzando

Rails.application.config.custom_config_key

Funziona su binari 3.1:

in config / environment.rb (o in config / environment / .. per indirizzare un ambiente specifico):

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

Questo sarà accessibile nel controller o in viste come questa:

YourApp::Application.config.yourKey

(YourApp deve essere sostituita dal nome dell'applicazione.)

Nota : è il codice Ruby, quindi se hai molte chiavi di configurazione, puoi farlo:

in config / environment.rb:

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

In Rails 4

Supponendo di inserire le variabili personalizzate in un file yaml:

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

Crea un inizializzatore per caricarli:

# 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

Ora ovunque nella tua app puoi accedere a questi valori in questo modo:

Rails.configuration.acme.api_user

È conveniente Rails.application.config_for :acmecaricare acme.ymle utilizzare l'ambiente corretto.

Da Rails 4.2, senza gemme aggiuntive, puoi caricare config / hi.yml semplicemente usando Rails.application.config_for :hi.

Per esempio:

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. e ora puoi usare AUTHENTICATIONcostante ovunque nella tua applicazione:

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

4. quindi aggiungere passwords.yml a .gitignore : echo /config/passwords.yml >> .gitignorecreare un file di esempio per il vostro comfort cp /config/passwords.yml /config/passwords.example.ymle poi basta modificare il file di esempio nella tua console di produzione con valori di produzione attuali.

Volevo solo aggiornare questo per le ultime cose interessanti in Rails 4.2, ora puoi farlo all'interno di uno qualsiasi dei tuoi config/**/*.rbfile:

config.x.whatever.you.want = 42

... e questo sarà disponibile nella tua app come:

Rails.configuration.x.whatever.you.want

Vedi di più qui: http://guides.rubyonrails.org/configuring.html#custom-configuration

Dai un'occhiata a questo gioiello pulito facendo esattamente questo: https://github.com/mislav/choices

In questo modo i tuoi dati sensibili non saranno esposti nei progetti open source

Ho creato un semplice plug-in per le impostazioni YAML: Yettings

Funziona in modo simile al codice nella risposta di khelll, ma devi solo aggiungere questo file di configurazione YAML:

app/config/yetting.yml

Il plug-in crea dinamicamente una classe che ti consente di accedere alle impostazioni YML come metodi di classe nella tua app in questo modo:

Yetting.your_setting

Inoltre, se si desidera utilizzare più file di impostazioni con nomi univoci, è possibile posizionarli in una sottodirectory all'interno dell'app / config in questo modo:

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

Quindi puoi accedere ai valori in questo modo:

FirstYetting.your_setting
SecondYetting.your_setting

Fornisce inoltre impostazioni predefinite che possono essere sovrascritte per ambiente. Puoi anche usare erb all'interno del file yml.

Mi piace molto la gemma settingslogic . Molto facile da configurare e utilizzare.

https://github.com/binarylogic/settingslogic

Se usi Heroku o hai bisogno di mantenere le impostazioni dell'applicazione come variabili di ambiente, la gemma di Figaro è molto utile.

Mi piace usare le impostazioni rotaie per i valori di configurazione globali che devono essere modificabili tramite l'interfaccia web.

Qualcosa che stiamo iniziando a fare sul lavoro è ActiveSupport Ordered Hash

Ciò consente di definire la configurazione in modo pulito all'interno dei file di ambiente, ad es

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

Vorrei suggerire un buon approccio su come gestire la configurazione nella tua applicazione. Esistono tre regole di base:

• cambia la tua configurazione non un codice;
• utilizzare le configurazioni rispetto alle condizioni;
• scrivere codice che significhi qualcosa.

Per una panoramica più dettagliata segui questo link: Configurazione delle rotaie nel modo corretto