rcor 0.8.1

data/lib/concordion_invoker.rb

@@ -0,0 +1,33 @@
+class ConcordionInvoker
+  def initialize(conc)
+    @concordion = conc
+    @builder = conc.invocation_builder
+  end
+
+  def invoke_sut(cpr, test_context)
+    sut_rv = nil
+    if cpr.needs_dereference?
+      sut_rv = @concordion.dereference(cpr.system_under_test)
+    else 
+      invocation_str = @builder.build_invocation_string(cpr.system_under_test, cpr.content)
+      sut_rv = test_context.instance_eval invocation_str
+    end
+    
+    sut_rv
+  end
+  def invoke_concordion(cpr, sut_rv)
+    commands[cpr.concordion_command].call(sut_rv, cpr.content)
+  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
+  end
+
+
+end

data/lib/concordion_lookahead_handler.rb

@@ -0,0 +1,17 @@
+
+class ConcordionLookaheadHandler
+
+
+  def is_element_setter?(elem)
+    !elem.get_attribute('concordion:set').nil?
+  end
+
+  def handle_lookahead(cpr, test_context, processor)
+    cpr.tag.search("/*[@]").each {|child|
+      if is_element_setter?(child)
+        processor.process(child, test_context)
+      end
+    }
+  end
+
+end

data/lib/concordion_parse_result.rb

@@ -0,0 +1,31 @@
+class ConcordionParseResult
+  include ConcordionUtility
+  attr_accessor :concordion_command, :system_under_test, :content, :tag
+  def initialize(cmd, sut, content, tag)
+    @concordion_command = cmd
+    @system_under_test = sut
+    @content = content
+    @tag = tag
+  end
+  def to_s
+    "CPR: #{@concordion_command}, #{@system_under_test}, #{@content}"
+  end
+
+  def is_set_command?
+    "set" == @concordion_command
+  end
+  def is_verify_command?
+    "verifyrows" == @concordion_command
+  end
+  def is_execute_command?
+    "execute" == @concordion_command
+  end
+
+  def assignment
+    concordion_assignment(@system_under_test)
+  end
+
+  def needs_dereference?
+    @system_under_test =~ /^#/ && @system_under_test.index("=").nil?
+  end
+end

data/lib/concordion_parser.rb

@@ -0,0 +1,47 @@
+require 'rubygems'
+
+require 'hpricot'
+require 'concordion_instrumenter'
+
+class ConcordionParser
+  @@ALL_ATTRIBUTED_ELEMENTS = "/html/body//*[@*]"
+
+  include ConcordionUtility
+
+  attr_accessor :root, :body, :html
+
+  def initialize(reader, concordion)
+    @reader = reader
+    @concordion = concordion
+    @verifier = concordion.verifier
+    @instrumenter = ConcordionInstrumenter.new
+  end
+
+  def parse(filename)
+    @root = Hpricot.parse(@reader.read(filename))
+    @body = @root.at("body")
+    @html = @root.at("html")
+  end
+  def each_concordion_element(&block)
+    @root.search(@@ALL_ATTRIBUTED_ELEMENTS).each {|elem|
+      yield elem
+    }
+  end
+
+
+
+  def each_eligible_concordion_element(&block)
+    each_concordion_element do |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)
+          yield elem
+        end
+      end
+    end
+  end
+
+
+
+end

data/lib/concordion_processor.rb

@@ -0,0 +1,24 @@
+require 'concordion_utility'
+
+class ConcordionProcessor
+  include ConcordionUtility
+
+  def initialize(concordion, decorator)
+    @concordion = concordion
+    @decorator = decorator
+  end
+
+  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)
+  end
+
+  def create_parse_result(tag, attr, value)
+    ConcordionParseResult.new(instrumentation(attr), value, tag.inner_text, tag)
+  end
+
+
+
+end

data/lib/concordion_reader.rb

@@ -0,0 +1,18 @@
+
+class ConcordionReader
+  def read(filename)
+    IO.read(find_on_load_path(filename))
+  end
+
+  def find_on_load_path(filename)
+    return filename if File.exists?(filename) 
+    
+    $LOAD_PATH.each {|path|
+      candidate = "#{path}/#{filename}"
+      return candidate if File.exists?(candidate)
+    }
+
+    raise "Could not find #{filename} on the system load path!"
+  end
+
+end

data/lib/concordion_string_utility.rb

@@ -0,0 +1,63 @@
+
+module SnakeCaseUtility
+  
+  def snake_case(str)
+    s = str.gsub( /([A-Z])/, '_\1')
+    if s.index("_") == 0
+      s = s.slice(1, s.length)
+    end
+
+    s.downcase
+  end
+
+  def snake_cased_test_name(str)
+    s = snake_case(str)
+    s = s.gsub(/_test$/, '')
+    "#{s}.html"
+  end
+
+  def snake_cased_goldmaster_name(str)
+    snake_cased_test_name(str).gsub(".html", "_goldmaster.html")
+  end
+  
+end
+
+module PluralToSingularUtility
+  
+  def singular(str)
+    str.sub(/s$/, "")
+  end
+end
+
+module ConcordionStringUtility
+  include SnakeCaseUtility
+  include PluralToSingularUtility
+  
+  def has_arguments?(name)
+    name !~ /\(\)$/
+  end
+
+  def concordion_assignment(name)
+    name.split("=")[0].strip
+  end
+
+  def has_assignment?(name)
+    name =~ /=/
+  end
+
+
+  def concordion_method_name(name)
+    if name =~ /\(/
+      base = name.split("(")[0].strip
+    else
+      base = name.strip
+    end
+    
+    if !has_assignment?(base)
+      return base
+    end
+
+    base.split("=")[1].strip
+  end
+
+end

data/lib/concordion_string_writer.rb

@@ -0,0 +1,13 @@
+
+
+class ConcordionStringWriter
+  attr_accessor :data
+  def calculate_filename_and_overwrite(data, filename)
+    @data = data.to_s
+    filename
+  end
+  
+  def output_file_exists?(filename)
+    true
+  end
+end

data/lib/concordion_test_case.rb

@@ -0,0 +1,97 @@
+require 'concordion_utility'
+require 'concordion_reader'
+require 'concordion_parser'
+require 'concordion_processor'
+require 'concordion_parse_result'
+require 'concordion_test_case'
+require 'concordion_writer'
+require 'concordion_environment'
+require 'concordion'
+require 'concordion_css_decorator'
+require 'test/unit'
+
+class ConcordionTestCase < Test::Unit::TestCase
+
+  @@EXPECTED_FAILURE_COUNT = 0
+
+  include ConcordionUtility
+
+  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
+  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
+    }
+  end
+
+  def initialize(arg, conf = ConcordionTestCase.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]
+  end
+
+  def test_something_trivial_to_shut_runit_up
+    assert true
+    trivial
+  end
+
+  def trivial
+    @trivial = true
+  end
+  def is_trivial?
+    @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

data/lib/concordion_utility.rb

@@ -0,0 +1,70 @@
+
+require 'concordion_constants'
+require 'concordion_string_utility'
+
+module ConcordionConvenience
+  def methods_for(clazz)
+    (clazz.methods - Object.methods).sort 
+  end
+end
+
+module ConcordionUtility
+  include ConcordionConstants
+  include ConcordionStringUtility
+  include ConcordionConvenience
+
+
+  def instrumentation(attr)
+    attr.split(":")[1]
+  end
+
+  
+  def supported_and_instrumented?(key)
+    supported?(key) and instrumented?(key)
+  end
+
+  def concordion_arguments(name)
+    return [] unless has_arguments?(name)
+    name_no_end_paren = name.gsub(")", '')
+    arg_string = name_no_end_paren.split("(")[1]
+
+    arg_string.split(",").collect { |arg| arg.strip }
+  end
+  def concordion_variable_name(conc_call)
+    if has_property_reference?(conc_call)
+      return conc_call.split(".")[0].strip
+    end
+
+    conc_call.strip
+  end
+
+  def has_property_reference?(conc_call)
+    conc_call =~ /\./
+  end
+
+  def concordion_property_reference(conc_call)
+    if !has_property_reference?(conc_call)
+      return conc_call
+    end
+    idx = conc_call.index(".")
+    conc_call.slice(idx + 1, conc_call.length - idx).strip
+  end
+
+
+
+  def concordion_cmd_attr_exists?(elem)
+    !concordion_cmd_attr_for(elem).nil?
+  end
+
+  def concordion_cmd_attr_for(elem)
+    concordion_command_attributes.each {|attr| 
+      instrumented_value = elem.get_attribute(attr)
+      if !instrumented_value.nil?
+        return attr
+      end
+    }
+    
+    nil
+  end
+
+end

data/lib/concordion_verifier.rb

@@ -0,0 +1,50 @@
+require 'concordion_utility'
+
+class ConcordionVerifier
+  include ConcordionUtility
+
+  @@ROW_REGEXP = /tr:nth\((\d+)\)/
+  attr_accessor :verification_variable
+  def initialize(concordion)
+    @concordion = concordion
+    @verification_variable = nil
+    @last_row = -1
+  end
+
+  def update_if_verify_command(cpr)
+    if cpr.is_verify_command?
+      @verification_variable = cpr.assignment
+    end
+  end
+
+  def update_verifier(idx)
+    return if verification_variable.nil?
+    arr = @concordion.get_variable(verification_variable)
+    index = idx < 1 ? 0 : idx - 1
+
+    value = arr[index]
+    @concordion.set_variable(singular(verification_variable), value)
+  end
+
+  def verification_variable=(value)
+    @verification_variable = value
+
+    unless @verification_variable.nil?
+      update_verifier(0)
+    end
+  end
+  def update_row(elem)
+    on_row = @@ROW_REGEXP.match(elem.css_path)
+    if on_row
+      current_row = on_row.captures[0]
+      if current_row != @last_row
+        update_verifier(current_row.to_i)
+        @last_row = current_row
+      end
+    else
+      @last_row = -1
+    end
+
+  end
+
+end