I have a module like the following
module MyModule
def self.included(base)
base.extend ClassMethods
end
module ClassMethods
def foo
##var = 1
end
def bar
puts ##var
end
end
end
class A
include MyModule
foo
end
class B < A; end
so that
B.bar outputs '1'.
However, I would like to have .bar only be defined if .foo is called. I tried
module MyModule
def self.included(base)
base.extend ClassMethods
end
module ClassMethods
def foo
##var = 1
extend SingletonMethods
end
module SingletonMethods
def bar
puts ##var
end
end
end
The problem is that
B.bar
returns the error "uninitialized class variable ##var in MyModule::SingletonMethods". How can I make it so that a variable defined in .foo is available to .bar?
use mattr_accessor instead
I was able to access class variables from a module using the self syntax
class User
include Base
##attributes = [:slug, :email, :crypted_password]
end
module Base
def self.included(base)
base.extend ClassMethods
end
def headers
if defined? self.attributes
self.attributes
end
end
end
Now calling User.headers gives me the expected result of
[:slug, :email, :crypted_password]
If anyone can shed more light on why this works exactly so in ruby, please let me know!
Related
I know there is should be a way to initialize class instance variable that added by a module via extend
example:
module MyModule
def self.included(base)
base.extend ClassMethods
base.send :include, InstanceMethods
end
module ClassMethods
attr_accessor :count
def self.count
#count = 0
end
count
end
module InstanceMethods
def register
# self.class.count = 0 if self.class.count.nil?
self.class.count += 1
end
end
end
class Foo
include MyModule
private
def initialize
register
end
end
In ClassMethods should be a way to initialize count, but i always catch error "undefined method `+' for nil:NilClass"
When i perform
f = Foo.new
No problem in module InstanceMethods if i uncomment line
# self.class.count = 0 if self.class.count.nil?
Work correctly!
You could move the variable initialization into the included callback:
module MyModule
def self.included(base)
base.extend ClassMethods
base.include InstanceMethods
base.count = 0
end
module ClassMethods
attr_accessor :count
end
module InstanceMethods
def register
self.class.count += 1
end
end
end
One bit too many self in your code. You already extend your ClassMethods module. extend uses instance methods, not class methods. So your module should look like this (rest of the code unchanged).
module ClassMethods
def count
#count ||= 0
end
attr_writer :count
end
Then it works
Foo.count # => 0
Foo.new
Foo.count # => 1
I want to create a DSL which stores various blocks, and then can call them. I want this to be a reusable module that I can include in multiple classes.
I figured out a way to do this using class variables, but rubocop complains and says that I should use class instance variables instead. I can't figure out a way to do this though. Is it possible?
module MyModule
def self.included(base)
base.extend(ClassMethods)
end
def run_fixers
ClassMethods.class_variable_get(:##fixers).each(&:call)
end
module ClassMethods
def fix(_name, &block)
##fixers ||= []
##fixers << block
end
end
end
class MyClass
include MyModule
def initialize
run_fixers
end
fix 'test' do
puts 'testing'
end
end
Rubocop complains about ##class_variable style. Class variables usage can be refactored into using instance variable of a class:
class SomeClass
#some_variable ||= []
end
instead of
class SomeClass
##some_variable ||= []
end
You can define instance variable of a class in any place where self equals to the class object. For example, in a class method:
module MyModule
def self.included(base)
base.extend(ClassMethods)
end
def run_fixers
ClassMethods.fixers.each(&:call)
end
module ClassMethods
def self.fixers
#fixers ||= []
end
def fix(_name, &block)
ClassMethods.fixers << block
end
end
end
So while I'm all against extending existing classes this way, sometimes (hacking rspec) it's necessary to do something like:
module MyModule
module ClassMethods
def define_something(name)
##names ||= []
##names << name
end
end
def self.included(base)
base.extend ClassMethods
end
def all_names
##names
end
end
class Example
include MyModule
define_something "one"
define_something "two"
end
Example.new.all_names
and then it yields this error:
NameError: uninitialized class variable ##names in MyModule
and I understand that because at the time of writing MyModule::ClassMethods - we are working on instance not class (not self.), so I tried:
module MyModule
module ClassMethods
def define_something(name)
#names ||= []
#names << name
end
end
def self.included(base)
base.extend ClassMethods
end
def all_names
##names
end
end
class Example
include MyModule
define_something "one"
define_something "two"
end
Example.new.all_names
it does not work either, finally I ended up with:
module MyModule
module ClassMethods
def define_something(name)
#names << name
end
end
def self.included(base)
base.instance_variable_set(:#names, [])
base.send(:define_method, :all_names) { base.instance_variable_get(:#names) }
base.extend ClassMethods
end
end
class Example
include MyModule
define_something "one"
define_something "two"
end
Example.new.all_names
Is there a better way to do that?
It's usually better from a design perspective to avoid crossing the class/instance line using instance variable references. This is usually more clear:
module MyModule
module ClassMethods
def define_something(name)
self.defined_somethings << name
end
def defined_somethings
#_my_module_names ||= []
end
end
def self.included(base)
base.extend ClassMethods
end
def all_names
self.class.defined_somethings
end
end
class Example
include MyModule
define_something "one"
define_something "two"
end
Example.new.all_names.inspect
#=> ["one","two"]
I've taken care here to create a class-level instance variable with a verbose name. Calling it #name could put it into conflict with a variable defined by the class that includes this module. Remember, when designing mixin code you're a guest and you need to be extra polite.
Class-type instance variables like ##name are sometimes trouble because they can end up spanning inheritance chains depending on how they're used. Defining a method means you can override it at any point in the chain, something not possible with a shared variable.
In other words, treat the instance's class as a separate object and make clear, well-defined method calls to maintain that separation.
Try the following
module MyModule
module ClassMethods
def define_something(name)
#names ||= []
#names << name
end
end
def self.included(base)
base.extend ClassMethods
end
def all_names
self.class.instance_variable_get(:#names)
end
end
class Example
include MyModule
define_something "one"
define_something "two"
end
Example.new.all_names
A class variable can be accessed using ## operator from a class level method i.e. self. methods.
#tadman's answer has a generic approach for similar problems (generally found in gems that provide modules to implement a functionality)
Ruby library code
module Yaffle
module ActsAsYaffle
def self.included(base)
base.extend(ClassMethods)
end
module ClassMethods
def acts_as_yaffle(options = {})
cattr_accessor :yaffle_text_field
self.yaffle_text_field = (options[:yaffle_text_field] || :last_squawk).to_s
include Yaffle::ActsAsYaffle::LocalInstanceMethods
end
end
...
more code
...
end
end
ActiveRecord::Base.send(:include, ActiveRecord::Acts::Taggable)
Why does when i call the acts_as_yaffle in the model, its being used like
class Hickwall < ActiveRecord::Base
acts_as_yaffle
end
Does the ActiveRecord::Base.send(:include,...) included the ClassMethods as instance eventhough the base is extended (base.extend(ClassMethods) ?
The acts_as_yaffle was declared as a ClassMethods.
It is a class method. Consider this example:
class C
def my_instance_method
puts 'hello from instance'
end
def self.my_class_method
puts 'hello from class'
end
my_instance_method
# NoMethodError
my_class_method
# hello from class
end
inside class C ... end you can only call class methods, because there is no instance to send the method call to. The library code is written using a common pattern to put class methods inside a module. For better understanding, the example class I wrote above is equivalent to this:
module M
def my_instance_method
puts 'hello from instance'
end
def self.included(base)
base.extend(ClassMethods)
end
module ClassMethods
def my_class_method
puts 'hello from class'
end
end
end
Having a hard time figuring this out. Suppose I wanted to write a module, and when included, it would allow classes to define methods by calling a method with symbols
class Anything
include Foo
initializers :hello, :goodbye
end
module Foo
# What goes in here? Its not
# def self.initializers(*symbols)
end
Same syntax idea as attr_accessible. Tried finding it in the Rails source, but, well..
module Foo
def self.included(base)
base.extend ClassMethods
end
module ClassMethods
def initializers *names
names.each do |name|
define_method name do
'ok'
end
end
end
end
def self.included(base)
base.extend ClassMethods
end
end
class Anything
include Foo
initializers :hello, :goodbye
end
puts Anything.new.hello #=> ok
for example:
module Foo
def self.included(base)
block = Proc.new do |*symbols|
puts symbols.inspect
end
base.class.send(:define_method, :initializers, block)
end
end
class Anything
include Foo
initializers :one, :two , :three
end