Melhor maneira de criar opções de configuração personalizadas para o meu aplicativo Rails?

Eu preciso criar uma opção de configuração para o meu aplicativo Rails. Pode ser o mesmo para todos os ambientes. Descobri que, se eu configurá-lo em environment.rb , ele está disponível em minhas visualizações, que é exatamente o que eu quero …

 environment.rb AUDIOCAST_URI_FORMAT = http://blablalba/blabbitybla/yadda 

Funciona bem.

No entanto, estou um pouco desconfortável. Esta é uma boa maneira de fazer isso? Existe uma maneira que é mais hip?

Para a configuração geral da aplicação que não precisa ser armazenada em uma tabela de database, gosto de criar um arquivo config.yml dentro do diretório config . Para o seu exemplo, pode ser assim:

 defaults: &defaults audiocast_uri_format: http://blablalba/blabbitybla/yadda development: <<: *defaults test: <<: *defaults production: <<: *defaults 

Este arquivo de configuração é carregado a partir de um inicializador customizado em 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] 

Se você estiver usando o Rails 3, certifique-se de não adicionar acidentalmente uma barra inicial ao seu caminho de configuração relativo.

Você pode então recuperar o valor usando:

 uri_format = APP_CONFIG['audiocast_uri_format'] 

Veja este Railscast para maiores detalhes.

Rails 3 versão do código do inicializador é a seguinte (RAILS_ROOT & RAILS_ENV são obsoletos)

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

Além disso, o Ruby 1.9.3 usa o Psych, o que faz com que as chaves de mesclagem diferenciam maiúsculas e minúsculas, portanto, você precisará alterar seu arquivo de configuração para levar isso em consideração, por exemplo,

 defaults: &DEFAULTS audiocast_uri_format: http://blablalba/blabbitybla/yadda development: <<: *DEFAULTS test: <<: *DEFAULTS production: <<: *DEFAULTS 

rails> = 4.2

Basta criar um arquivo YAML no diretório config/ , por exemplo: config/neo4j.yml .

O conteúdo do neo4j.yml pode ser algo como abaixo (para simplificar, usei o padrão para todos os ambientes):

 default: &default host: localhost port: 7474 username: neo4j password: root development: <<: *default test: <<: *default production: <<: *default 

em config/application.rb :

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

Agora, sua configuração personalizada está acessível como abaixo:

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

Mais informações

O documento oficial da API do Rails descreve o método config_for como:

Conveniência para carregar config / foo.yml para o env atual Rails.


Se você não quiser usar um arquivo yaml

Como o guia oficial do Rails diz:

Você pode configurar seu próprio código através do object de configuração do Rails com configuração customizada sob a propriedade config.x .

Exemplo

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

Esses pontos de configuração estão disponíveis por meio do object de configuração:

 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 

Referência oficial para o método config_for | Guia oficial de Rails

Etapa 1: Criar 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) 

Etapa 2: Criar config / config.yml

 common: &common facebook: key: 'asdjhasxas' secret : 'xyz' twitter: key: 'asdjhasxas' secret : 'abx' development: <<: *common test: <<: *common production: <<: *common 

Etapa 3: obtenha constantes em qualquer parte do código

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

Eu só queria atualizar isso para as últimas coisas legais no Rails 4.2 e 5, agora você pode fazer isso dentro de qualquer um dos seus arquivos config/**/*.rb :

 config.x.whatever = 42 

(e isso é um literal x lá, ou seja, o config.x. literalmente deve ser isso, e então você pode adicionar o que quiser depois do x )

… e isso estará disponível no seu aplicativo como:

 Rails.configuration.x.whatever 

Veja mais aqui: http://guides.rubyonrails.org/configuring.html#custom-configuration

Apenas algumas informações extras sobre este tópico:

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

“.with_indifferent_access” permite que você acesse os valores no hash usando uma chave de string ou com uma chave de símbolo equivalente.

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

Puramente uma coisa de conveniência, mas eu prefiro ter minhas chaves representadas como símbolos.

Eu uso algo semelhante ao John for Rails 3.0 / 3.1, mas eu tenho erb parse o arquivo primeiro:

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

Isso me permite usar o ERB na minha configuração, se eu precisar, como ler o URL redistogo do heroku:

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

Rails 4

Para criar um yaml de configuração personalizada e carregá-lo (e disponibilizar para o seu aplicativo) de forma semelhante a como database_configuration .

Crie seu *.yml , no meu caso eu precisei de um arquivo de configuração redis.

config/redis.yml

 default: &default host: localhost port: 6379 development: <<: *default test: <<: *default production: <<: *default host: <%= ENV['ELASTICACHE_HOST'] %> port: <%= ENV['ELASTICACHE_PORT'] %> 

Em seguida, carregue a configuração

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 

Acesse os valores:

Rails.configuration.redis_configuration[Rails.env] semelhante a como você pode ter access ao seu database.yml por Rails.configuration.database_configuration[Rails.env]

Com base na solução elegante do Omer Aslam, decidi converter as chaves em símbolos. A única mudança é:

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

Isso permite que você faça referência a valores por símbolos como chaves, por exemplo

 AppConfig[:twitter][:key] 

Isso parece mais arrumado para os meus olhos.

(Postado como resposta, pois minha reputação não é alta o suficiente para comentar a resposta de Omer)

Eu gosto de simpleconfig . Permite que você tenha configuração por ambiente.

veja minha resposta para Onde é o melhor lugar para armazenar os parâmetros do aplicativo: database, arquivo, código …?

Uma variação para o que você tinha em que é uma referência simples para outro arquivo. Ele vê que environment.rb não é constantemente atualizado e não tem um monte de coisas específicas de aplicativos nele. Embora não seja uma resposta específica para a sua pergunta “é a maneira do Rails?”, Talvez haja alguma discussão sobre isso.

Eu prefiro acessar as configurações através da pilha de aplicativos globais. Evito excesso de variables ​​globais no escopo local.

config / initializers / myconfig.rb

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

E acessá-lo com.

 MyAppName::Application.myconfig["yamlstuff"] 

Minha maneira de carregar configurações antes de inicializar Rails

Permite que você use as configurações na boot do Rails e defina as configurações por ambiente

 # 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)} 

Você pode obter configurações de duas maneiras: Configurações [’email’] ou Configurações.email

Minha melhor maneira de configurar personalizado, com mensagem de aumento quando setting.yml está faltando.

é carregado a partir de um inicializador customizado em config / initializers / custom_config.rb

 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] 

Crie um YAML em config / setting.yml

 development: app_id: 433387212345678 app_secret: f43df96fc4f65904083b679412345678 test: app_id: 148166412121212 app_secret: 7409bda8139554d11173a32222121212 production: app_id: 148166412121212 app_secret: 7409bda8139554d11173a32222121212