Module: Yaks::Configurable

Included in:
Builder, Mapper
Defined in:
lib/yaks/configurable.rb

Overview

A “Configurable” class is one that keeps a configuration in a separate immutable object, of type class::Config. say you have

class MyMapper < Yaks::Mapper
  # use yaks configuration DSL in here
end

The links, associations, etc, that you set up for MyMapper, will be available in MyMapper.config, which is an instance of Yaks::Mapper::Config.

Each configuration step, like link, has_many, will replace MyMapper.config with an updated version, discarding the old config.

By extending Configurable, a number of “macros” become available to describe the DSL that subclasses can use. See the docs for def_set. def_forward, and def_add.

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#config ⇒ Object

Returns the value of attribute config.



21
22
23
 
# File 'lib/yaks/configurable.rb', line 21

def config
  @config
end

Class Method Details

.extended(child) ⇒ Object 



23
24
25
 
# File 'lib/yaks/configurable.rb', line 23

def self.extended(child)
  child.config = child::Config.new
end

Instance Method Details

#def_add(name, options) ⇒ Object

Generate a DSL method that creates a certain type of domain object, and adds it to a list on the config.

def_add :fieldset, create: Fieldset, append_to: :fields

This will generate a fieldset method, which will call Fieldset.create, and append the result to config.fields



76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
 
# File 'lib/yaks/configurable.rb', line 76

def def_add(name, options)
  old_verbose, $VERBOSE = $VERBOSE, false # skip method redefinition warning
  define_singleton_method name do |*args, &block|
    defaults = options.fetch(:defaults, {})
    klass    = options.fetch(:create)

    if args.last.instance_of?(Hash)
      args[-1] = defaults.merge(args[-1])
    else
      args << defaults
    end

    self.config = config.append_to(
      options.fetch(:append_to),
      klass.create(*args, &block)
    )
  end
ensure
  $VERBOSE = old_verbose
end

#def_forward(mappings, *names) ⇒ Object

Forward a method to the config object. This assumes the method will return an updated config instance.

Either takes a list of methods to forward, or a mapping (hash) of source to destination method name.



57
58
59
60
61
62
63
64
65
66
67
 
# File 'lib/yaks/configurable.rb', line 57

def def_forward(mappings, *names)
  if mappings.instance_of? Hash
    mappings.each do |method_name, target|
      define_singleton_method method_name do |*args, &block|
        self.config = config.public_send(target, *args, &block)
      end
    end
  else
    def_forward([mappings, *names].map{|name| {name => name}}.inject(:merge))
  end
end

#def_set(*method_names) ⇒ Object

Create a DSL method to set a certain config property. The generated method will take either a plain value, or a block, which will be captured and stored instead.



34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 
# File 'lib/yaks/configurable.rb', line 34

def def_set(*method_names)
  method_names.each do |method_name|
    define_singleton_method method_name do |arg = Undefined, &block|
      if arg.equal?(Undefined)
        unless block
          raise ArgumentError, "setting #{method_name}: no value and no block given"
        end
        self.config = config.with(method_name => block)
      else
        if block
          raise ArgumentError, "ambiguous invocation setting #{method_name}: give either a value or a block, not both."
        end
        self.config = config.with(method_name => arg)
      end
    end
  end
end

#inherited(child) ⇒ Object 



27
28
29
 
# File 'lib/yaks/configurable.rb', line 27

def inherited(child)
  child.config = config
end