ruby-on-rails - define_method - modules in ruby

Alcance de las constantes en los módulos Ruby

Question

Estoy teniendo un pequeño problema con el alcance constante en los módulos mixin. Digamos que tengo algo como esto

module Auth
USER_KEY = "user" unless defined? USER_KEY
def authorize
user_id = session[USER_KEY]
def
end

La constante USER_KEY debe establecerse como "usuario" a menos que ya esté definida. Ahora puedo mezclar esto en un par de lugares, pero en uno de esos lugares el USER_KEY debe ser diferente, así que podríamos tener algo como esto

class ApplicationController < ActionController::Base
USER_KEY = "my_user"
include Auth
def test_auth
authorize
end
end

Esperaría que USER_KEY fuera "mi_usuario" cuando se utilizara en authorize, dado que ya está definido, pero sigue siendo "user", tomado de la definición de USER_KEY de los módulos. ¿Alguien tiene alguna idea de cómo autorizar para usar la versión de clases de USER_KEY?

Answer 1

La USER_KEY que ha declarado (incluso condicionalmente) en Auth se conoce globalmente como Auth::USER_KEY . No se "mezcla" para incluir módulos, aunque los módulos que incluyen pueden hacer referencia a la clave de una manera no calificada.

Si desea que cada módulo incluido (por ejemplo, ApplicationController ) pueda definir su propia USER_KEY , intente esto:

module Auth
DEFAULT_USER_KEY = ''user''
def self.included(base)
unless base.const_defined?(:USER_KEY)
base.const_set :USER_KEY, Auth::DEFAULT_USER_KEY
end
end
def authorize
user_id = session[self.class.const_get(:USER_KEY)]
end
end
class ApplicationController < ActionController::Base
USER_KEY = ''my_user''
include Auth
end

Sin embargo, si vas a tomar todas estas molestias, es mejor que lo conviertas en un método de clase:

module Auth
DEFAULT_USER_KEY = ''user''
def self.included(base)
base.extend Auth::ClassMethods
base.send :include, Auth::InstanceMethods
end
module ClassMethods
def user_key
Auth::DEFAULT_USER_KEY
end
end
module InstanceMethods
def authorize
user_id = session[self.class.user_key]
end
end
end
class ApplicationController < ActionController::Base
def self.user_key
''my_user''
end
end

o un descriptor de nivel de clase:

module Auth
DEFAULT_USER_KEY = ''user''
def self.included(base)
base.send :attr_accessor :user_key unless base.respond_to?(:user_key=)
base.user_key ||= Auth::DEFAULT_USER_KEY
end
def authorize
user_id = session[self.class.user_key]
end
end
class ApplicationController < ActionController::Base
include Auth
self.user_key = ''my_user''
end

Answer 2

Aquí hay una solución simple.

Cambios:

• No es necesario verificar la existencia de USER_KEY .
• Intente buscar la constante en el módulo / clase del receptor (en su caso sería el controlador). Si existe, úselo, de lo contrario use el módulo / clase predeterminado (ver abajo cuál es el valor predeterminado).

.

module Auth
USER_KEY = "user"
def authorize
user_key = self.class.const_defined?(:USER_KEY) ? self.class::USER_KEY : USER_KEY
user_id = session[user_key]
def
end

Explicación

El comportamiento que está viendo no es específico de los rieles, sino que se debe a que Ruby busca constantes si no tiene un alcance explícito a través de :: (lo que yo llamo "predeterminado" más arriba). Las constantes se buscan utilizando el "alcance léxico del código que se está ejecutando actualmente". Esto significa que Ruby primero busca la constante en el módulo (o clase) del código de ejecución, luego se mueve hacia afuera a cada módulo (o clase) sucesivo de inclusión hasta que encuentra la constante definida en ese ámbito.

En tu controlador, llamas authorize . Pero cuando authorize está ejecutando, el código que se está ejecutando actualmente está en Auth . Entonces ahí es donde se buscan las constantes. Si Auth no tenía USER_KEY , pero un módulo adjunto lo tiene, entonces se usaría el que lo incluye. Ejemplo:

module Outer
USER_KEY = ''outer_key''
module Auth
# code here can access USER_KEY without specifying "Outer::"
# ...
end
end

Un caso especial de esto es el entorno de ejecución de nivel superior, que se trata como perteneciente a la clase Object .

USER_KEY = ''top-level-key''
module Auth
# code here can access the top-level USER_KEY (which is actually Object::USER_KEY)
# ...
end

Una dificultad es definir un módulo o clase con el operador de scoping ( :: :):

module Outer
USER_KEY = ''outer_key''
end
module Outer::Auth
# methods here won''t be able to use USER_KEY,
# because Outer isn''t lexically enclosing Auth.
# ...
end

Tenga en cuenta que la constante se puede definir mucho más tarde de lo que se define el método. La búsqueda solo ocurre cuando se accede a USER_KEY, por lo que esto también funciona:

module Auth
# don''t define USER_KEY yet
# ...
end
# you can''t call authorize here or you''ll get an uninitialized constant error
Auth::USER_KEY = ''user''
# now you can call authorize.

Answer 3

Las constantes no tienen alcance global en Ruby. Las constantes pueden ser visibles desde cualquier ámbito, pero debe especificar dónde se encuentra la constante. Cuando comienza una nueva clase, módulo o definición, comienza un nuevo ámbito, y si desea una constante desde otro ámbito, debe especificar dónde encontrarlo.

X = 0
class C
X = 1
module M
X = 2
class D
X = 3
puts X # => 3
puts C::X # => 1
puts C::M::X # => 2
puts M::X # => 2
puts ::X # => 0
end
end
end

Answer 4

Si su proyecto está en Rails, o al menos utiliza el módulo ActiveSupport , puede reducir significativamente la necesaria azúcar lógica:

module Auth
extend ActiveSupport::Concern
included do
# set a global default value
unless self.const_defined?(:USER_KEY)
self.const_set :USER_KEY, ''module_user''
end
end
end
class ApplicationController < ActionController::Base
# set an application default value
USER_KEY = "default_user"
include Auth
end
class SomeController < ApplicationController
# set a value unique to a specific controller
USER_KEY = "specific_user"
end

Me sorprende que nadie sugiriera este enfoque, ya que la situación del OP residía en una aplicación de Rails ...

Answer 5

Hay una solución mucho más simple para la pregunta de OP que las otras respuestas aquí revelan:

module Foo
THIS_CONST = ''foo''
def show_const
self.class::THIS_CONST
end
end
class Bar
include Foo
THIS_CONST =''bar''
def test_it
show_const
end
end
class Baz
include Foo
def test_it
show_const
end
end
2.3.1 :004 > r = Bar.new
=> #<Bar:0x000000008be2c8>
2.3.1 :005 > r.test_it
=> "bar"
2.3.1 :006 > z = Baz.new
=> #<Baz:0x000000008658a8>
2.3.1 :007 > z.test_it
=> "foo" 

Fue la respuesta de @ james-a-rosen la que me dio la inspiración para probar esto. No quería ir a su ruta porque tenía varias constantes que se comparten entre varias clases, cada una con un valor diferente, y su método parecía una gran cantidad de tipeo.