Class: ActsAsActsAs::Requirements::Verifier

Inherits:
Object
  • Object
show all
Includes:
Macros
Defined in:
lib/acts_as_acts_as/requirements/verifier.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Macros

#drop_temp_model, #tableless_model, #temp_model, #temp_versioned_model

Constructor Details

#initialize(acts_as_method) ⇒ Verifier 



6
7
8
 
# File 'lib/acts_as_acts_as/requirements/verifier.rb', line 6

def initialize(acts_as_method)
  @acts_as_method = acts_as_method
end

Instance Attribute Details

#acts_as_method ⇒ Object

Returns the value of attribute acts_as_method.



3
4
5
 
# File 'lib/acts_as_acts_as/requirements/verifier.rb', line 3

def acts_as_method
  @acts_as_method
end

Instance Method Details

#define_methods(options, reqs, *methods) ⇒ Object 



109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
 
# File 'lib/acts_as_acts_as/requirements/verifier.rb', line 109

def define_methods(options, reqs, *methods)
  verifier       = self
  acts_as_method = @acts_as_method
  describe 'defined methods' do
    methods.each do |meth|
      it "#{meth} method is defined automatically" do
        mod = verifier.tableless_model(
          :columns => reqs[:require_columns],
          :methods => reqs[:require_methods]
        )
        lambda { mod.send(acts_as_method, options) }.should_not raise_error
        mod.new.should respond_to(meth)
      end
    end
  end
end

#require_class_methods(options, reqs, *methods) ⇒ Object 



38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/acts_as_acts_as/requirements/verifier.rb', line 38

def require_class_methods(options, reqs, *methods)
  verifier       = self
  acts_as_method = @acts_as_method
  describe 'required methods' do
    methods.each do |meth|
      it "#{meth} must be defined in class" do
        mod = verifier.tableless_model(
          :columns => reqs[:require_columns]
        )
        reqs[:require_class_methods].reject { |rm| rm == meth }.each do |method|
          mod.class_eval %{
            def self.#{method}
              true
            end
          }
        end
        lambda { mod.send(acts_as_method, options) }.should raise_error(/#{meth}/)
      end
    end
  end
end

#require_columns(options, reqs, *columns) ⇒ Object 



80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
 
# File 'lib/acts_as_acts_as/requirements/verifier.rb', line 80

def require_columns(options, reqs, *columns)
  verifier       = self
  acts_as_method = @acts_as_method
  describe 'required columns' do
    columns.each do |c|
      it "#{c[0]} must be defined as column in caller" do
        m = verifier.tableless_model(
          :columns => reqs[:require_columns].reject { |rc| rc == c },
          :methods => reqs[:require_methods]
        )
        lambda { m.send(acts_as_method, options) }.should raise_error(/#{c[0]}/)
      end

      it "#{c[0]} must be of type #{c[1]}" do
        goodm = verifier.tableless_model(
          :columns => reqs[:require_columns],
          :methods => reqs[:require_methods]
        )
        badm = verifier.tableless_model(
          :columns => reqs[:require_columns].map { |rc| (rc != c) ? rc : [rc[0], :badcoltype]},
          :methods => reqs[:require_methods]
        )
        lambda { goodm.send(acts_as_method, options) }.should_not raise_error
        lambda { badm.send(acts_as_method,  options) }.should raise_error(/#{c[0]}/)
      end
    end
  end
end

#require_methods(options, reqs, *methods) ⇒ Object 



22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
# File 'lib/acts_as_acts_as/requirements/verifier.rb', line 22

def require_methods(options, reqs, *methods)
  verifier       = self
  acts_as_method = @acts_as_method
  describe 'required methods' do
    methods.each do |meth|
      it "#{meth} must be defined in caller" do
        mod = verifier.tableless_model(
          :columns => reqs[:require_methods],
          :methods => reqs[:require_methods].reject { |rm| rm == meth }
        )
        lambda { mod.send(acts_as_method, options) }.should raise_error(/#{meth}/)
      end
    end
  end
end

#require_parameters(options, reqs, *parameters) ⇒ Object 



60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/acts_as_acts_as/requirements/verifier.rb', line 60

def require_parameters(options, reqs, *parameters)
  verifier       = self
  acts_as_method = @acts_as_method
  describe 'required methods' do
    parameters.each do |parameter|
      it "#{parameter} must be passed in the #{acts_as_method} options hash " do
        mod = verifier.tableless_model(
          :columns => reqs[:require_columns]
        )

        passing_options = parameters.inject({}) {|h, param| h[param] = :foo ; h}
        passing_options.merge!(options)
        passing_options.delete(parameter)

        lambda { mod.send(acts_as_method, passing_options) }.should raise_error(/#{parameter}/)
      end
    end
  end
end

#verify_requirements(collector) ⇒ Object 



10
11
12
13
14
15
16
17
18
19
20
 
# File 'lib/acts_as_acts_as/requirements/verifier.rb', line 10

def verify_requirements(collector)
  verifier       = self
  acts_as_method = self.acts_as_method
  collector.all.each do |c|
    describe "with options: #{c.options.inspect}" do
      c.requirements.each_pair do |method, args|
        verifier.send(method, c.options, c.requirements, *args)
      end
    end 
  end
end