Der beste Weg, individuelle Konfigurationsoptionen für meine Rails-Anwendung zu erstellen?

Question

Ich brauche eine Konfigurationsoption für meine Rails-Anwendung zu erstellen. Es kann das gleiche für alle Umgebungen sein. Ich fand, dass, wenn ich es in environment.rb gesetzt, es in meinen Ansichten verfügbar ist, was genau das ist, was ich will ...

environment.rb

AUDIOCAST_URI_FORMAT = http://blablalba/blabbitybla/yadda

Arbeiten groß.

Allerdings bin ich ein wenig unruhig. Ist das ein guter Weg, es zu tun? Gibt es eine Möglichkeit, die mehr hip ist?

Answer 1

Für allgemeine Anwendungskonfiguration, die nicht in einer Datenbanktabelle gespeichert werden muss, wie ich eine config.yml Datei innerhalb der Konfiguration Verzeichnis erstellen. Für Ihr Beispiel, es könnte wie folgt aussehen:

defaults: &defaults
  audiocast_uri_format: http://blablalba/blabbitybla/yadda

development:
  <<: *defaults

test:
  <<: *defaults

production:
  <<: *defaults

Diese Konfigurationsdatei von einem benutzerdefinierten initializer in geladen wird config / initializers :

# Rails 2
APP_CONFIG = YAML.load_file("#{RAILS_ROOT}/config/config.yml")[RAILS_ENV]

# Rails 3+
APP_CONFIG = YAML.load_file(Rails.root.join('config/config.yml'))[Rails.env]

Wenn Sie mit Rails 3, sicherzustellen, dass Sie nicht versehentlich einen führenden Schrägstrich zu Ihrem relativen Konfigurationspfad hinzuzufügen.

Sie können dann den Wert abrufen mit:

uri_format = APP_CONFIG['audiocast_uri_format']

Siehe diese Railscast für weitere Informationen.

Answer 2

Rails 3-Version von initialiser Code lautet wie folgt (RAILS_ROOT & RAILS_ENV sind veraltet)

APP_CONFIG = YAML.load_file(Rails.root.join('config', 'config.yml'))[Rails.env]

Auch Ruby 1.9.3 verwendet Psych, die empfindlichen fusionieren Schlüssel Fall macht, so dass Sie Ihre Konfigurationsdatei, die berücksichtigen ändern müssen werden, z.

defaults: &DEFAULTS
  audiocast_uri_format: http://blablalba/blabbitybla/yadda

development:
  <<: *DEFAULTS

test:
  <<: *DEFAULTS

production:
  <<: *DEFAULTS

Answer 3

Schienen> = 4.2

Erstellen Sie einfach eine YAML Datei in config/ Verzeichnis, zum Beispiel:. config/neo4j.yml

Der Inhalt des neo4j.yml somthing wie unten sein kann (Der Einfachheit halber habe ich Standard für alle Umgebungen):

default: &default
  host: localhost
  port: 7474
  username: neo4j
  password: root

development:
  <<: *default

test:
  <<: *default

production:
  <<: *default

in config/application.rb:

module MyApp
  class Application < Rails::Application
    config.neo4j = config_for(:neo4j)
  end
end

Nun, Ihre benutzerdefinierte Konfiguration ist zugänglich wie folgt:

Rails.configuration.neo4j['host'] #=>localhost
Rails.configuration.neo4j['port'] #=>7474

---

Mehr Informationen

Rails offizielle API Dokument beschreibt config_for Verfahren wie:

  

Convenience zum Laden config / foo.yml für den aktuellen Rails env.

---

Wenn Sie nicht wollen, eine yaml Datei

verwenden,

Als Rails offiziellen Guide sagt:

  

Sie können Ihren eigenen Code durch die Rails Konfigurationsobjekt mit benutzerdefinierter Konfiguration unter der config.x Eigenschaft konfigurieren.

Beispiel:

config.x.payment_processing.schedule = :daily
config.x.payment_processing.retries  = 3
config.x.super_debugger = true

  

Diese Konfigurationspunkte sind dann durch das Konfigurationsobjekt zur Verfügung:

Rails.configuration.x.payment_processing.schedule # => :daily
Rails.configuration.x.payment_processing.retries  # => 3
Rails.configuration.x.super_debugger              # => true
Rails.configuration.x.super_debugger.not_set      # => nil

---

Offizielle Referenz für config_for Methode | Offizielle Rails-Führer

Answer 4

Schritt 1: Erstellen config / initializers / appconfig.rb

require 'ostruct'
require 'yaml'

all_config = YAML.load_file("#{Rails.root}/config/config.yml") || {}
env_config = all_config[Rails.env] || {}
AppConfig = OpenStruct.new(env_config)

Schritt 2: Erstellen config / config.yml

common: &common
  facebook:
    key: 'asdjhasxas'
    secret : 'xyz'
  twitter:
    key: 'asdjhasxas'
    secret : 'abx'

development:
  <<: *common

test:
  <<: *common

production:
  <<: *common

Schritt 3: Erhalten Sie Konstanten überall im Code

facebook_key = AppConfig.facebook['key']
twitter_key  = AppConfig.twitter['key']

Answer 5

Ich wollte nur für die neueste coole Sachen diese aktualisieren, in Rails 4.2 und 5 können Sie jetzt tun dies innerhalb eines Ihrer config/**/*.rb Dateien:

config.x.whatever = 42

(und das ist eine wörtliche x drin, dh. Die config.x. wahrsten Sinne des Wortes, dass sein muss, und dann können Sie addieren, was Sie nach dem x wollen)

... und dies wird zur Verfügung steht in der App als:

Rails.configuration.x.whatever

Sehen Sie mehr hier: http://guides.rubyonrails.org/configuring.html # benutzerdefinierte Konfiguration

Answer 6

Nur ein paar zusätzliche Informationen zu diesem Thema:

APP_CONFIG = YAML.load_file(Rails.root.join('config', 'config.yml'))[Rails.env].with_indifferent_access

„with_indifferent_access“ können Sie die Werte in der Hash-Zugriff auf eine String-Schlüssel oder mit einer gleichwertigen Symbol-Taste.

zB.
APP_CONFIG['audiocast_uri_format'] => 'http://blablalba/blabbitybla/yadda' APP_CONFIG[:audiocast_uri_format] => 'http://blablalba/blabbitybla/yadda'

Reine Bequemlichkeit Sache, aber ich ziehe meine Schlüssel dargestellt als Symbole haben.

Answer 7

Ich verwende etwas ähnlich wie John für Rails 3.0 / 3.1, aber ich habe erb die Datei analysiert zuerst:

APP_CONFIG = YAML.load(ERB.new(File.new(File.expand_path('../config.yml', __FILE__)).read).result)[Rails.env]

Dies ermöglicht es mir ERB in meine Config zu verwenden, wenn es nötig ist, wie Heroku des redistogo url Lesen:

production:
  <<: *default
  redis:                  <%= ENV['REDISTOGO_URL'] %>

Answer 8

Rails 4

Um eine benutzerdefinierte Konfiguration yaml zu erstellen und laden Sie es (und zu Ihrer App zur Verfügung stellen), ähnlich wie database_configuration.

Ihre eigene *.yml, in meinem Fall habe ich eine redis Konfigurationsdatei benötigt wird.

config/redis.yml

default: &default
  host: localhost
  port: 6379

development:
  <<: *default

test:
  <<: *default

production:
  <<: *default
  host: <%= ENV['ELASTICACHE_HOST'] %>
  port: <%= ENV['ELASTICACHE_PORT'] %>

Dann laden Sie die Konfiguration

config/application.rb

module MyApp
  class Application < Rails::Application

    ## http://guides.rubyonrails.org/configuring.html#initialization-events
    config.before_initialize do
      Rails.configuration.redis_configuration = YAML.load_file("#{Rails.root}/config/redis.yml")
    end

  end
end

Zugriff auf die Werte:

Rails.configuration.redis_configuration[Rails.env] ähnlich, wie Sie Zugang zu Ihrem database.yml von Rails.configuration.database_configuration[Rails.env] haben

Answer 9

Aufbauend auf Omer Aslam elegante Lösung, entschied ich mich die Schlüssel in Symbole zu konvertieren. Die einzige Änderung ist:

all_config = YAML.load_file("#{Rails.root}/config/config.yml").with_indifferent_access || {}

Damit können Sie dann Werte verweisen durch Symbole wie Tasten, z.

AppConfig[:twitter][:key]

Das scheint ordentlicheres mir in die Augen.

(Veröffentlicht als Antwort, wie mein Ruf nicht hoch genug ist, auf Omer Antwort auf Kommentar)

Answer 10

Ich mag simpleconfig . Es ermöglicht Ihnen, pro Umgebungskonfiguration haben.

Answer 11

siehe meine Antwort auf Wo ist der beste Ort, Anwendungsparameter zu speichern: Datenbank-, Datei-, Code ...

Eine Variante zu dem, was man hatte, dass sie auf eine andere Datei eine einfache Referenz ist. Es sieht, dass environment.rb nicht ständig aktualisiert wird und nicht einen Haufen App spezifischer Sachen drin hat. Obwohl es nicht eine spezifische Antwort auf Ihre Frage ‚ist es der Rails Weg?‘, Vielleicht wird es einige Diskussionen da sein darüber.

Answer 12

Ich ziehe Einstellungen durch den globalen Anwendungs-Stack zugreifen. Ich vermeide überschüssige globale Variablen im lokalen Bereich.

config / initializers / myconfig.rb

MyAppName::Application.define_singleton_method("myconfig") {YAML.load_file("#{Rails.root}/config/myconfig.yml") || {}}

Und Zugang mit.

MyAppName::Application.myconfig["yamlstuff"]

Answer 13

My way Einstellungen zu laden, bevor Rails initialisieren

Hier können Sie Einstellungen in Rails Initialisierung verwenden, und konfigurieren Sie die Einstellungen pro Umgebung

# config/application.rb
Bundler.require(*Rails.groups)

mode = ENV['RAILS_ENV'] || 'development'
file = File.dirname(__FILE__).concat('/settings.yml')
Settings = YAML.load_file(file).fetch(mode)
Settings.define_singleton_method(:method_missing) {|name| self.fetch(name.to_s, nil)}

Sie können Einstellungen auf zwei Arten erhalten: Einstellungen [ 'E-Mail'] oder Settings.email

Answer 14

Mein bester Weg, um benutzerdefinierte Konfiguration, mit raise Meldung, wenn setting.yml fehlt.

wird von einem benutzerdefinierten initializer in config / initializers / custom_config.rb

geladen

setting_config = File.join(Rails.root,'config','setting.yml')
raise "#{setting_config} is missing!" unless File.exists? setting_config
config = YAML.load_file(setting_config)[Rails.env].symbolize_keys

@APP_ID = config[:app_id]
@APP_SECRET = config[:app_secret]

Erstellen Sie eine YAML in config / setting.yml

development:
  app_id: 433387212345678
  app_secret: f43df96fc4f65904083b679412345678

test:
  app_id: 148166412121212
  app_secret: 7409bda8139554d11173a32222121212

production:
  app_id: 148166412121212
  app_secret: 7409bda8139554d11173a32222121212