Ruby on Rails: ¿Dónde definir constantes globales?

Recién estoy comenzando con mi primera aplicación web Ruby on Rails. Tengo un montón de diferentes modelos, vistas, controladores, etc.

Quiero encontrar un buen lugar para pegar definiciones de constantes verdaderamente globales, que se apliquen a toda mi aplicación. En particular, se aplican tanto en la lógica de mis modelos como en las decisiones tomadas en mis puntos de vista. No puedo encontrar ningún lugar SECO para poner estas definiciones donde estén disponibles tanto para todos mis modelos como para todas mis vistas.

Para tomar un ejemplo específico, quiero una constante COLOURS = ['white', 'blue', 'black', 'red', 'green']. Esto se usa en todo el lugar, tanto en modelos como en vistas. ¿Dónde puedo definirlo en un solo lugar para que sea accesible?

Lo que probé:

• Variables de clase constante en el archivo model.rb con las que están más asociadas, como @@COLOURS = [...]. Pero no pude encontrar una forma sensata de definirlo para poder escribir en mis puntos de vista en Card.COLOURSlugar de algo muy grosero Card.first.COLOURS.
• Un método en el modelo, algo así como el def colours ['white',...] endmismo problema.
• Un método en application_helper.rb: esto es lo que estoy haciendo hasta ahora, pero los ayudantes solo son accesibles en vistas, no en modelos
• Creo que podría haber intentado algo en application.rb o environment.rb, pero eso no parece correcto (y tampoco parece funcionar)

¿No hay forma de definir algo que sea accesible tanto desde los modelos como desde las vistas? Quiero decir, sé que los modelos y las vistas deben estar separados, pero seguramente en algunos dominios habrá ocasiones en que necesiten referirse al mismo conocimiento específico del dominio.

Si su modelo es realmente "responsable" de las constantes, debe pegarlas allí. Puede crear métodos de clase para acceder a ellos sin crear una nueva instancia de objeto:

class Card < ActiveRecord::Base
  def self.colours
    ['white', 'blue']
  end
end

# accessible like this
Card.colours

Alternativamente, puede crear variables de clase y un descriptor de acceso. Sin embargo, esto se desaconseja, ya que las variables de clase pueden ser algo sorprendentes con la herencia y en entornos de subprocesos múltiples.

class Card < ActiveRecord::Base
  @@colours = ['white', 'blue']
  cattr_reader :colours
end

# accessible the same as above

Las dos opciones anteriores le permiten cambiar la matriz devuelta en cada invocación del método de acceso si es necesario. Si tiene una constante verdaderamente inmutable, también puede definirla en la clase de modelo:

class Card < ActiveRecord::Base
  COLOURS = ['white', 'blue'].freeze
end

# accessible as
Card::COLOURS

También podría crear constantes globales a las que se pueda acceder desde cualquier lugar en un inicializador como en el siguiente ejemplo. Este es probablemente el mejor lugar, si sus colores son realmente globales y se usan en más de un contexto de modelo.

# put this into config/initializers/my_constants.rb
COLOURS = ['white', 'blue'].freeze

Nota: cuando definimos las constantes anteriores, a menudo queremos freezela matriz. Eso evita que otro código modifique más tarde (sin darse cuenta) la matriz, por ejemplo, agregando un nuevo elemento. Una vez que un objeto está congelado, ya no se puede cambiar.

Algunas opciones:

Usando una constante:

class Card
  COLOURS = ['white', 'blue', 'black', 'red', 'green', 'yellow'].freeze
end

Carga diferida usando la variable de instancia de clase:

class Card
  def self.colours
    @colours ||= ['white', 'blue', 'black', 'red', 'green', 'yellow'].freeze
  end
end

Si es una constante verdaderamente global ( sin embargo, evite las constantes globales de esta naturaleza ), también podría considerar poner una constante de nivel superior, config/initializers/my_constants.rbpor ejemplo.

A partir de Rails 4.2, puede usar la config.xpropiedad:

# config/application.rb (or config/custom.rb if you prefer)
config.x.colours.options = %w[white blue black red green]
config.x.colours.default = 'white'

Que estará disponible como:

Rails.configuration.x.colours.options
# => ["white", "blue", "black", "red", "green"]
Rails.configuration.x.colours.default
# => "white"

Otro método para cargar la configuración personalizada:

# config/colours.yml
default: &default
  options:
    - white
    - blue
    - black
    - red
    - green
  default: white
development:
  *default
production:
  *default

# config/application.rb
config.colours = config_for(:colours)

Rails.configuration.colours
# => {"options"=>["white", "blue", "black", "red", "green"], "default"=>"white"}
Rails.configuration.colours['default']
# => "white"

En los rieles 5 y 6 , puede usar el configurationobjeto directamente para la configuración personalizada, además de config.x. Sin embargo, solo se puede usar para configuraciones no anidadas:

# config/application.rb
config.colours = %w[white blue black red green]

Estará disponible como:

Rails.configuration.colours
# => ["white", "blue", "black", "red", "green"]

Si se necesita una constante en más de una clase, la pongo en config / initializers / contant.rb siempre en mayúsculas (la lista de estados a continuación está truncada).

STATES = ['AK', 'AL', ... 'WI', 'WV', 'WY']

Están disponibles en toda la aplicación, excepto en el código del modelo como tal:

    <%= form.label :states, %>
    <%= form.select :states, STATES, {} %>

Para usar la constante en un modelo, use attr_accessor para hacer que la constante esté disponible.

class Customer < ActiveRecord::Base
    attr_accessor :STATES

    validates :state, inclusion: {in: STATES, message: "-- choose a State from the drop down list."}
end

Para la configuración de toda la aplicación y para las constantes globales, recomiendo usar Settingslogic . Esta configuración se almacena en un archivo YML y se puede acceder desde modelos, vistas y controladores. Además, puede crear diferentes configuraciones para todos sus entornos:

  # app/config/application.yml
  defaults: &defaults
    cool:
      sweet: nested settings
    neat_setting: 24
    awesome_setting: <%= "Did you know 5 + 5 = #{5 + 5}?" %>

    colors: "white blue black red green"

  development:
    <<: *defaults
    neat_setting: 800

  test:
    <<: *defaults

  production:
    <<: *defaults

En algún lugar de la vista (prefiero los métodos de ayuda para este tipo de cosas) o en un modelo que puede obtener, por ejemplo, una variedad de colores Settings.colors.split(/\s/). Es muy flexible. Y no necesitas inventar una bicicleta.

Utiliza un método de clase:

def self.colours
  ['white', 'red', 'black']
end

Luego Model.coloursdevolverá esa matriz. Alternativamente, cree un inicializador y ajuste las constantes en un módulo para evitar conflictos de espacio de nombres.

Intente mantener todo constante en un solo lugar. En mi aplicación, he creado una carpeta de constantes dentro de los inicializadores de la siguiente manera:

y generalmente mantengo todo constante en estos archivos.

En su caso, puede crear un archivo en la carpeta de constantes como colors_constant.rb

colors_constant.rb

No olvides reiniciar el servidor

Otra opción, si desea definir sus constantes en un lugar:

module DSL
  module Constants
    MY_CONSTANT = 1
  end
end

Pero aún así hacerlos visibles globalmente sin tener que acceder a ellos de manera totalmente calificada:

DSL::Constants::MY_CONSTANT # => 1
MY_CONSTANT # => NameError: uninitialized constant MY_CONSTANT
Object.instance_eval { include DSL::Constants }
MY_CONSTANT # => 1

Un lugar común para colocar constantes globales de toda la aplicación es dentro config/application.

module MyApp
  FOO ||= ENV.fetch('FOO', nil)
  BAR ||= %w(one two three)

  class Application < Rails::Application
    config.foo_bar = :baz
  end
end

Normalmente tengo un modelo / tabla de 'búsqueda' en mi programa rails y lo uso para las constantes. Es muy útil si las constantes van a ser diferentes para diferentes entornos. Además, si tiene un plan para extenderlos, digamos que desea agregar 'amarillo' en una fecha posterior, simplemente puede agregar una nueva fila a la tabla de búsqueda y listo.

Si otorga permisos de administrador para modificar esta tabla, no acudirán a usted para realizar tareas de mantenimiento. :) SECO.

Así es como se ve mi código de migración:

class CreateLookups < ActiveRecord::Migration
  def change
    create_table :lookups do |t|
      t.string :group_key
      t.string :lookup_key
      t.string :lookup_value
      t.timestamps
    end
  end
end

Yo uso seeds.rb para rellenarlo previamente.

Lookup.find_or_create_by_group_key_and_lookup_key_and_lookup_value!(group_key: 'development_COLORS', lookup_key: 'color1', lookup_value: 'red');

La variable global debe declararse en el config/initializersdirectorio

COLOURS = %w(white blue black red green)

De acuerdo con su condición, también puede definir algunas variables ambientales y buscarlas ENV['some-var']en código ruby, esta solución puede no ser adecuada para usted, pero espero que pueda ayudar a otros.

Ejemplo: se pueden crear diferentes archivos .development_env, .production_env, .test_envy cargarlo según sus entornos de aplicaciones, marque esta generación dotenv-carriles que automatizan esto para su.