rcor 0.8.1 → 0.9.5

data/Rakefile.rb

@@ -17,7 +17,7 @@ end
 task :default => [:clean, :test] 
 
 PKG_FILES = FileList['**/*'].exclude(/_test_output\.html$/)
-PKG_VERSION = '0.8.1'                     
+PKG_VERSION = '0.9.5'
 
 spec = Gem::Specification.new do |s|
   s.platform = Gem::Platform::RUBY

data/lib/concordion.rb

@@ -1,5 +1,4 @@
 require 'concordion_utility'
-require 'concordion_invocation_string_builder'
 require 'concordion_lookahead_handler'
 require 'concordion_verifier'
 require 'concordion_invoker'
@@ -12,11 +11,10 @@ class Concordion
   def self.TEXT_VAR
     @@TEXT_VAR
   end
-  attr_reader :verification_variable, :verifier, :invocation_builder
+  attr_reader :verification_variable, :verifier
 
   def initialize
     @memory = {}
-    @invocation_builder = ConcordionInvocationStringBuilder.new(self)
     @lookahead_handler = ConcordionLookaheadHandler.new
     @verifier = ConcordionVerifier.new(self)
     @invoker = ConcordionInvoker.new(self)
@@ -31,9 +29,6 @@ class Concordion
     @memory[variable]
   end
   
-  def build_invocation_string(conc_call, content)
-    @invocation_builder.build_invocation_string(conc_call,content)
-  end
 
   def dereference(conc_call)
     var_name = concordion_variable_name(conc_call)
@@ -61,6 +56,4 @@ class Concordion
     conc_rv
   end
 
-
-
 end

data/lib/concordion_constants.rb

@@ -1,7 +1,7 @@
 module ConcordionConstants
 
   def concordion_command_attributes
-    ["assertequals", "set", "execute", "verifyrows", "asserttrue"].collect do
+    ["assertequals", "set", "execute", "verifyrows", "asserttrue", "assert_image"].collect do
         |cmd| "concordion:#{cmd}"
     end
   end

data/lib/concordion_css.rb

@@ -68,7 +68,7 @@ p.success {
   padding: 2px;
 }
 .concordion_success, .concordion_success * {
-  background-color: #afa !important;
+  background-color: #afa;
 }
 .success pre {
   background-color: #bbffbb;
@@ -82,6 +82,13 @@ p.success {
   color: #bb5050;
 }
 
+td.concordion_failure {
+  background-color: #ffb0b0 !important;
+}
+td.concordion_success {
+  background-color: #afa !important;
+}
+
 ins {
   text-decoration: none;
 }

data/lib/concordion_css_decorator.rb

@@ -1,4 +1,5 @@
 require 'concordion_css'
+require 'concordion_error_condition'
 
 class ConcordionCSSDecorator
   def add_concordion_css_link(root, html, type)
@@ -39,14 +40,30 @@ class ConcordionCSSDecorator
     end
   end
   
-  def decorate_tag(rv, tag) 
+  def decorate_tag(rv, tag, cpr) 
+    context = tag.to_html
+    expected = tag.inner_html
+    xpath = tag.xpath
+    
     if rv[:result]
       tag[:class] = 'concordion_success'
-      return 0
+      return nil
     end
 
     tag[:class] = 'concordion_failure'
-    tag.inner_html += " expected but received #{rv[:actual]}"
-    1
+    if cpr.is_verify_command?
+      if rv[:actual] > rv[:expected]
+        diff = rv[:actual] - rv[:expected]
+        tag.inner_html += "<tr><td>[#{diff} Surplus Row(s) Returned By Fixture]</td></tr>"
+      end
+    else
+      if cpr.is_assert_true_command?
+        tag.inner_html += ": expected true but received #{rv[:actual]}"
+      else
+        tag.inner_html += " expected but received #{rv[:actual]}"
+      end
+    end
+    #TODO refactor: move some of this logic into the conc parse result?
+    ConcordionErrorCondition.new(expected, rv[:actual], xpath, context, cpr.is_assert_true_command?)
   end
 end

data/lib/concordion_error_condition.rb

@@ -0,0 +1,26 @@
+# 
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+ 
+
+class ConcordionErrorCondition
+  attr_reader :expected, :actual
+  def initialize(expected, actual, xpath, context = nil, assert_true_command = false)
+    @expected = expected
+    @actual = actual
+    @xpath = xpath
+    @context = context
+    @assert_true_command = assert_true_command
+  end
+  
+  def to_s
+    @expected = "true" if @assert_true_command
+      
+    base = "expected (#{@expected}) but got (#{@actual}) in tag: #{@xpath}"
+    
+    
+    return base if @context.nil?
+    
+    base + "\n\tcontext of error: #{@context}"
+  end
+end

data/lib/concordion_invoker.rb

@@ -1,31 +1,125 @@
+require 'loader_helper'
+require 'concordion_utility'
+
 class ConcordionInvoker
+  include LoaderHelper
+  include ConcordionUtility
+  
   def initialize(conc)
     @concordion = conc
-    @builder = conc.invocation_builder
   end
 
+  def try_to_dereference(cpr)
+    rv = nil
+    begin
+      rv = @concordion.dereference(cpr.system_under_test)
+    rescue NoMethodError => e
+      method = method_from_no_method_error(e)
+
+      rv = dereference_error_message(e)
+    end
+    rv
+  end
+  
+  def dereference_error_message(e)
+    rv = "["
+    clazz = e.to_s.split(":")[1]
+    if clazz == 'NilClass'
+      rv += "No more rows"
+    else
+      rv += " on #{clazz} but was not found"
+    end
+    rv += "]"
+  end
+  
+  
   def invoke_sut(cpr, test_context)
     sut_rv = nil
     if cpr.needs_dereference?
-      sut_rv = @concordion.dereference(cpr.system_under_test)
+      sut_rv = try_to_dereference(cpr)
     else 
-      invocation_str = @builder.build_invocation_string(cpr.system_under_test, cpr.content)
-      sut_rv = test_context.instance_eval invocation_str
+
+      sut_rv = try_to_invoke_sut(cpr,test_context)
     end
     
     sut_rv
   end
+  
+  
+  def try_to_invoke_sut(cpr, test_context)
+    sut_rv = nil
+    begin
+        #TODO refactor, inlined/amended from former string builder
+        conc_method = concordion_method_name(cpr.system_under_test)
+        arg_values = []
+        if has_arguments?(cpr.system_under_test)
+          arg_vars = concordion_arguments(cpr.system_under_test)
+          arg_values = arg_vars.collect {|var| 
+             if var == '#TEXT'
+              escape_single_quotes(cpr.content)
+            else
+              @concordion.get_variable(var) 
+            end
+          }
+        end
+        args = arg_values.join(",")
+       sut_rv = test_context.send(conc_method, *arg_values)  
+    rescue NoMethodError => e
+      
+      if e.to_s =~ /nil:NilClass/
+        sut_rv = "[Parse failed for: #{cpr}, cause: (#{e})]"
+      else
+        method = method_from_no_method_error(e)
+        clazz = class_from_no_method_error(e)
+        sut_rv = "[Missing method '#{method}' in fixture #{clazz} ]"
+      end
+    end
+    sut_rv
+  end
+
+  def method_from_no_method_error(e)
+    except_str_from(e).split("`")[1].split("'")[0]
+  end
+  
+  def except_str_from(e)
+    e.exception.to_s
+  end
+  
+  def class_from_no_method_error(e)
+    except_str_from(e).split("<")[1].split(":")[0]
+  end
+  
   def invoke_concordion(cpr, sut_rv)
-    commands[cpr.concordion_command].call(sut_rv, cpr.content)
+    cmd = commands[cpr.concordion_command]
+    if cpr.is_assert_image_command?
+      cmd.call(sut_rv, cpr.image_location)
+    elsif cpr.is_verify_command?
+      cmd.call(sut_rv, cpr.num_results_expected)
+    else
+      cmd.call(sut_rv, cpr.content)
+    end
+    
   end
 
 
   def commands
     cmds = {}
-    cmds["assertequals"] = Proc.new { |a, b| { :result => a == b, :actual => a, :expected => b } }
-    cmds["execute"] = Proc.new { |a,b| {:result => true, :actual => a, :expected => b } }
-    cmds["verifyrows"] = Proc.new { |a,b| { :result => true, :actual => a, :expected => b } }
-    cmds["asserttrue"] = Proc.new { |a, b| { :result => a, :actual => a,  :expected => true } }
+    cmds["assertequals"] = Proc.new { |a, b| 
+      result = (a.to_s == b)
+      { :result => result, :actual => a, :expected => b } }
+    cmds["execute"] = Proc.new { |a,b| 
+      result = true
+      result = false if a.to_s =~ /Missing method/
+      {:result => result, :actual => a, :expected => b } }
+    cmds["verifyrows"] = Proc.new { |a,b| { :result => a.size == b, :actual => a.size, :expected => b } }
+    cmds["asserttrue"] = Proc.new { |a, b| 
+      result = a
+      result = false if a.instance_of?(String)
+      { :result => result, :actual => false,  :expected => true } }
+    cmds["assert_image"] = Proc.new { |actual_data, expected_image_url| 
+      expected_data = File.read(path_for(expected_image_url))
+      { :result => actual_data == expected_data, :actual => "[Image data of size #{actual_data.size} omitted]",  :expected => "[Expected to match #{expected_image_url}]" } 
+    }
     cmds
   end
 

data/lib/concordion_parse_result.rb

@@ -1,3 +1,5 @@
+require 'concordion_utility'
+
 class ConcordionParseResult
   include ConcordionUtility
   attr_accessor :concordion_command, :system_under_test, :content, :tag
@@ -8,9 +10,13 @@ class ConcordionParseResult
     @tag = tag
   end
   def to_s
-    "CPR: #{@concordion_command}, #{@system_under_test}, #{@content}"
+    "Concordion command[#{@concordion_command}], System under test method[#{@system_under_test}], Tag Content[#{@content}] Image Location[#{image_location}]"
   end
 
+  def is_assert_image_command?
+    "assert_image" == @concordion_command
+  end
+  
   def is_set_command?
     "set" == @concordion_command
   end
@@ -20,7 +26,19 @@ class ConcordionParseResult
   def is_execute_command?
     "execute" == @concordion_command
   end
+  def is_assert_true_command?
+    "asserttrue" == @concordion_command
+  end
 
+  def num_results_expected
+    @tag.search("tr").size - 1
+  end
+  
+  def image_location
+    return nil if @tag.nil?
+    @tag.get_attribute('src')
+  end
+  
   def assignment
     concordion_assignment(@system_under_test)
   end

data/lib/concordion_parser.rb

@@ -32,7 +32,7 @@ class ConcordionParser
 
   def each_eligible_concordion_element(&block)
     each_concordion_element do |elem|
-      if concordion_cmd_attr_exists?(elem)        
+      if concordion_cmd_attr_exists?(elem)       
         attr = concordion_cmd_attr_for(elem)
         @verifier.update_row(elem)
         if !@instrumenter.instrument_from_headers(elem, attr, @root)

data/lib/concordion_processor.rb

@@ -11,8 +11,9 @@ class ConcordionProcessor
   def process(tag, test_context)
     attr = concordion_cmd_attr_for(tag)
     instrumented_value = tag.get_attribute(attr)
-    rv = @concordion.evaluate(create_parse_result(tag, attr, instrumented_value), test_context, self)
-    @decorator.decorate_tag(rv, tag)
+    cpr = create_parse_result(tag, attr, instrumented_value)
+    rv = @concordion.evaluate(cpr, test_context, self)
+    @decorator.decorate_tag(rv, tag, cpr)
   end
 
   def create_parse_result(tag, attr, value)

data/lib/concordion_string_utility.rb

@@ -34,9 +34,17 @@ module ConcordionStringUtility
   include PluralToSingularUtility
   
   def has_arguments?(name)
-    name !~ /\(\)$/
+    !(ends_in_empty_parens?(name) || is_direct_method_call?(name))
   end
 
+  def is_direct_method_call?(name)
+    name =~ /^[\w]+$/
+  end
+  
+  def ends_in_empty_parens?(name)
+    name =~ /\(\)$/
+  end
+  
   def concordion_assignment(name)
     name.split("=")[0].strip
   end
@@ -45,19 +53,45 @@ module ConcordionStringUtility
     name =~ /=/
   end
 
-
+  def attr_writer_method?(name)
+    name =~ /=$/
+  end
+  
   def concordion_method_name(name)
     if name =~ /\(/
       base = name.split("(")[0].strip
     else
+      
+      
       base = name.strip
+      if base =~ /\s/
+        
+        if base =~ /=/ && base =~ /^#/
+          base = base.split("=")[1].strip
+        end
+        elements = base.split(/\s/)
+        base = elements[0]
+      end
     end
     
     if !has_assignment?(base)
       return base
     end
+ 
+    if attr_writer_method?(base)
+      return base if base.count("=") == 1
+      return assignment(base) + "="
+    end
+    
+    assignment(base)
+  end
 
+  def assignment(base)
     base.split("=")[1].strip
   end
+  
+  def escape_single_quotes(s)
+    s.gsub(/[']/, '\\\\\\\\\'')
+  end
 
 end

data/lib/concordion_test_case.rb

@@ -10,50 +10,26 @@ require 'concordion'
 require 'concordion_css_decorator'
 require 'test/unit'
 
-class ConcordionTestCase < Test::Unit::TestCase
+require 'concordion_test_methods'
 
-  @@EXPECTED_FAILURE_COUNT = 0
 
-  include ConcordionUtility
+class ConcordionTestCase < Test::Unit::TestCase
 
-  def self.inherited(subclass)
-    subclass.class_eval do
-      define_method :test_spec do
-        filename = snake_cased_test_name(subclass.to_s)
-        parse_spec(filename)
-        run_spec(filename)
-        report_spec(filename)
-      end
-    end
-    subclass
+  include ConcordionConfigMethods
+  extend ConcordionConfigMethods
+  include ConcordionInternalTestMethods
+  class << self
+    alias_method :original_inherited, :inherited
   end
 
-  def self.default_config
-    concordion = Concordion.new
-    parser = ConcordionParser.new(ConcordionReader.new, concordion)
-    decorator = ConcordionCSSDecorator.new
-    processor = ConcordionProcessor.new(concordion, decorator)
-    { :expected_failure_count => @@EXPECTED_FAILURE_COUNT,
-      :parser => parser,
-      :writer => ConcordionWriter.new(ConcordionEnvironment.output_dir),
-      :concordion => concordion,
-      :decorator => decorator,
-      :processor => processor,
-      :write_goldmaster => false,
-      :css_type => ConcordionEnvironment.css_type
-    }
+  def self.inherited(subclass)
+    original_inherited(subclass)
+    bind_test_method_to(subclass, default_config)
   end
 
-  def initialize(arg, conf = ConcordionTestCase.default_config)
+  def initialize(arg, conf = default_config())
     super(arg)
-    config = ConcordionTestCase.default_config.merge(conf)
-    @parser = config[:parser]
-    @writer = config[:writer]
-    @concordion = config[:concordion]
-    @decorator = config[:decorator]
-    @expected_failure_count = config[:expected_failure_count]
-    @processor = config[:processor]
-    @css_type = config[:css_type]
+    @config = default_config.merge(conf)
   end
 
   def test_something_trivial_to_shut_runit_up
@@ -68,30 +44,4 @@ class ConcordionTestCase < Test::Unit::TestCase
     @trivial
   end
 
-  def parse_spec(filename)
-    @parser.parse(filename)
-    assert_concordion_document
-    @decorator.add_concordion_css_link(@parser.root, @parser.html, @css_type)
-  end
-
-  def run_spec(filename)
-    @failures = 0
-    @parser.each_eligible_concordion_element do |elem|
-      @failures += @processor.process(elem, self)
-    end    
-  end   
-
-  def report_spec(filename)
-    @decorator.add_css_file_to_output_dir(@writer, @css_type)
-    outfilename = @writer.calculate_filename_and_overwrite(@parser.root, filename)
-    assert_no_failures(@failures, outfilename)
-  end
-
-  def assert_no_failures(failures, outfilename)
-    assert_equal @expected_failure_count, failures, "Wrote output to #{outfilename}"    
-  end
-
-  def assert_concordion_document
-    assert_equal "http://www.concordion.org/2007/concordion", @parser.html.get_attribute("xmlns:concordion")
-  end
 end