concordion 0.9.8

data/lib/concordion_environment.rb

@@ -0,0 +1,27 @@
+
+class ConcordionEnvironment
+  def self.output_dir_key
+    'RCOR_OUTPUT_DIR'
+  end
+  
+  def self.css_type_key
+    'RCOR_CSS_TYPE'
+  end
+  
+  def self.with_dir(str)
+    File.join(output_dir, str)
+  end
+  def self.clean_list
+    [with_dir("*_test_output.html"), with_dir("concordion.css")] #TODO is this safe to delete? what if the user overwrites this file?
+  end
+
+  def self.css_type
+    type = ENV[css_type_key] 
+    type.nil? ? :inline : type.to_sym
+  end
+  
+  def self.output_dir
+    dir = ENV[output_dir_key] 
+    dir.nil? ? "." : dir
+  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_instrumenter.rb

@@ -0,0 +1,30 @@
+
+class ConcordionInstrumenter
+  @@TH_CSS_QUERY_REGEXP = /tr:nth\(\d+\) > th:nth\((\d+)\)$/
+  @@TH_CSS_SINGLE_REGEXP = /tr:nth\(\d+\) > th$/
+
+  def instrument_from_headers(elem, attr, root)
+    header = @@TH_CSS_QUERY_REGEXP.match(elem.css_path)
+    if header
+      instrument_column(elem, attr, header.captures, @@TH_CSS_QUERY_REGEXP, root)
+      return true
+    end
+
+    single_header = @@TH_CSS_SINGLE_REGEXP.match(elem.css_path)
+    if single_header
+      instrument_column(elem, attr, 0, @@TH_CSS_SINGLE_REGEXP, root)
+      return true
+    end
+
+    false
+  end
+
+  def instrument_column(elem, attr, column_number, regex, root)
+    trimmed = elem.css_path.sub(regex, '')
+    td_css_query = trimmed + "tr > td:nth(#{column_number})"
+    
+    value = elem.get_attribute(attr)
+    root.search(td_css_query).set(attr, value)
+  end
+
+end

data/lib/concordion_invoker.rb

@@ -0,0 +1,137 @@
+require 'loader_helper'
+require 'concordion_utility'
+
+class ConcordionInvoker
+  include LoaderHelper
+  include ConcordionUtility
+  
+  def initialize(conc)
+    @concordion = conc
+  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"
+    end
+    rv += "]"
+  end
+  
+  
+  def invoke_sut(cpr, test_context)
+    sut_rv = nil
+    if cpr.needs_dereference?
+      sut_rv = try_to_dereference(cpr)
+    else 
+
+      sut_rv = try_to_invoke_sut(cpr,test_context)
+    end
+    
+    sut_rv
+  end
+
+  def handle_args(cpr)
+      arg_vars = concordion_arguments(cpr.system_under_test)
+      arg_values = arg_vars.collect {|var|
+         if var == '#TEXT'
+            cpr.content
+         else
+             @concordion.get_variable(var)
+         end
+      }
+
+      arg_values
+  end
+
+  def arg_values_for(cpr)
+      arg_values = []
+      if has_arguments?(cpr.system_under_test)
+        arg_values = handle_args(cpr)
+      end
+      arg_values
+  end
+
+  def try_to_invoke_sut(cpr, test_context)
+    sut_rv = nil
+    begin
+        conc_method = concordion_method_name(cpr.system_under_test)
+        sut_rv = test_context.send(conc_method, *arg_values_for(cpr))
+    rescue NoMethodError => e
+      sut_rv = report_error(e)
+    end
+    sut_rv
+  end
+
+  def report_error(e)
+    rv = nil
+    if e.to_s =~ /nil:NilClass/
+      rv = "[Parse failed for: #{cpr}, cause: (#{e})]"
+    else
+      method = method_from_no_method_error(e)
+      clazz = class_from_no_method_error(e)
+      rv = "[Missing method '#{method}' in fixture #{clazz} ]"
+    end
+    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)
+    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.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
+
+
+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,72 @@
+require 'concordion_utility'
+
+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
+    "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
+  def is_verify_command?
+    "verifyrows" == @concordion_command
+  end
+  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
+
+  def needs_dereference?
+    @system_under_test =~ /^#/ && @system_under_test.index("=").nil?
+  end
+
+  def verify_error(actual, expected)
+      if actual > expected
+        diff = actual - expected
+        @tag.inner_html += "<tr><td>[#{diff} Surplus Row(s) Returned By Fixture]</td></tr>"
+      end
+  end
+
+  def assertion_error(actual)
+    if is_assert_true_command?
+      @tag.inner_html += ": expected true but received #{actual}"
+    else
+      @tag.inner_html += " expected but received #{actual}"
+    end
+  end
+
+  def attribute_error(actual, expected)
+    if is_verify_command?
+        verify_error(actual, expected)
+    else
+        assertion_error(actual)
+    end
+  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,25 @@
+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)
+    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)
+    ConcordionParseResult.new(instrumentation(attr), value, tag.inner_text, tag)
+  end
+
+
+
+end

data/lib/concordion_reader.rb

@@ -0,0 +1,10 @@
+require 'loader_helper'
+
+class ConcordionReader
+  include LoaderHelper
+  def read(filename)
+    IO.read(path_for(filename))
+  end
+
+
+end

data/lib/concordion_state.rb

@@ -0,0 +1,78 @@
+require 'concordion_utility'
+require 'concordion_lookahead_handler'
+require 'concordion_verifier'
+require 'concordion_invoker'
+require 'concordion_binder'
+
+# Concordion State  manages memory for Concordion specs as they are being parsed (e.g. when #var is declared in a spec, this class holds the memory reference).
+
+
+class ConcordionState
+  include ConcordionUtility
+
+  @@TEXT_VAR = "#TEXT"
+  def self.TEXT_VAR
+    @@TEXT_VAR
+  end
+  attr_reader :verification_variable, :verifier
+
+  def initialize
+    @memory = {}
+    @lookahead_handler = ConcordionLookaheadHandler.new
+    @verifier = ConcordionVerifier.new(self)
+    @invoker = ConcordionInvoker.new(self)
+    @binder = ConcordionBinder.new(self)
+    set_variable(@@TEXT_VAR, @@TEXT_VAR)
+  end
+
+  def set_variable(variable, value)
+    @memory[variable] = value
+  end
+
+  def get_variable(variable)
+    @memory[variable]
+  end
+  
+
+  # Deferences concordion method calls.
+  # For example if memory held:
+  # * #foo => 12
+  # * #bar => 4
+  # Then the following mappings hold:
+  # * #foo => 12
+  # * #foo.to_f => 12.0
+  # * method(#foo, #bar) => method(12, 4)
+
+  def dereference(conc_call)
+    var_name = concordion_variable_name(conc_call)
+    var = get_variable(var_name)
+
+    if !has_property_reference?(conc_call)
+      return var
+    end
+
+    var.send(concordion_property_reference(conc_call))
+  end
+
+  # Evaluate an expression
+  # 1. Lookahead in the tag to see if needed variables are bound later.
+  # 2. Bind a value to the variable from the spec, if needed.  Returns early if bound successfully.
+  # 3. Update the current value of the iterator for verification commands, if needed.
+  # 4. Invoke the system under test
+  # 5. Bind a value to the variable on the left hand side of an equation, if needed.
+  # 6. Hand the system under test return value to the concordion invoker, which makes the assertion.
+  def evaluate(cpr, test_context, processor)
+    @lookahead_handler.handle_lookahead(cpr, test_context, processor)
+
+    return { :result => true } if @binder.bind_if_set_command(cpr) 
+
+    @verifier.update_if_verify_command(cpr)
+
+    sut_rv = @invoker.invoke_sut(cpr, test_context)
+    @binder.handle_assignment(cpr, sut_rv)
+    conc_rv = @invoker.invoke_concordion(cpr, sut_rv)
+    
+    conc_rv
+  end
+
+end

data/lib/concordion_string_utility.rb

@@ -0,0 +1,97 @@
+
+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)
+    !(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
+
+  def has_assignment?(name)
+    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_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,47 @@
+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_state'
+require 'concordion_css_decorator'
+require 'test/unit'
+
+require 'concordion_test_methods'
+
+
+class ConcordionTestCase < Test::Unit::TestCase
+
+  include ConcordionConfigMethods
+  extend ConcordionConfigMethods
+  include ConcordionInternalTestMethods
+  class << self
+    alias_method :original_inherited, :inherited
+  end
+
+  def self.inherited(subclass)
+    original_inherited(subclass)
+    bind_test_method_to(subclass, default_config)
+  end
+
+  def initialize(arg, conf = default_config())
+    super(arg)
+    @config = default_config.merge(conf)
+  end
+
+  def test_something_trivial_to_shut_runit_up
+    assert true
+    trivial
+  end
+
+  def trivial
+    @trivial = true
+  end
+  def is_trivial?
+    @trivial
+  end
+
+end