Eu queria saber como adicionar variáveis ​​de configuração personalizadas a um aplicativo rails e como acessá-las no controlador, por exemplo, eu quero definir um diretório de upload nos arquivos de configuração, como development.rb e acessá-lo em um dos meus controladores.

Em segundo lugar, eu estava planejando ter suporte ao S3 para uploads no meu aplicativo, se eu quisesse adicionar um arquivo yaml com o acesso s3, chave secreta, como inicializá-lo no meu aplicativo Rails e como acesso os valores que defini nesse arquivo de configuração.

Atualização 1

Muito recomendado: hoje em dia, uso a gema Rails Config para obter o controle refinado que ela fornece.

Update2

Se você deseja uma solução rápida, verifique a resposta de Jack Pratt abaixo.

Embora minha resposta original abaixo ainda funcione, esta resposta está desatualizada. Eu recomendo olhar para as atualizações 1 e 2.

Resposta original:

Para uma solução rápida, assistir à tela "Arquivo de configuração YAML" de Ryan Bates deve ser muito útil.

Em suma:

# 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

No Rails 3, os dados de configuração personalizados específicos do aplicativo podem ser colocados no objeto de configuração do aplicativo. A configuração pode ser atribuída nos arquivos de inicialização ou nos arquivos de ambiente - digamos, para um determinado aplicativo MyApp:

MyApp::Application.config.custom_config_variable = :my_config_setting

ou

Rails.configuration.custom_config_variable = :my_config_setting

Para ler a configuração, basta chamar a variável de configuração sem defini-la:

Rails.configuration.custom_config_variable
=> :my_config_setting

UPDATE Rails 4

No Rails 4, existe uma nova maneira de isso => http://guides.rubyonrails.org/configuring.html#custom-configuration

No Rails 3.0.5, a seguinte abordagem funcionou para mim:

Em config/environments/development.rb, write

config.custom_config_key = :config_value

O valor custom_config_keypode ser referenciado a partir de outros arquivos usando

Rails.application.config.custom_config_key

Isso funciona nos trilhos 3.1:

em config / environment.rb (ou em config / environment / .. para direcionar um ambiente específico):

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

Isso estará acessível no controlador ou em visualizações como esta:

YourApp::Application.config.yourKey

(YourApp deve ser substituído pelo nome do seu aplicativo.)

Nota : É código Ruby, portanto, se você tiver muitas chaves de configuração, poderá fazer o seguinte:

em config / environment.rb:

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

No Rails 4

Supondo que você coloque suas variáveis ​​personalizadas em um arquivo yaml:

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

Crie um inicializador para carregá-los:

# 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

Agora, em qualquer lugar do seu aplicativo, você pode acessar esses valores da seguinte forma:

Rails.configuration.acme.api_user

É conveniente Rails.application.config_for :acmecarregar o seu acme.ymle usar o ambiente correto.

Desde o Rails 4.2, sem gemas adicionais, você pode carregar o config / hi.yml simplesmente usandoRails.application.config_for :hi .

Por exemplo:

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. e agora você pode usar AUTHENTICATIONconstante em qualquer lugar do seu aplicativo:

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

4. em seguida, adicione passwords.yml a .gitignore : echo /config/passwords.yml >> .gitignore, criar um arquivo de exemplo para o seu conforto cp /config/passwords.yml /config/passwords.example.ymle, em seguida, basta editar seu arquivo de exemplo na sua consola de produção com valores de produção reais.

Eu só queria atualizar isso para obter as novidades interessantes do Rails 4.2, agora você pode fazer isso em qualquer um dos seus config/**/*.rbarquivos:

config.x.whatever.you.want = 42

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

Rails.configuration.x.whatever.you.want

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

Confira esta jóia pura fazendo exatamente isso: https://github.com/mislav/choices

Dessa forma, seus dados confidenciais não serão expostos em projetos de código aberto

Criei um plug-in simples para as configurações de YAML: Yettings

Funciona de maneira semelhante ao código na resposta do khelll, mas você só precisa adicionar este arquivo de configuração YAML:

app/config/yetting.yml

O plug-in cria dinamicamente uma classe que permite acessar as configurações YML como métodos de classe no seu aplicativo, da seguinte maneira:

Yetting.your_setting

Além disso, se você quiser usar vários arquivos de configurações com nomes exclusivos, poderá colocá-los em um subdiretório dentro de app / config como este:

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

Então você pode acessar os valores como este:

FirstYetting.your_setting
SecondYetting.your_setting

Ele também fornece configurações padrão que podem ser substituídas por ambiente. Você também pode usar erb dentro do arquivo yml.

Eu realmente gosto da jóia settingslogic . Muito fácil de configurar e usar.

https://github.com/binarylogic/settingslogic

Se você usa o Heroku ou precisa manter as configurações do aplicativo como variáveis ​​de ambiente, a gema figaro é muito útil.

Eu gosto de usar o rails-settings para valores globais de configuração que precisam ser alterados via interface da web.

Algo que estamos começando a fazer no trabalho é o Hash Ordenado do ActiveSupport

O que permite definir sua configuração de maneira limpa dentro dos arquivos do ambiente, por exemplo

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

Eu sugeriria uma boa abordagem sobre como lidar com a configuração em seu aplicativo. Existem três regras básicas:

• altere sua configuração, não um código;
• usar configurações sobre condições;
• escreva código que significa alguma coisa.

Para ter uma visão geral mais detalhada, siga este link: Configuração do Rails da maneira correta