concordion 0.9.9.2 → 0.9.9.5

data/lib/concordion/parse_result.rb

@@ -0,0 +1,74 @@
+require 'concordion/utility'
+
+module Concordion
+  class ParseResult
+    include Concordion::Utility
+    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
+end

data/lib/concordion/parser.rb

@@ -0,0 +1,43 @@
+require 'concordion/instrumenter'
+require 'rubygems'
+require 'hpricot'
+
+module Concordion
+  class Parser
+    @@ALL_ATTRIBUTED_ELEMENTS = "/html/body//*[@*]"
+
+    include Concordion::Utility
+
+    attr_accessor :root, :body, :html
+
+    def initialize(reader, concordion)
+      @reader = reader
+      @concordion = concordion
+      @verifier = concordion.verifier
+      @instrumenter = Concordion::Instrumenter.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
+end

data/lib/concordion/processor.rb

@@ -0,0 +1,24 @@
+require 'concordion/utility'
+
+module Concordion
+  class Processor
+    include Concordion::Utility
+
+    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)
+      Concordion::ParseResult.new(instrumentation(attr), value, tag.inner_text, tag)
+    end
+  end
+end

data/lib/concordion/reader.rb

@@ -0,0 +1,11 @@
+require 'concordion/loader_helper'
+
+module Concordion
+  class Reader
+    include Concordion::LoaderHelper
+    def read(filename)
+      IO.read(path_for(filename))
+    end
+
+  end
+end

data/lib/concordion/state.rb

@@ -0,0 +1,77 @@
+require 'concordion/utility'
+require 'concordion/lookahead_handler'
+require 'concordion/verifier'
+require 'concordion/invoker'
+require 'concordion/binder'
+
+module Concordion
+  # 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 State
+    include Concordion::Utility
+
+    @@TEXT_VAR = "#TEXT"
+    def self.TEXT_VAR
+      @@TEXT_VAR
+    end
+    attr_reader :verification_variable, :verifier
+
+    def initialize
+      @memory = {}
+      @lookahead_handler = Concordion::LookaheadHandler.new
+      @verifier = Concordion::Verifier.new(self)
+      @invoker = Concordion::Invoker.new(self)
+      @binder = Concordion::Binder.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
+end

data/lib/concordion/string_utility.rb

@@ -0,0 +1,104 @@
+module Concordion
+  module SnakeCaseUtility
+  
+    def snake_case(str)
+      file_parts = str.split "::"
+      
+      s = file_parts.pop      
+      s = s.gsub( /([A-Z])/, '_\1')
+      
+      if s.index("_") == 0
+        s = s.slice(1, s.length)
+      end
+      
+      file_parts << s
+      file_parts.join('/').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 StringUtility
+    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
+end

data/lib/concordion/string_writer.rb

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

data/lib/concordion/test_methods.rb

@@ -0,0 +1,130 @@
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+require 'concordion/writer'
+require 'concordion/environment'
+require 'concordion/css_decorator'
+require 'concordion/state'
+require 'concordion/reader'
+require 'concordion/parser'
+require 'concordion/processor'
+require 'concordion/parse_result'
+
+module Concordion
+  
+  module ConfigMethods
+    
+    def default_config
+      concordion = Concordion::State.new
+      parser = Concordion::Parser.new(Concordion::Reader.new, concordion)
+      decorator = Concordion::CSSDecorator.new
+      processor = Concordion::Processor.new(concordion, decorator)
+      { 
+        :parser => parser,
+        :writer => Concordion::Writer.new(Concordion::Environment.output_dir),
+        :concordion => concordion,
+        :decorator => decorator,
+        :processor => processor,
+        :write_goldmaster => false,
+        :css_type => Concordion::Environment.css_type
+      }
+    end
+
+    def bind_test_method_to(subclass, config)
+      subclass.class_eval do
+        define_method :test_spec do
+          filename = snake_cased_test_name(subclass.to_s)
+          parse_spec(filename,config)
+          failures = run_spec(filename, config)
+          report_spec(filename,config, failures)
+        end
+      end
+      subclass
+    end
+
+  end
+
+  module InternalTestMethods
+    @@EXPECTED_FAILURE_COUNT = 0
+    include Concordion::Utility
+
+    def parse_spec(filename,config)
+      config[:parser].parse(filename)
+      assert_concordion_document(config)
+      if self.class.method_defined?(:css_type)
+        config[:decorator].add_concordion_css_link(config[:parser].root, config[:parser].html, css_type)
+      else
+        config[:decorator].add_concordion_css_link(config[:parser].root, config[:parser].html, config[:css_type])
+      end
+    
+    end
+
+    def run_spec(filename, config)
+      failures = []
+      config[:parser].each_eligible_concordion_element do |elem|
+        failure = config[:processor].process(elem, self)
+        failures << failure unless failure.nil?
+      end
+      failures
+    end
+
+    def report_spec(filename, config, failures)
+      config[:decorator].add_css_file_to_output_dir(config[:writer], config[:css_type])
+
+      writer = config[:writer]
+      if self.class.method_defined?(:rcor_writer)
+        writer = rcor_writer()
+      end
+    
+      outfilename = writer.calculate_filename_and_overwrite(config[:parser].root, filename)
+      assert_no_failures(outfilename, config, failures)
+    end
+
+    def assert_no_failures(outfilename, config, failures)
+      expected = @@EXPECTED_FAILURE_COUNT
+
+      if self.class.method_defined?(:expected_failure_count)
+        expected = expected_failure_count()
+      end
+
+      message = build_message "#{show_failures(failures)}\nWrote output to #{outfilename}.", 
+                              'Actual failure count <?> did not match expected <?>.',
+                              failures.size, expected
+      assert_block message do
+        failures.size == expected
+      end
+    end
+
+    def show_failures(failures)
+      rv = ""
+      failures.each_with_index do |failure, index|
+        rv += "[Error:#{index + 1}] #{failure}\n"
+      end
+      rv
+    end
+
+    def assert_concordion_document(config)
+      assert_equal "http://www.concordion.org/2007/concordion", config[:parser].html.get_attribute("xmlns:concordion")
+    end
+  
+  end
+
+
+  module TestMethods
+    include InternalTestMethods
+    extend  ConfigMethods
+
+    class << self
+      alias_method :original_included, :included
+    end
+
+    def self.included(cmod)
+      original_included(cmod)
+      conf = default_config
+      cm = class << cmod
+        include ConfigMethods
+      end
+    
+      bind_test_method_to(cmod, conf)
+    end
+  end
+end

data/lib/concordion/utility.rb

@@ -0,0 +1,72 @@
+
+require 'concordion/constants'
+require 'concordion/string_utility'
+
+module Concordion
+  module Utility
+    include Concordion::Constants
+    include Concordion::StringUtility
+
+    def instrumentation(attr)
+      attr.split(":")[1]
+    end
+
+    def concordion_arguments(name)
+      return [] unless has_arguments?(name)
+      arg_string = nil
+      if name =~ /\(/
+        name_no_end_paren = name.gsub(")", '')
+        arg_string = name_no_end_paren.split("(")[1]
+      else
+      
+        base = name.strip
+        if base =~ /=/
+          arg_string = nil
+          base = base.split("=")[1].strip
+        end
+        tokens = base.split(" ").compact
+        arg_string = tokens.slice(1, tokens.size - 1).join(" ")
+      end
+    
+      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
+end

data/lib/concordion/verifier.rb

@@ -0,0 +1,52 @@
+require 'concordion/utility'
+
+module Concordion
+  class Verifier
+    include Concordion::Utility
+
+    @@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
+end

data/lib/concordion/writer.rb

@@ -0,0 +1,52 @@
+module Concordion
+  class Writer
+    @@DEFAULT = "."
+    def initialize(output_dir = @@DEFAULT)
+      @output_dir = output_dir.nil? ? @@DEFAULT : output_dir
+    end
+
+    def write(data, filename)
+      create_outputs_directories_for filename
+      f = File.new(filename, "w")
+      
+      f.puts data
+      f.close
+    end
+  
+    def create_outputs_directories_for filename
+      directory = File.dirname filename      
+      FileUtils.mkdir_p directory
+    end
+  
+    def output_file_exists?(filename)
+      exists?(base_filename(filename))
+    end
+  
+    def exists?(filename)
+      File.exists?(filename)
+    end
+  
+    def delete_if_exists(filename)
+      if exists?(filename)
+        File.delete(filename)
+      end
+    
+    end
+  
+    def calculate_filename_and_overwrite(data, filename)
+      outfile = output_filename_for(filename)
+      delete_if_exists(outfile)
+      write(data, outfile)
+
+      outfile
+    end
+
+    def base_filename(filename)
+      File.join(@output_dir, filename)
+    end
+    
+    def output_filename_for(name)
+      base_filename(name.sub(".html", "_test_output.html"))
+    end
+  end
+end

data/lib/concordion_test_case.rb

@@ -1,23 +1,11 @@
-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 'concordion/test_methods'
 require 'test/unit'
 
-require 'concordion_test_methods'
-
-
 class ConcordionTestCase < Test::Unit::TestCase
 
-  include ConcordionConfigMethods
-  extend ConcordionConfigMethods
-  include ConcordionInternalTestMethods
+  include Concordion::ConfigMethods
+  extend Concordion::ConfigMethods
+  include Concordion::InternalTestMethods
   class << self
     alias_method :original_inherited, :inherited
   end