lemon 0.8.1 → 0.8.2

data/lib/lemon/model/pending.rb

@@ -0,0 +1,10 @@
+require 'lemon/model/ae'
+
+class Pending < Assertion
+  def self.to_proc; lambda{ raise self }; end
+end
+
+class Untested < Pending
+  def self.to_proc; lambda{ raise self }; end
+end
+

data/lib/lemon/model/snapshot.rb

@@ -0,0 +1,203 @@
+module Lemon
+
+  # Snapshot is used to record the "unit picture" of the system
+  # at a given moment.
+  class Snapshot
+
+    include Enumerable
+
+    #
+    def self.capture(namespaces=nil)
+      o = new
+      o.capture(namespaces)
+      o
+    end
+
+    #
+    attr :units
+
+    #
+    def initialize(units=[])
+      @units = units
+    end
+
+    #
+    def each(&block)
+      units.each(&block)
+    end
+
+    #
+    def size
+      @units.size
+    end
+
+    #
+    def reset
+      each{ |u| u.covered = false }
+    end
+
+    # Select units by namespace (i.e. module or class).
+    #def [](mod)
+    #  @units.select{ |u| u.namespace == mod }
+    #end
+
+    #
+    def capture(namespaces=nil)
+      @units = []
+      ObjectSpace.each_object(Module) do |mod|
+        next if mod.name.empty?
+        #next if namespaces and !namespaces.any?{ |ns| /^#{ns}(::|$)/ =~ mod.to_s }
+        next if namespaces and !namespaces.any?{ |ns| ns.to_s == mod.to_s }
+        capture_namespace(mod)
+      end
+    end
+
+    #
+    def capture_namespace(mod)
+      ['', 'protected_', 'private_'].each do |access|
+        methods  = mod.__send__("#{access}instance_methods", false)
+        #methods -= Object.__send__("#{access}instance_methods", true)
+        methods.each do |method|
+          @units << Unit.new(mod, method, :access=>access)
+        end
+
+        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)
+        end
+      end
+      return @units
+    end
+
+    #
+    def to_a
+      @units
+    end
+
+    #
+    def public_units
+      @units.select{ |u| u.public? }
+    end
+
+    #
+    def -(other)
+      Snapshot.new(units - other.units)
+    end
+
+    #
+    def +(other)
+      Snapshot.new(units + other.units)
+    end
+
+    #
+    def <<(other)
+      @units.concat(other.units)
+    end
+
+    # Snapshot Unit encapsulates a method and it's various characteristics.
+    class Unit
+
+      # Clsss or module.
+      attr :target
+
+      # Method name.
+      attr :method
+
+      # Is the method a "class method", rather than an instance method.
+      attr :function
+
+      def initialize(target, method, props={})
+        @target   = target
+        @method   = method.to_sym
+        @function = props[:function] ? true : false
+        @covered  = props[:covered]
+
+        if @function
+          @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 }
+          @protected = @target.protected_instance_methods.find{ |m| m.to_sym == @method }
+        end
+      end
+
+      # Can be used to flag a unit as covered.
+      attr_accessor :covered
+
+      # Alternate name for target.
+      def namespace
+        @target
+      end
+
+      #
+      def function?
+        @function
+      end
+
+      # Method access is public?
+      def public?
+        !(@private or @protected)
+      end
+
+      # Method access is public?
+      def private?
+        @private
+      end
+
+      #
+      def protected?
+        @protected
+      end
+
+      #
+      def access
+        return :private if private?
+        return :protected if protected?
+        :public
+      end
+
+      # Marked as covered?
+      def covered?
+        @covered
+      end
+
+      #
+      def hash
+        @target.hash ^ @method.hash ^ @function.hash
+      end
+
+      #
+      def to_s
+        if @function
+          "#{@target}.#{@method}"
+        else
+          "#{@target}##{@method}"
+        end
+      end
+      alias to_str to_s
+
+      def eql?(other)
+        return false unless Unit === other
+        return false unless target == other.target
+        return false unless method == other.method
+        return false unless function == other.function
+        return true
+      end
+
+      def inspect
+        "#{target}#{function ? '.' : '#'}#{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
+        method.to_s <=> other.method.to_s
+      end
+    end
+
+  end
+
+end

data/lib/lemon/model/source_parser.rb

@@ -0,0 +1,198 @@
+module Lemon
+
+  require 'ruby_parser'
+
+  #
+  class SourceParser
+    # Converts Ruby code into a data structure.
+    #
+    # text - A String of Ruby code.
+    #
+    # Returns a Hash with each key a namespace and each value another
+    #   Hash or a TomDoc::Scope.
+    def self.parse(text)
+      new.parse(text)
+    end
+
+    attr_accessor :parser, :scopes, :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
+    def initialize(options = {})
+      @options = {}
+      @parser  = RubyParser.new
+      @scopes  = {}
+    end
+
+    # Resets the state of the parser to a pristine one. Maintains options.
+    #
+    # Returns nothing.
+    def reset
+      initialize(@options)
+    end
+
+    # Converts Ruby code into a data structure. Note that at the
+    # instance level scopes accumulate, which makes it easy to parse
+    # multiple files in a single project but harder to parse files
+    # that have no connection.
+    #
+    # text - A String of Ruby code.
+    #
+    # Examples
+    #   @parser = TomDoc::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.
+    def parse(text)
+      process(tokenize(sexp(text)))
+      @scopes
+    end
+
+    # Converts Ruby sourcecode into an AST.
+    #
+    # text - A String of Ruby source.
+    #
+    # Returns a Sexp representing the AST.
+    def sexp(text)
+      @parser.parse(text)
+    end
+
+    # Converts a tokenized Array of classes, modules, and methods into
+    # Scopes and Methods, adding them to the @scopes instance variable
+    # as it works.
+    #
+    # ast   - Tokenized Array produced by calling `tokenize`.
+    # scope - An optional Scope object for nested classes or modules.
+    #
+    # Returns nothing.
+    def process(ast, scope = nil)
+      case Array(ast)[0]
+      when :module, :class
+        name = ast[1]
+        new_scope = Scope.new(name, ast[2])
+
+        if scope
+          scope.scopes[name] = new_scope
+        elsif @scopes[name]
+          new_scope = @scopes[name]
+        else
+          @scopes[name] = new_scope
+        end
+
+        process(ast[3], new_scope)
+      when :imethod
+        ast.shift
+        scope.instance_methods << Method.new(*ast)
+      when :cmethod
+        ast.shift
+        scope.class_methods << Method.new(*ast)
+      when Array
+        ast.map { |a| process(a, scope) }
+      end
+    end
+
+    # Converts a Ruby AST-style Sexp into an Array of more useful tokens.
+    #
+    # node - A Ruby AST Sexp or Array
+    #
+    # Examples
+    #
+    #   [:module, :Math, "",
+    #     [:class, :Multiplexer, "# Class Comment",
+    #       [:cmethod,
+    #         :multiplex, "# Class Method Comment", [:text]],
+    #       [:imethod,
+    #         :multiplex, "# Instance Method Comment", [:text, :count]]]]
+    #
+    #   # In others words:
+    #   # [ :type, :name, :comment, other ]
+    #
+    # Returns an Array in the above format.
+    def tokenize(node)
+      case Array(node)[0]
+      when :module
+        name = node[1]
+        [ :module, name, node.comments, tokenize(node[2]) ]
+      when :class
+        name = node[1]
+        [ :class, name, node.comments, tokenize(node[3]) ]
+      when :defn
+        name = node[1]
+        args = args_for_node(node[2])
+        [ :imethod, name, node.comments, args ]
+      when :defs
+        name = node[2]
+        args = args_for_node(node[3])
+        [ :cmethod, name, node.comments, args ]
+      when :block
+        tokenize(node[1..-1])
+      when :scope
+        tokenize(node[1])
+      when Array
+        node.map { |n| tokenize(n) }.compact
+      end
+    end
+
+    # 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 }
+    end
+
+    # A Scope is a Module or Class.
+    # It may contain other scopes.
+    class Scope
+      include Enumerable
+
+      attr_accessor :name, :comment, :instance_methods, :class_methods
+      attr_accessor :scopes
+
+      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)
+      end
+
+      def [](scope)
+        @scopes[scope]
+      end
+
+      def keys
+        @scopes.keys
+      end
+
+      def each(&block)
+        @scopes.each(&block)
+      end
+
+      def to_s
+        inspect
+      end
+
+      def inspect
+        scopes = @scopes.keys.join(', ')
+        imethods = @instance_methods.inspect
+        cmethods = @class_methods.inspect
+
+        "<#{name} scopes:[#{scopes}] :#{cmethods}: ##{imethods}#>"
+      end
+
+    end
+
+  end
+
+end
+

data/lib/lemon/model/test_case.rb

@@ -0,0 +1,221 @@
+require 'lemon/model/pending'
+require 'lemon/model/test_context'
+require 'lemon/model/test_unit'
+
+module Lemon
+
+  # Test Case encapsulates a collection of 
+  # unit tests organized into groups of contexts.
+  class TestCase
+
+    # The test suite to which this testcase belongs.
+    attr :suite
+
+    # A testcase +target+ is a class or module.
+    attr :target
+
+    # Description of the aspect of the test class/module
+    # to be testd.
+    attr :aspect
+
+    # Ordered list of testunits.
+    attr :units
+
+    # Before any test case units are run.
+    attr :before
+    #attr_accessor :prepare
+
+    # After all test case units are run.
+    attr :after
+    #attr_accessor :cleanup
+
+    # Module for parsing test case scripts.
+    attr :dsl
+
+    # A test case +target+ is a class or module.
+    def initialize(suite, target, aspect=nil, &block)
+      @suite  = suite
+      @target = target
+      @aspect = aspect
+
+      #@steps  = []
+      @units  = []
+
+      #@prepare = nil
+      #@cleanup = nil
+
+      @before = {}
+      @after  = {}
+
+      @dsl = DSL.new(self, &block)
+    end
+
+    # DEPRECATE
+    alias_method :testunits, :units
+
+    # Iterate over each test unit.
+    def each(&block)
+      units.each(&block)
+    end
+
+    #
+    def size
+      testunits.size
+    end
+
+    #
+    def to_s
+      target.to_s.sub(/^\#\<.*?\>::/, '')
+    end
+
+    #
+    def prepare
+      @before[[]]
+    end
+
+    #
+    def cleanup
+      @after[[]]
+    end
+
+    #
+    class DSL < Module
+      #
+      def initialize(testcase, &casecode)
+        @testcase = testcase
+        @context  = nil #Instance.new(self)
+        module_eval(&casecode)
+      end
+
+      # Define a unit test for this case.
+      def unit(*target, &block)
+        target = target.map{ |x| Hash === x ? x.to_a : x }.flatten
+        method, aspect = *target
+        unit = TestUnit.new(
+          @testcase, method,
+          :function => false,
+          :aspect   => aspect,
+          :context => @context,
+          &block
+        )
+        #@testcase.steps << unit
+        @testcase.units << unit
+        unit
+      end
+      alias_method :TestUnit, :unit
+      alias_method :testunit, :unit
+      alias_method :Unit, :unit
+
+      # Define a meta-method unit test for this case.
+      def meta(*target, &block)
+        target = target.map{ |x| Hash === x ? x.to_a : x }.flatten
+        method, aspect = *target
+        unit = TestUnit.new(
+          @testcase, method,
+          :function => true,
+          :aspect   => aspect,
+          :context => @context,
+          &block
+        )
+        #@testcase.steps << unit
+        @testcase.units << unit
+        unit
+      end
+      alias_method :MetaUnit, :meta
+      alias_method :metaunit, :meta
+      alias_method :Meta, :meta
+
+      # Omit a unit from testing.
+      #
+      #  omit unit :foo do
+      #    # ...
+      #  end
+      #
+      def Omit(unit)
+        unit.omit = true
+      end
+      alias_method :omit, :Omit
+
+      #
+      def setup(description=nil, &block)
+        if block
+          context  = TestContext.new(@testcase, description, &block)
+          @context = context
+          #@function = false
+          #@testcase.steps << context
+        end
+      end
+      alias_method :Setup, :setup
+      alias_method :Concern, :setup
+      alias_method :concern, :setup
+      alias_method :Context, :setup
+      alias_method :context, :setup
+
+      ## Define a new test instance for this case.
+      #def instance(description=nil, &block)
+      #  context  = TestInstance.new(@testcase, description, &block)
+      #  @context = context
+      #  @function = false
+      #  #@testcase.steps << context
+      #end
+      #alias_method :Instance, :instance
+
+      # Define a new test singleton for this case.
+      #def Singleton(description=nil, &block)
+      #  context  = TestSingleton.new(@testcase, description, &block)
+      #  @context = context
+      #  @function = true
+      #  #@testcase.steps << context
+      #end
+      #alias_method :singleton, :Singleton
+
+      def teardown(&block)
+        @context.teardown = block
+      end
+      alias_method :Teardown, :teardown
+
+      # TODO: Make Before and After more generic to handle before and after
+      # units, contexts/concerns, etc.
+      
+      # Define a before procedure for this case.
+      def before(*matches, &block)
+        @testcase.before[matches] = block
+      end
+      alias_method :Before, :before
+
+      # Define an after procedure for this case.
+      def after(*matches, &block)
+        @testcase.after[matches] = block
+      end
+      alias_method :After, :after
+
+      #
+      #def prepare(&block)
+      #  @testcase.prepare = block
+      #end
+      #alias_method :Prepare, :prepare
+
+      #
+      #def cleanup(&block)
+      #  @testcase.cleanup = block
+      #end
+      #alias_method :Cleanup, :cleanup
+
+      # Load a helper script applicable to this test case.
+      def helper(file)
+        instance_eval(File.read(file), file)
+      end
+      alias_method :Helper, :helper
+
+      #def include(*mods)
+      #  extend *mods
+      #end
+
+      #def pending(message=nil)
+      #  raise Pending.new(message)
+      #end
+    end
+
+  end
+
+end