lemon 0.8.5 → 0.9.0

data/work/deprecated/model/test_base_dsl.rb

@@ -0,0 +1,88 @@
+module Lemon
+
+  # Base class for TestCase DSLs.
+  class BaseDSL < Module
+
+    #
+    def initialize(context, &code)
+      @context = context
+      @subject = context.subject
+
+      module_eval(&code)
+    end
+
+    #
+    def context(description, &block)
+      @context.tests << TestCase.new(@context, description, &block)
+    end
+
+    #
+    def test(description, &procedure)
+      test = TestProc.new(
+        @context, 
+        :description => description,
+        :subject     => subject,
+        &procedure
+      )
+      @context.tests << test
+      test
+    end
+
+    # Omit a test or test case from being run.
+    #
+    #  omit test "something or other" do
+    #    # ...
+    #  end
+    #
+    def omit(test_or_case)
+      test_or_case.omit = true
+    end
+    alias_method :Omit, :omit
+
+
+
+
+    # Load a helper script applicable to this test case. Unlike requiring
+    # a helper script, the #helper method will eval the file's contents
+    # directly into the test context (using instance_eval).
+    #
+    # @param [String] file
+    #   File to eval into test context.
+    #
+    # FIXME: This is at odds with loading helpers automatically. How
+    # to handle?
+    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
+
+
+# Before All and After All advice are bad form.
+#
+#    # Define a "before all" procedure.
+#    def prepare(&procedure)
+#      before(&procedure)
+#    end
+#
+#    alias_method :Prepare, :prepare
+#
+#    # Define an "after all" procedure.
+#    def cleanup(&procedure)
+#      after(&procedure)
+#    end
+#
+#    alias_method :Cleanup, :cleanup
+#
+
+  end
+
+end

data/work/deprecated/model/test_clause.rb

@@ -0,0 +1,112 @@
+module Lemon
+
+  #
+  class TestClause
+
+    # New unit test procedure.
+    #
+    def initialize(scenario, description, options={}) #, &procedure)
+      @context     = scenario
+      @description = description
+
+      @type        = options[:type]
+
+      #@subject   = options[:subject]
+      #@aspect    = options[:aspect]
+      #@omit      = options[:omit]
+
+      #@procedure = procedure
+
+      @tested    = false
+    end
+
+    attr :type
+
+  public
+
+    # The case to which this test belongs.
+    attr :context
+
+    # Setup and teardown procedures.
+    #attr :subject
+
+    # 
+    #def target
+    #  context.
+    #end
+
+    # Description of test.
+    attr :description
+
+    # Test procedure, in which test assertions should be made.
+    #attr :procedure
+
+    # The before and after advice from the context.
+    #def advice
+    #  context.advice
+    #end
+
+    #
+    #def name ; @target ; end
+
+    # Is this unit test for a class or module level method?
+    #def function?
+    #  context.function?
+    #end
+
+    #
+    attr_accessor :omit
+
+    #
+    def omit?
+      @omit
+    end
+
+    #
+    #attr_accessor :tested
+
+    #
+    #def to_s
+    #  if function?
+    #    "#{test_case}.#{target}"
+    #  else
+    #    "#{test_case}##{target}"
+    #  end
+    #end
+
+    #
+    def to_s
+      "#{type.to_s.capitalize} #{description}"
+    end
+
+    #
+    def subject
+    end
+
+    #
+    def scope
+      context.scope
+    end
+
+    #
+    def to_proc
+      lambda{ call }
+    end
+
+    #
+    #def match?(match)    
+    #  match == target || match === aspect
+    #end
+
+    #
+    def call
+      context.run(self) do
+        #subject.run_setup(scope)    if subject
+        scope.instance_exec(*arguments, &procedure)
+        #subject.run_teardown(scope) if subject
+      end
+    end
+
+  end
+
+end

data/{lib/lemon → work/deprecated}/model/test_context.rb

@@ -1,19 +1,19 @@
+=begin
 module Lemon
 
-  # Test Instances are used to organize unit tests into groups, so as to address
-  # specific scenarios for a given class.
+  #
   class TestContext
 
     # The test case to which this concern belongs.
-    attr :testcase
+    attr :test_case
 
     # The description of this concern. Make this
     # as detailed as you wish.
     attr :description
 
     # New case instance.
-    def initialize(testcase, description, options={}, &block)
-      @testcase    = testcase
+    def initialize(test_case, description, options={}, &block)
+      @test_case   = test_case
       @description = description.to_s
       @function    = options[:function] || options[:singleton]
       @type        = options[:type] || :context
@@ -37,9 +37,8 @@ module Lemon
     # Create instance.
     def setup(scope)
       if @block
-        ins = scope.instance_eval(&@block)
+        scope.instance_eval(&@block)
       end
-      ins
     end
 
     def function? ; false ; end
@@ -51,21 +50,24 @@ module Lemon
     end
   end
 
-  ##
-  #class TestInstance < TestContext
-  #
-  #  # Create instance.
-  #  def setup(scope)
-  #    if @block
-  #      ins = scope.instance_eval(&@block)
-  #      raise "target type mismatch" unless testcase.target === ins
-  #    end
-  #    ins
-  #  end
-  #
-  #end
+end
+=end
 
 =begin
+  #
+  class TestInstance < TestContext
+  
+    # Create instance.
+    def setup(scope)
+      if @block
+        ins = scope.instance_eval(&@block)
+        raise "target type mismatch" unless test_case.target === ins
+      end
+      ins
+    end
+  
+  end
+
   #
   class TestSingleton < TestContext
 
@@ -73,9 +75,9 @@ module Lemon
     def setup(scope)
       if @block
         ins = scope.instance_eval(&@block)
-        raise "target type mismatch" unless testcase.target == ins
+        raise "target type mismatch" unless test_case.target == ins
       else
-        ins = @testcase.target
+        ins = @test_case.target
       end
       ins
     end
@@ -86,5 +88,3 @@ module Lemon
   end
 =end
 
-end
-

data/work/deprecated/model/test_feature.rb

@@ -0,0 +1,128 @@
+require 'lemon/model/pending'
+require 'lemon/model/test_context'
+require 'lemon/model/test_advice'
+require 'lemon/model/test_scenario'
+
+module Lemon
+
+  # The TestFeature ...
+  #
+  # * `tests` are _scenarios_,
+  # * `advice` are _given_, _when_ and _then_ rules.
+  #
+  class TestFeature < TestCase
+
+    #
+    def initialize(context, settings={}, &block)
+      @story = []
+      super(context, settings, &block)
+    end
+
+    ## This has to be redefined in each subclass to pick
+    ## up there respective DSL classes.
+    #def evaluate(&block)
+    #  @dsl = DSL.new(self, &block)
+    #end
+  
+    attr :story
+
+    # Feature scenarios are tests.
+    alias_method :scenarios, :tests
+
+    #
+    def to_s
+      "Feature #{target}"
+    end
+
+    #
+    def to_s #description
+      (["Feature: #{target}"] + story).join("\n  ")
+    end
+
+    # Run test in the context of this case.
+    #
+    # @param [TestProc] test
+    #   The test procedure instance to run.
+    #
+    def run(&block)
+    end
+
+    #
+    class DSL < Module
+
+      #
+      def initialize(feature, &code)
+        @feature = feature
+
+        module_eval(&code)
+      end
+
+      #
+      def To(description)
+        @feature.story << "To " + description
+      end
+
+      #
+      def As(description)
+        @feature.story << "As " + description
+      end
+
+      #
+      def We(description)
+        @feature.story << "We " + description
+      end
+
+      #
+      def Scenario(description, &procedure)
+        scenario = TestScenario.new(@feature, description, &procedure)
+        @feature.scenarios << scenario
+        scenario
+      end
+      alias_method :scenario, :Scenario
+
+      # Omit a scenario from test runs.
+      #
+      #  omit unit :foo do
+      #    # ...
+      #  end
+      #
+      def Omit(scenario)
+        scenario.omit = true
+      end
+      alias_method :omit, :Omit
+
+      # Given ...
+      #
+      # @param [String] description
+      #   A brief description of the _given_ criteria.
+      #
+      def Given(description, &procedure)
+        @feature.advice[:given][description] = procedure
+      end
+      alias_method :given, :Given
+
+      # When ...
+      #
+      # @param [String] description
+      #   A brief description of the _when_ criteria.
+      #
+      def When(description, &procedure)
+        @feature.advice[:when][description] = procedure
+      end
+      alias_method :wence, :When
+
+      # Then ...
+      #
+      # @param [String] description
+      #   A brief description of the _then_ criteria.
+      #
+      def Then(description, &procedure)
+        @feature.advice[:then][description] = procedure
+      end
+      alias_method :hence, :Then
+
+    end
+
+  end
+
+end

data/work/deprecated/model/test_scenario.rb

@@ -0,0 +1,137 @@
+require 'lemon/model/test_clause'
+
+module Lemon
+
+  #
+  class TestScenario < TestCase
+
+    #
+    def initialize(feature, summary, options={}, &block)
+      @feature = feature
+      @summary = summary
+
+      @tests   = []
+
+      evaluate(&block)
+    end
+  
+    #
+    def evaluate(&procedure)
+      @dsl = DSL.new(self, &procedure)
+    end
+
+    #
+    attr :feature
+
+    #
+    attr :dsl
+
+    attr_accessor :omit
+
+    #
+    def omit?
+      @omit
+    end
+
+    #
+    def to_s
+      "Scenario: #{@summary}"
+    end
+
+    def subject
+
+    end
+
+    #
+    def run(clause)
+      type = clause.type
+      desc = clause.description
+      feature.advice[type].each do |mask, proc|
+        if md = match_regexp(mask).match(desc)
+          scope.instance_exec(*md[1..-1], &proc)
+        end
+      end
+    end
+
+    #
+    #--
+    # TODO: Change so that the scope is the DSL
+    #       and includes the DSL of the context?
+    #++
+    def scope
+      @scope ||= (
+        #if feature
+        #  scope = feature.scope || Object.new
+        #  scope.extend(dsl)
+        #else
+          scope = Object.new
+          scope.extend(dsl)
+        #end
+      )
+    end
+
+    #
+    #def find
+    #  features.clauses[@type].find{ |c| c =~ @description }
+    #end
+
+    # Convert matching string into a regular expression. If the string
+    # contains double parenthesis, such as ((.*?)), then the text within
+    # them is treated as in regular expression and kept verbatium.
+    #
+    # TODO: Better way to isolate regexp. Maybe ?:(.*?) or /(.*?)/.
+    #
+    def match_regexp(str)
+      str = str.split(/(\(\(.*?\)\))(?!\))/).map{ |x|
+        x =~ /\A\(\((.*)\)\)\Z/ ? $1 : Regexp.escape(x)
+      }.join
+      str = str.gsub(/\\\s+/, '\s+')
+      Regexp.new(str, Regexp::IGNORECASE)
+    end
+
+
+    # TODO: Need to ensure the correct order of Given, When, Then.
+    class DSL < Module
+
+      #
+      def initialize(scenario, &code)
+        @scenario = scenario
+
+        module_eval(&code)
+      end
+
+      # Given ...
+      #
+      # @param [String] description
+      #   A brief description of what the setup procedure sets-up.
+      #
+      def Given(description)
+        @scenario.tests << TestClause.new(@scenario, description, :type=>:given)
+      end
+      alias_method :given, :Given
+
+      # When ...
+      #
+      # @param [String] description
+      #   A brief description of what the setup procedure sets-up.
+      #
+      def When(description)
+        @scenario.tests << TestClause.new(@scenario, description, :type=>:when)
+      end
+      alias_method :wence, :When
+
+      # Then ...
+      #
+      # @param [String] description
+      #   A brief description of what the setup procedure sets-up.
+      #
+      def Then(description)
+        @scenario.tests << TestClause.new(@scenario, description, :type=>:then)
+      end
+      alias_method :hence, :Then
+
+    end
+
+  end
+
+end