W Rails 3, specyficzne dla aplikacji niestandardowe dane konfiguracyjne mogą być umieszczone w obiekcie konfiguracyjnym aplikacji. Konfiguracja może być przypisana w plikach inicjalizacyjnych lub plikach środowiskowych -- powiedzmy dla danej aplikacji MyApp:

MyApp::Application.config.custom_config_variable = :my_config_setting

Lub

Rails.configuration.custom_config_variable = :my_config_setting

Aby odczytać ustawienie, wystarczy wywołać zmienną konfiguracyjną bez jej ustawiania:

Rails.configuration.custom_config_variable
=> :my_config_setting

UPDATE Rails 4

W Rails 4 jest nowy sposób na to => http://guides.rubyonrails.org/configuring.html#custom-configuration

W Rails 3.0.5 zadziałało dla mnie następujące podejście:

In config/environments/development.rb, write

config.custom_config_key = :config_value

Wartość custom_config_key może być następnie odwołana z innych plików za pomocą

Rails.application.config.custom_config_key

To działa w rails 3.1:

W Config / environment.rb (lub w config / environments/.. ukierunkowanie na konkretne środowisko) :

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

Będzie to dostępne w kontrolerze lub widokach takich jak:

YourApp::Application.config.yourKey

(nazwę aplikacji należy zastąpić nazwą aplikacji.)

Uwaga : jest to kod Ruby, więc jeśli masz dużo kluczy konfiguracyjnych, możesz to zrobić:

W config / environment.rb:

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

In Rails 4

Zakładając, że umieścisz swoje zmienne niestandardowe w pliku yaml:

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

Utwórz inicjalizator, aby je załadować:

# 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

Teraz gdziekolwiek w aplikacji możesz uzyskać dostęp do tych wartości, jak tak:

Rails.configuration.acme.api_user

Jest to wygodne, że Rails.application.config_for :acme załaduje twoje acme.yml i użyje odpowiedniego środowiska.

Od Rails 4.2, bez dodatkowych klejnotów, można załadować config/hi.yml po prostu za pomocą Rails.application.config_for :hi.

Na przykład:

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. I teraz możesz używać AUTHENTICATION stałej wszędzie w swojej aplikacji:

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

2. Następnie dodaj hasła.yml do .gitignore: echo /config/passwords.yml >> .gitignore, Utwórz przykładowy plik dla swojego comfort cp /config/passwords.yml /config/passwords.example.yml, a następnie po prostu edytuj przykładowy plik w konsoli produkcyjnej z rzeczywistymi wartościami produkcyjnymi.

Chciałem tylko zaktualizować to dla najnowszych fajnych rzeczy w Rails 4.2, teraz możesz to zrobić w dowolnym pliku config/**/*.rb:

config.x.whatever.you.want = 42

...i to będzie dostępne w aplikacji jako:

Rails.configuration.x.whatever.you.want

Zobacz więcej tutaj: http://guides.rubyonrails.org/configuring.html#custom-configuration

Zobacz ten zgrabny klejnot robi dokładnie to: https://github.com/mislav/choices

W ten sposób twoje poufne dane nie zostaną ujawnione w projektach open source

Stworzyłem prosty plugin do ustawień YAML: Yettings

Działa podobnie do kodu w odpowiedzi khellla, ale wystarczy dodać ten plik konfiguracyjny YAML:

app/config/yetting.yml

Wtyczka dynamicznie tworzy klasę, która umożliwia dostęp do ustawień YML jako metod klasy w Twojej aplikacji w następujący sposób:

Yetting.your_setting

Ponadto, jeśli chcesz użyć wielu plików ustawień o unikalnych nazwach, możesz umieścić je w podkatalogu wewnątrz app/config, jak to:

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

Następnie możesz uzyskać dostęp do wartości w następujący sposób:

FirstYetting.your_setting
SecondYetting.your_setting

Zapewnia również domyślne ustawienia, które mogą być nadpisywane dla każdego środowiska. Można również użyć erb wewnątrz pliku yml.

Bardzo mi się podoba settingslogic gem. Bardzo łatwy w konfiguracji i użyciu.

Https://github.com/binarylogic/settingslogic

Jeśli używasz Heroku lub w inny sposób musisz zachować ustawienia aplikacji jako zmienne środowiskowe, gem figaro jest bardzo pomocny.

Lubię używać rails-settings dla globalnych wartości konfiguracyjnych, które muszą być zmieniane przez interfejs WWW.

Coś, co zaczęliśmy robić w pracy, to Activesupport uporządkowany Hash

Który pozwala na dokładne zdefiniowanie konfiguracji wewnątrz plików środowiska np.

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

Sugerowałbym dobre podejście, jak w ogóle radzić sobie z konfiguracją w Twojej aplikacji. Istnieją trzy podstawowe zasady:

• zmień konfigurację a nie kod;
• Użyj konfiguracji ponad warunkami;
• Napisz kod, który coś znaczy.

Aby uzyskać bardziej szczegółowy przegląd kliknij ten link: konfiguracja Rails w odpowiedni sposób