Class: Makers::Dsl::Maker

Inherits:
Object
  • Object
show all
Defined in:
lib/makers/dsl/maker.rb

Instance Method Summary collapse

Constructor Details

#initialize(name, options = {}, &block) ⇒ Maker 



5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
# File 'lib/makers/dsl/maker.rb', line 5

def initialize(name, options={}, &block)
  @name = name
  @options = options.reverse_merge(class_name: name.to_s.classify)
  @class = @options[:class_name].constantize
  @assignments = {}
  @associations = {}
  @sequences = {}
  if block_given?
    instance_eval &block
  end
  Makers.definitions.add(
    [@name] + Array(@options[:aliases]),
    @assignments,
    @associations,
    @sequences,
    @options
  )
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(name, *args, &block) ⇒ Object 



73
74
75
76
77
78
79
80
81
 
# File 'lib/makers/dsl/maker.rb', line 73

def method_missing(name, *args, &block)
  if @class.reflections.has_key?(name.to_s)
    association name, *args
  elsif block_given?
    @assignments[name] = block
  elsif args.size > 0
    @assignments[name] = -> { args.first }
  end
end

Instance Method Details

#association(name, *args) ⇒ Object 



48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
# File 'lib/makers/dsl/maker.rb', line 48

def association(name, *args)
  options = args.extract_options!
  lookup = (options[:maker] || name)
  action = (options[:strategy] || :build)
  reflection = @class.reflections[name.to_s]
  class_name = @class.name
  case reflection.macro
  when :belongs_to,:has_one
    @assignments[name] = -> {
      maker = Makers.definitions.find(lookup).dup
      maker.disabled_association = class_name
      maker.send action
    }
  when :has_many
    @assignments[name] = -> {
      maker = Makers.definitions.find(lookup.to_s.singularize.to_sym).dup
      maker.disabled_association = class_name
      (args.first || 1).times.map do
        maker.send action
      end
    }
  end
  @associations[name] = reflection.class_name
end

#maker(name, overrides = {}, &block) ⇒ Object 



24
25
26
27
28
29
30
31
 
# File 'lib/makers/dsl/maker.rb', line 24

def maker(name, overrides={}, &block)
  byebug unless @options.is_a?(Hash)
  options = @options.dup
  options.delete :aliases
  options.merge! overrides
  options.merge! parent: @name
  Dsl::Maker.new name, options, &block
end

#sequence(name, &block) ⇒ Object 



33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
# File 'lib/makers/dsl/maker.rb', line 33

def sequence(name, &block)
  index = 0
  if block_given?
    @assignments[name] = -> {
      index += 1
      instance_exec index, &block
    }
  else
    @assignments[name] = -> {
      index += 1
    }
  end
  @sequences[name] = index
end