it-swarm.com.de

Bester Weg, um benutzerdefinierte Konfigurationsoptionen für meine Rails-App zu erstellen?

Ich muss eine Konfigurationsoption für meine Rails-Anwendung erstellen. Es kann für alle Umgebungen gleich sein. Ich habe festgestellt, dass wenn ich es in environment.rb setze, es in meinen Ansichten verfügbar ist, genau das, was ich will ...

environment.rb

AUDIOCAST_URI_FORMAT = http://blablalba/blabbitybla/yadda

Funktioniert super.

Ich bin jedoch etwas unruhig. Ist dies eine gute Möglichkeit, dies zu tun? Gibt es einen Weg, der mehr Hüfte ist?

130
Ethan

Für allgemeine Anwendungskonfigurationen, die nicht in einer Datenbanktabelle gespeichert werden müssen, möchte ich eine config.yml-Datei im Verzeichnis config erstellen. Für Ihr Beispiel könnte es so aussehen:

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

development:
  <<: *defaults

test:
  <<: *defaults

production:
  <<: *defaults

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

# 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 Rails 3 verwenden, stellen Sie sicher, dass Sie Ihrem relativen Konfigurationspfad nicht versehentlich einen führenden Schrägstrich hinzufügen.

Sie können den Wert dann abrufen mit:

uri_format = APP_CONFIG['audiocast_uri_format']

Siehe diesen Railscast für vollständige Details.

189
John Topley

Rails 3-Version des Initialisierungscodes lautet wie folgt (Rails_ROOT und Rails_ENV sind veraltet)

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

Außerdem verwendet Ruby 1.9.3 Psych, wodurch die Groß- und Kleinschreibung von Zusammenführungsschlüsseln berücksichtigt wird, sodass Sie Ihre Konfigurationsdatei ändern müssen, um dies zu berücksichtigen, z.

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

development:
  <<: *DEFAULTS

test:
  <<: *DEFAULTS

production:
  <<: *DEFAULTS
82
David Burrows

Schienen> = 4.2

Erstellen Sie einfach eine YAML -Datei im Verzeichnis config/, Zum Beispiel: config/neo4j.yml.

Der Inhalt von neo4j.yml Kann wie folgt lauten (der Einfachheit halber habe ich Standard für alle Umgebungen verwendet):

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

Jetzt können Sie wie folgt auf Ihre benutzerdefinierte Konfiguration zugreifen:

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

Weitere Infos

Das offizielle API-Dokument von Rails beschreibt die Methode config_for Als:

Bequemes Laden von config/foo.yml für die aktuelle Rails-Umgebung.


Wenn Sie keine yaml -Datei verwenden möchten

Wie der Rails offizielle Führer sagt:

Sie können Ihren eigenen Code über das Konfigurationsobjekt Rails mit benutzerdefinierter Konfiguration unter der Eigenschaft config.x Konfigurieren.

Beispiel

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

Diese Konfigurationspunkte sind dann über das Konfigurationsobjekt verfügbar:

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 die Methode config_for | Official Rails Guide

48

Schritt 1: Erzeuge 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: / config/config.yml erstellen 

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

development:
  <<: *common

test:
  <<: *common

production:
  <<: *common

Schritt 3: Konstanten überall im Code abrufen 

facebook_key = AppConfig.facebook['key']
Twitter_key  = AppConfig.Twitter['key']
24
Omer Aslam

Ich wollte dies nur für die neuesten coolen Sachen in Rails 4.2 und 5 aktualisieren. Sie können dies jetzt in Ihren config/**/*.rb-Dateien tun:

config.x.whatever = 42

(und das ist ein wörtliches x dort, dh der config.x. muss wörtlich so sein, und dann können Sie nach dem x hinzufügen, was Sie wollen)

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

Rails.configuration.x.whatever

Mehr dazu hier: http://guides.rubyonrails.org/configuring.html#custom-configuration

18
smathy

Nur ein paar zusätzliche Infos zu diesem Thema:

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

".with_indifferent_access" ermöglicht den Zugriff auf die Werte im Hash mithilfe eines Zeichenfolgenschlüssels oder mit einem entsprechenden Symbolschlüssel.

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

Eine rein praktische Sache, aber ich möchte, dass meine Schlüssel als Symbole dargestellt werden.

6
foomip

Ich benutze etwas ähnliches wie John für Rails 3.0/3.1, aber ich habe die Datei zuerst von erb parsen:

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

Dies erlaubt mir, ERB in meiner Konfig zu verwenden, wenn es nötig ist, wie das Lesen der Heroku-Redistogo-URL:

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

Rails 4

Um eine benutzerdefinierte Konfiguration zu erstellen, laden und laden Sie sie (und machen Sie sie für Ihre App verfügbar) ähnlich wie database_configuration.

Erstellen Sie Ihren *.yml, in meinem Fall benötigte ich eine Redis-Konfigurationsdatei.

config/redis.yml

default: &default
  Host: localhost
  port: 6379

development:
  <<: *default

test:
  <<: *default

production:
  <<: *default
  Host: <%= ENV['ELASTICACHE_Host'] %>
  port: <%= ENV['ELASTICACHE_PORT'] %>

Laden Sie dann 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 Zugriff auf Ihren database.yml haben können Rails.configuration.database_configuration[Rails.env]

2
twmulloy

Aufbauend auf Omer Aslams eleganter Lösung entschied ich mich, die Schlüssel in Symbole umzuwandeln. Die einzige Änderung ist:

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

Auf diese Weise können Sie die Werte dann durch Symbole als Schlüssel referenzieren, z.

AppConfig[:Twitter][:key]

Dies scheint mir schöner zu sein.

(Als Antwort gepostet, da mein Ruf nicht hoch genug ist, um Omer's Antwort zu kommentieren.)

1
Kitebuggy

Ich mag simpleconfig . Sie können die Konfiguration pro Umgebung vornehmen.

0
Jerry Cheung

Meine Art, Einstellungen zu laden, bevor Rails initialisiert wird

Ermöglicht die Verwendung von Einstellungen in der Rails-Initialisierung und zum Konfigurieren von 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 ['email'] oder Settings.email

0
greenif

siehe meine Antwort auf Wo kann ich Anwendungsparameter am besten speichern: Datenbank, Datei, Code ...?

Eine Variation zu dem, was Sie bisher hatten, ist ein einfacher Verweis auf eine andere Datei. Es sieht so aus, dass environment.rb nicht ständig aktualisiert wird und nicht viele App-spezifische Dinge enthält. Obwohl es keine konkrete Antwort auf Ihre Frage "Ist es der Weg der Rails?", Gibt es vielleicht eine Diskussion darüber.

0
Straff

Ich ziehe den Zugriff auf Einstellungen über den globalen Anwendungsstapel vor. Ich vermeide übermäßige globale Variablen im lokalen Bereich.

config/initializers/myconfig.rb

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

Und greifen Sie mit auf.

MyAppName::Application.myconfig["yamlstuff"]
0
6ft Dan

Mein bester Weg zur benutzerdefinierten Konfiguration, mit Meldung, wenn setting.yml fehlt.

wird von einem benutzerdefinierten Initialisierer 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
0
Marcelo Austria