Ich habe mich gefragt, wie man einer Rails-Anwendung benutzerdefinierte Konfigurationsvariablen hinzufügt und wie man im Controller darauf zugreift. Zum Beispiel möchte ich in den Konfigurationsdateien ein upload_directory definieren können, z. B. development.rb, und in einer meiner Dateien darauf zugreifen können Steuerungen.

Zweitens plante ich S3-Unterstützung für Uploads in meiner Anwendung, wenn ich eine Yaml-Datei mit dem s3-Zugriff, dem geheimen Schlüssel, hinzufügen wollte, wie ich sie in meiner Rails-App initialisiere und wie ich auf die von mir definierten Werte zugreife in dieser Konfigurationsdatei.

Update 1

Sehr zu empfehlen: Ich gehe heutzutage mit Rails Config Gem für die feinkörnige Kontrolle, die es bietet.

Update2

Wenn Sie eine schnelle Lösung wünschen, überprüfen Sie die Antwort von Jack Pratt unten.

Obwohl meine ursprüngliche Antwort unten immer noch funktioniert, ist diese Antwort jetzt veraltet. Ich empfehle, die Updates 1 und 2 zu lesen.

Ursprüngliche Antwort:

Für eine schnelle Lösung sollte es sehr hilfreich sein, den Bildschirm "YAML-Konfigurationsdatei" von Ryan Bates anzusehen.

Zusammenfassend:

# 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 können anwendungsspezifische benutzerdefinierte Konfigurationsdaten im Anwendungskonfigurationsobjekt platziert werden. Die Konfiguration kann in den Initialisierungsdateien oder den Umgebungsdateien zugewiesen werden - beispielsweise für eine bestimmte Anwendung MyApp:

MyApp::Application.config.custom_config_variable = :my_config_setting

oder

Rails.configuration.custom_config_variable = :my_config_setting

Um die Einstellung zu lesen, rufen Sie einfach die Konfigurationsvariable auf, ohne sie festzulegen:

Rails.configuration.custom_config_variable
=> :my_config_setting

UPDATE Rails 4

In Rails 4 gibt es dafür einen neuen Weg => http://guides.rubyonrails.org/configuring.html#custom-configuration

In Rails 3.0.5 hat der folgende Ansatz für mich funktioniert:

In config/environments/development.rb, Schreib

config.custom_config_key = :config_value

Der Wert custom_config_keykann dann aus anderen Dateien mit referenziert werden

Rails.application.config.custom_config_key

Dies funktioniert in Schienen 3.1:

in config / environment.rb (oder in config / environment / .., um eine bestimmte Umgebung zu erreichen):

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

Dies ist in Controllern oder Ansichten wie diesen zugänglich:

YourApp::Application.config.yourKey

(Ihre App sollte durch Ihren Anwendungsnamen ersetzt werden.)

Hinweis : Es handelt sich um Ruby-Code. Wenn Sie also viele Konfigurationsschlüssel haben, können Sie dies tun:

in config / environment.rb:

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

In Schienen 4

Angenommen, Sie fügen Ihre benutzerdefinierten Variablen in eine Yaml-Datei ein:

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

Erstellen Sie einen Initialisierer, um sie zu laden:

# 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

Jetzt können Sie überall in Ihrer App wie folgt auf diese Werte zugreifen:

Rails.configuration.acme.api_user

Es ist praktisch, dass Sie Rails.application.config_for :acmeIhre laden acme.ymlund die richtige Umgebung verwenden.

Seit Rails 4.2 können Sie config / hi.yml ohne zusätzliche Edelsteine einfach mit verwenden Rails.application.config_for :hi.

Zum Beispiel:

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. und jetzt können Sie AUTHENTICATIONkonstant überall in Ihrer Anwendung verwenden:

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

4. fügen Sie dann passwords.yml zuFügen Sie .gitignore : hinzu echo /config/passwords.yml >> .gitignore, erstellen Sie eine Beispieldatei für Ihren Komfort cp /config/passwords.yml /config/passwords.example.ymlund bearbeiten Sie dann einfach Ihre Beispieldatei in Ihrer Produktionskonsole mit den tatsächlichen Produktionswerten.

Ich wollte dies nur für die neuesten coolen Sachen in Rails 4.2 aktualisieren. Sie können dies jetzt in jeder Ihrer config/**/*.rbDateien tun :

config.x.whatever.you.want = 42

... und dies wird in Ihrer App verfügbar sein als:

Rails.configuration.x.whatever.you.want

Weitere Informationen finden Sie hier: http://guides.rubyonrails.org/configuring.html#custom-configuration

Schauen Sie sich dieses hübsche Juwel an, das genau das tut: https://github.com/mislav/choices

Auf diese Weise werden Ihre vertraulichen Daten in Open Source-Projekten nicht verfügbar gemacht

Ich habe ein einfaches Plugin für YAML-Einstellungen erstellt: Yettings

Es funktioniert ähnlich wie der Code in Khellls Antwort, aber Sie müssen nur diese YAML-Konfigurationsdatei hinzufügen:

app/config/yetting.yml

Das Plugin erstellt dynamisch eine Klasse, mit der Sie auf die YML-Einstellungen als Klassenmethoden in Ihrer App zugreifen können:

Yetting.your_setting

Wenn Sie mehrere Einstellungsdateien mit eindeutigen Namen verwenden möchten, können Sie diese wie folgt in einem Unterverzeichnis in app / config ablegen:

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

Dann können Sie auf folgende Werte zugreifen:

FirstYetting.your_setting
SecondYetting.your_setting

Außerdem erhalten Sie Standardeinstellungen, die pro Umgebung überschrieben werden können. Sie können erb auch in der yml-Datei verwenden.

Ich mag das Settingslogic- Juwel sehr. Sehr einfach einzurichten und zu verwenden.

https://github.com/binarylogic/settingslogic

Wenn Sie Heroku verwenden oder auf andere Weise Ihre Anwendungseinstellungen als Umgebungsvariablen beibehalten müssen, ist das figaro- Juwel sehr hilfreich.

Ich verwende gerne Rails-Einstellungen für globale Konfigurationswerte, die über die Weboberfläche geändert werden müssen.

Etwas, das wir bei der Arbeit anfangen, ist der ActiveSupport Ordered Hash

So können Sie Ihre Konfiguration sauber in den Umgebungsdateien definieren, z

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

Ich würde einen guten Ansatz vorschlagen, wie Sie mit der Konfiguration in Ihrer Anwendung überhaupt umgehen sollen. Es gibt drei Grundregeln:

• Ändern Sie Ihre Konfiguration nicht als Code.
• Konfigurationen über Bedingungen verwenden;
• schreibe Code, der etwas bedeutet.

Um eine detailliertere Übersicht zu erhalten, folgen Sie diesem Link: Schienenkonfiguration auf die richtige Weise