Class: Lemon::Generator

Inherits:
Object
  • Object
show all
Defined in:
lib/lemon/generator.rb

Overview

Test Scaffold Generator.

Instance Method Summary collapse

Constructor Details

#initialize(files, options = {}) ⇒ Generator

New Scaffold Generator.

Parameters:

  • options (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (options):

  • :namespaces (Array) —

    List of class/module names to limit scaffolding.

  • :private (Boolean) —

    Include private methods in scaffolding.

  • :covered (Boolean) —

    Include covered targets in scaffolding.

  • :uncovered (Boolean) —

    Include uncovered targets in scaffolding.

  • :all (Boolean) —

    Include all possible targets in scaffolding.



31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
# File 'lib/lemon/generator.rb', line 31

def initialize(files, options={})
  @files      = files

  @coverage   = CoverageAnalyzer.new(files, options)
  @suite      = @coverage.suite

  @namespaces = options[:namespaces]
  @private    = options[:private]
  @covered    = options[:covered]
  @uncovered  = options[:uncovered]
  @all        = options[:all]

  if @namespaces
    unless @covered or @uncovered
      @all = true 
    end
  end

end

Instance Method Details

#all? ⇒ Boolean

Include all targets.

Returns:

  • (Boolean) 


62
63
64
 
# File 'lib/lemon/generator.rb', line 62

def all?
  @all
end

#coverage ⇒ Object

Returns CoverageAnalyzer instance.



52
53
54
 
# File 'lib/lemon/generator.rb', line 52

def coverage
  @coverage
end

#covered? ⇒ Boolean

Include targets that are already covered.

Returns:

  • (Boolean) 


67
68
69
 
# File 'lib/lemon/generator.rb', line 67

def covered?
  @covered
end

#filter(units) ⇒ Object

Filter targets to include only specified namespaces.



108
109
110
111
112
113
114
115
 
# File 'lib/lemon/generator.rb', line 108

def filter(units)
  return units if namespaces.nil? or namespaces.empty?
  units.select do |u|
    namespaces.any? do |ns|
      /^#{ns}/ =~ u.namespace.to_s
    end
  end
end

#generate ⇒ Object

Generate test template(s).



82
83
84
85
86
87
88
89
90
 
# File 'lib/lemon/generator.rb', line 82

def generate
  if all?
    generate_all
  elsif uncovered?
    generate_uncovered
  else
    generate_target
  end
end

#generate_all ⇒ Object

Generate code template for all.



103
104
105
 
# File 'lib/lemon/generator.rb', line 103

def generate_all
  render(Snapshot.capture(namespaces).units)
end

#generate_target ⇒ Object

Generate code template for covered.



93
94
95
 
# File 'lib/lemon/generator.rb', line 93

def generate_target
  render(filter(coverage.target.units))
end

#generate_uncovered ⇒ Object

Generate code template for uncovered.



98
99
100
 
# File 'lib/lemon/generator.rb', line 98

def generate_uncovered
  render(filter(coverage.uncovered))
end

#namespaces ⇒ Object

List of class and module namespaces to limit scaffolding.



57
58
59
 
# File 'lib/lemon/generator.rb', line 57

def namespaces
  @namespaces
end

#private? ⇒ Boolean

Include private and protected methods.

Returns:

  • (Boolean) 


77
78
79
 
# File 'lib/lemon/generator.rb', line 77

def private?
  @private
end

#render(units) ⇒ Object

Generate code template.



118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
 
# File 'lib/lemon/generator.rb', line 118

def render(units)
  code = []
  mods = units.group_by{ |u| u.namespace }
  mods.each do |mod, units|
    if Class === mod
      code << "TestClass #{mod} do"
    else
      code << "TestModule #{mod} do"
    end
    units.each do |unit|
      next unless private? or unit.public?
      if unit.function?
        code << "\n  ClassMethod :#{unit.method} do"
        code << "\n    Test '' do"
        code << "\n    end"
        code << "end"
      else
        code << "\n  Method :#{unit.method} do"
        code << "\n    Test '' do"
        code << "\n    end"
        code << "\n  end"
      end
    end
    code << "\nend\n"
  end

  code.join("\n")
end

#uncovered? ⇒ Boolean

Include only uncovered targrts.

Returns:

  • (Boolean) 


72
73
74
 
# File 'lib/lemon/generator.rb', line 72

def uncovered?
  @uncovered
end