lemon 0.9.0 → 0.9.1

data/lib/lemon/coverage/formats/verbose.rb

@@ -41,7 +41,7 @@ module Lemon::CoverReports
 
     #
     def unit_line(unit, color)
-      data = [unit.to_s.ansi(color), unit.access.to_s, unit.function? ? 'function' : 'instance method']
+      data = [unit.to_s.ansi(color), unit.access.to_s, unit.singleton? ? 'class method' : 'instance method']
       "* %s  %s %s" % data
     end
 

data/lib/lemon/coverage/generator.rb

@@ -0,0 +1,196 @@
+module Lemon
+
+  require 'lemon/coverage/analyzer'
+  require 'lemon/coverage/source_parser'
+
+  # TODO: Add option to add `require <file>` for each test file genetated.
+
+  # Test Scaffold Generator.
+  #
+  class Generator
+
+    # New Scaffold Generator.
+    #
+    # @option options [Array] :files
+    #   Ruby scripts for which to generate tests.
+    #
+    # @option options [Array] :tests
+    #   Test files that already exist.
+    #
+    # @option options [Array] :namespaces
+    #   List of class/module names to limit scaffolding.
+    #
+    # @option options [Boolean] :private
+    #   Include private methods in scaffolding.
+    #
+    # @option options [Symbol] :group
+    #   Group by `:case` or by `:file`.
+    #
+    def initialize(options={})
+      @files      = options[:files] || []
+      @tests      = options[:tests] || []
+      @group      = options[:group] || :case
+
+      @namespaces = options[:namespaces]
+      #@coverage   = options[:coverage]
+      @private    = options[:private]
+      @caps       = options[:caps]
+
+      #if @namespaces
+      #  @coverage ||= :all
+      #else
+      #  @coverage ||= :uncovered
+      #end
+
+      #@snapshot   = Snapshot.capture
+
+      @analyzer   = CoverageAnalyzer.new(files + tests, options)
+      @suite      = @analyzer.suite
+    end
+
+    #
+    attr :files
+
+    #
+    attr :tests
+
+    # Group tests by `:case` or `:file`.
+    attr :group
+
+    # List of class and module namespaces to limit scaffolding.
+    attr :namespaces
+
+    # Target coverage `:all`, `:uncovered` or `:covered`.
+    #def coverage
+    #  @coverage
+    #end
+
+    # Include private and protected methods.
+    def private?
+      @private
+    end
+
+    # Returns CoverageAnalyzer instance.
+    def analyzer
+      @analyzer
+    end
+
+    # Units in groups, by file or by case.
+    def grouped_units
+      case group
+      when :case
+        units_by_case
+      when :file
+        units_by_file
+      else
+        units_by_case # default ?
+      end
+    end
+
+    # Generate test template(s).
+    def generate
+      render_map = {}
+
+      if tests.empty?
+        grouped_units.each do |group, units|
+          units = filter(units)
+          render_map[group] = render(units)
+        end
+      else
+        uncovered_units = analyzer.uncovered
+        grouped_units.each do |group, units|
+          units = filter(units)
+          units = units & uncovered_units
+          render_map[group] = render(units)
+        end
+      #when :covered
+      #  covered_units = analyzer.target.units
+      #  grouped_units.each do |group, units|
+      #    units = filter(units)
+      #    units = units & covered_units
+      #    map[group] = render(units)
+      #  end
+      #else
+      #  #units = Snapshot.capture(namespaces).units
+      #  #units = (units - @snapshot.units)
+      end
+
+      render_map
+    end
+
+    # TODO: If units knew which file they came from that would make
+    #       the code more efficient b/c then we could group after all
+    #       filtering instead of before.
+
+    #
+    def units_by_case
+      units = []
+      files.each do |file|
+        units.concat SourceParser.parse_units(File.read(file))
+      end
+      units.group_by{ |u| u.namespace }
+    end
+
+    #
+    def units_by_file
+      map = {}
+      files.each do |file|
+        units = SourceParser.parse_units(File.read(file))
+        map[file] = units
+      end
+      map
+    end
+
+    # Filter targets to include only specified namespaces.
+    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 code template.
+    def render(units)
+      code = []
+      mods = units.group_by{ |u| u.namespace }
+      mods.each do |mod, units|
+        code << "#{term_case} #{mod} do"
+        units.each do |unit|
+          next unless private? or unit.public?
+          if unit.singleton?
+            code << "\n  #{term_class_method} :#{unit.method} do"
+            code << "\n    test '' do"
+            code << "\n    end"
+            code << "\n  end"
+          else
+            code << "\n  #{term_method} :#{unit.method} do"
+            code << "\n    test '' do"
+            code << "\n    end"
+            code << "\n  end"
+          end
+        end
+        code << "\nend\n"
+      end
+      code.join("\n")
+    end
+
+    #
+    def term_case
+      @caps ? 'TestCase' : 'test_case'
+    end
+
+    #
+    def term_class_method
+      @caps ? 'ClassMethod' : 'class_method'
+    end
+
+    #
+    def term_method
+      @caps ? 'Method' : 'method'
+    end
+
+  end
+
+end

data/lib/lemon/coverage/snapshot.rb

@@ -64,7 +64,7 @@ module Lemon
         methods  = mod.__send__("#{access}methods", false)
         #methods -= Object.__send__("#{access}methods", true)
         methods.each do |method|
-          @units << Unit.new(mod, method, :access=>access, :function=>true)
+          @units << Unit.new(mod, method, :access=>access, :singleton=>true)
         end
       end
       return @units
@@ -105,19 +105,19 @@ module Lemon
       attr :method
 
       # Is the method a "class method", rather than an instance method.
-      attr :function
+      attr :singleton
 
       def initialize(target, method, props={})
-        @target   = target
-        @method   = method.to_sym
-        @function = props[:function] ? true : false
-        @covered  = props[:covered]
+        @target    = target
+        @method    = method.to_sym
+        @singleton = props[:singleton] ? true : false
+        @covered   = props[:covered]
 
-        if @function
+        if @singleton
           @private   = @target.private_methods.find{ |m| m.to_sym == @method }
           @protected = @target.protected_methods.find{ |m| m.to_sym == @method }
         else
-          @private = @target.private_instance_methods.find{ |m| m.to_sym == @method }
+          @private   = @target.private_instance_methods.find{ |m| m.to_sym == @method }
           @protected = @target.protected_instance_methods.find{ |m| m.to_sym == @method }
         end
       end
@@ -131,8 +131,8 @@ module Lemon
       end
 
       #
-      def function?
-        @function
+      def singleton?
+        @singleton
       end
 
       # Method access is public?
@@ -164,12 +164,12 @@ module Lemon
 
       #
       def hash
-        @target.hash ^ @method.hash ^ @function.hash
+        @target.hash ^ @method.hash ^ @singleton.hash
       end
 
       #
       def to_s
-        if @function
+        if @singleton
           "#{@target}.#{@method}"
         else
           "#{@target}##{@method}"
@@ -181,19 +181,19 @@ module Lemon
         return false unless Unit === other
         return false unless target == other.target
         return false unless method == other.method
-        return false unless function == other.function
+        return false unless singleton == other.singleton
         return true
       end
 
       def inspect
-        "#{target}#{function ? '.' : '#'}#{method}"
+        "#{target}#{singleton ? '.' : '#'}#{method}"
       end
 
       def <=>(other)
         c = (target.name <=> other.target.name)
         return c unless c == 0
-        return -1 if function  && !other.function
-        return  1 if !function && other.function
+        return -1 if singleton  && !other.singleton
+        return  1 if !singleton && other.singleton
         method.to_s <=> other.method.to_s
       end
     end

data/lib/lemon/coverage/source_parser.rb

@@ -1,6 +1,7 @@
-module Lemon
+require 'ripper'
+require 'lemon/coverage/snapshot'
 
-  require 'ruby_parser'
+module Lemon
 
   #
   class SourceParser
@@ -8,24 +9,38 @@ module Lemon
     #
     # text - A String of Ruby code.
     #
-    # Returns a Hash with each key a namespace and each value another
-    #   Hash or a TomDoc::Scope.
+    # Returns a Hash with each key a namespace and each value another Hash or Scope.
     def self.parse(text)
       new.parse(text)
     end
 
-    attr_accessor :parser, :scopes, :options
+    # Converts Ruby code into a data structure.
+    #
+    # text - A String of Ruby code.
+    #
+    # Returns an Array of Snapshot::Unit objects.
+    def self.parse_units(text)
+      sp = new
+      sp.parse(text)
+      sp.units
+    end
+
+    attr_accessor :parser
+
+    attr_accessor :scopes
+
+    attr_accessor :options
 
     # Each instance of SourceParser accumulates scopes with each
     # parse, making it easy to parse an entire project in chunks but
     # more difficult to parse disparate files in one go. Create
     # separate instances for separate global scopes.
     #
-    # Returns an instance of TomDoc::SourceParser
+    # Returns an instance of SourceParser.
     def initialize(options = {})
       @options = {}
-      @parser  = RubyParser.new
       @scopes  = {}
+      #@parser  = RubyParser.new
     end
 
     # Resets the state of the parser to a pristine one. Maintains options.
@@ -43,14 +58,13 @@ module Lemon
     # text - A String of Ruby code.
     #
     # Examples
-    #   @parser = TomDoc::SourceParser.new
+    #   @parser = SourceParser.new
     #   files.each do |file|
     #     @parser.parse(File.read(file))
     #   end
     #   pp @parser.scopes
     #
-    # Returns a Hash with each key a namespace and each value another
-    #   Hash or a TomDoc::Scope.
+    # Returns a Hash with each key a namespace and each value another Hash or Scope.
     def parse(text)
       process(tokenize(sexp(text)))
       @scopes
@@ -62,7 +76,8 @@ module Lemon
     #
     # Returns a Sexp representing the AST.
     def sexp(text)
-      @parser.parse(text)
+      Ripper.sexp(text)
+      #@parser.parse(text)
     end
 
     # Converts a tokenized Array of classes, modules, and methods into
@@ -73,13 +88,14 @@ module Lemon
     # scope - An optional Scope object for nested classes or modules.
     #
     # Returns nothing.
-    def process(ast, scope = nil)
+    def process(ast, scope=nil)
       case Array(ast)[0]
       when :module, :class
         name = ast[1]
         new_scope = Scope.new(name, ast[2])
 
         if scope
+          new_scope.parent = scope
           scope.scopes[name] = new_scope
         elsif @scopes[name]
           new_scope = @scopes[name]
@@ -119,22 +135,22 @@ module Lemon
     def tokenize(node)
       case Array(node)[0]
       when :module
-        name = node[1]
-        [ :module, name, node.comments, tokenize(node[2]) ]
+        name = node[1][1][1]
+        [ :module, name, '', tokenize(node[2]) ]
       when :class
-        name = node[1]
-        [ :class, name, node.comments, tokenize(node[3]) ]
-      when :defn
-        name = node[1]
+        name = node[1][1][1]
+        [ :class, name, '', tokenize(node[3]) ]
+      when :def
+        name = node[1][1]
         args = args_for_node(node[2])
-        [ :imethod, name, node.comments, args ]
+        [ :imethod, name, '', args ]
       when :defs
-        name = node[2]
-        args = args_for_node(node[3])
-        [ :cmethod, name, node.comments, args ]
+        name = node[3][1]
+        args = args_for_node(node[4])
+        [ :cmethod, name, '', args ]
       when :block
         tokenize(node[1..-1])
-      when :scope
+      when :program, :bodystmt, :scope
         tokenize(node[1])
       when Array
         node.map { |n| tokenize(n) }.compact
@@ -143,27 +159,34 @@ module Lemon
 
     # Given a method sexp, returns an array of the args.
     def args_for_node(node)
-      Array(node)[1..-1].select { |arg| arg.is_a? Symbol }
+      Array(node)[1..-1].select{ |arg| arg.is_a? Symbol }
     end
 
-    # A Scope is a Module or Class.
-    # It may contain other scopes.
+    #
+    def units
+      list = []
+      @scopes.each do |name, scope|
+        list.concat(scope.to_units)
+      end
+      list
+    end
+
+    # A Scope is a Module or Class, and may contain other scopes.
     class Scope
       include Enumerable
 
       attr_accessor :name, :comment, :instance_methods, :class_methods
+
+      attr_accessor :parent
+
       attr_accessor :scopes
 
-      def initialize(name, comment = '', instance_methods = [], class_methods = [])
-        @name = name
-        @comment = comment
+      def initialize(name, comment='', instance_methods=[], class_methods=[])
+        @name             = name
+        @comment          = comment
         @instance_methods = instance_methods
-        @class_methods = class_methods
-        @scopes = {}
-      end
-
-      def tomdoc
-        @tomdoc ||= TomDoc.new(@comment)
+        @class_methods    = class_methods
+        @scopes           = {}
       end
 
       def [](scope)
@@ -183,16 +206,59 @@ module Lemon
       end
 
       def inspect
-        scopes = @scopes.keys.join(', ')
+        scopes   = @scopes.keys.join(', ')
         imethods = @instance_methods.inspect
         cmethods = @class_methods.inspect
 
         "<#{name} scopes:[#{scopes}] :#{cmethods}: ##{imethods}#>"
       end
 
+      #
+      def target
+        if parent
+          parent.target.const_get(name)
+        else
+          Object.const_get(name)
+        end
+      end
+
+      #
+      def to_units
+        units = []
+        @instance_methods.each do |imethod|
+          units << Snapshot::Unit.new(target, imethod, :singleton=>false)
+        end
+        @class_methods.each do |imethod|
+          units << Snapshot::Unit.new(target, imethod, :singleton=>true)
+        end
+        @scopes.each do |name, scope|
+          units.concat(scope.to_units)
+        end
+        units
+      end
+
+    end
+
+    # A Method can be instance or class level.
+    class Method
+      attr_accessor :name, :comment, :args
+
+      def initialize(name, comment='', args=[])
+        @name    = name
+        @comment = comment
+        @args    = args || []
+      end
+      alias_method :to_s, :name
+
+      def to_sym
+        name.to_sym
+      end
+
+      def inspect
+        "#{name}(#{args.join(', ')})"
+      end
     end
 
   end
 
 end
-