fit 1.1

data/lib/fit/fixture.rb

@@ -0,0 +1,309 @@
+# Copyright (c) 2002 Cunningham & Cunningham, Inc.
+# Released under the terms of the GNU General Public License version 2 or later.
+
+require 'fit/scientific_double'
+require 'parsedate'
+require 'fit/fixture_loader'
+
+module Fit
+
+  class RunTime
+    def initialize
+      @elapsed = 0
+      @start = Time.now
+    end
+    def to_s
+      @elapsed = Time.now.to_f - @start.to_f
+      if @elapsed > 1
+        @elapsed = @elapsed.round
+        return d(3600) + ':' + d(600) + d(60) + ':' + d(10) + d(1)
+      else
+        @elapsed = (@elapsed * 100).round
+        return d(6000) + ':' + d(1000) + d(100) + '.' + d(10) + d(1)
+      end
+    end
+    def d scale
+      report = @elapsed / scale
+      @elapsed -= report * scale
+      report.to_s
+    end
+  end
+
+  class Counts
+    attr_accessor :right, :wrong, :ignores, :exceptions
+    def initialize
+      @right, @wrong, @ignores, @exceptions = 0, 0, 0, 0
+    end
+    def to_s
+      "#@right right, #@wrong wrong, #@ignores ignored, #@exceptions exceptions"
+    end
+    def tally c
+      @right += c.right
+      @wrong += c.wrong
+      @ignores += c.ignores
+      @exceptions += c.exceptions
+    end
+    def total_errors
+      @wrong + @exceptions
+    end
+  end
+  
+  class FixtureListener
+    def tables_finished(finalCounts)
+    end
+    
+    def table_finished(tableParse)
+    end
+  end
+
+  class Fixture
+    @@metadata = {}
+    def Fixture.metadata; @@metadata; end
+
+    attr_accessor :summary, :counts, :listener, :args
+
+    def initialize
+      @summary = {}
+      @counts = Counts.new
+      @listener = FixtureListener.new
+      @loader = FixtureLoader.new
+      @args = []
+    end
+
+    def total_errors
+      @counts.total_errors
+    end
+    
+    # Traversal
+
+    def find_class class_name
+      @loader.find_fixture_class class_name
+    end
+    
+    def do_tables tables
+      @summary['run date'] = Time.now.to_s
+      @summary['run elapsed time'] = RunTime.new
+      unless tables.nil?
+        fixture_name = fixture_name tables
+        unless fixture_name.nil?
+          begin
+            fixture = get_linked_fixture_with_args tables
+            fixture.interpret_tables tables
+          rescue Exception => e
+            exception fixture_name, e
+            interpret_following_tables tables
+          end
+        end
+      end
+      @listener.tables_finished(@counts)
+    end
+    
+    def interpret_tables tables
+      # don't create the first fixture again, because creation may do something important
+      begin
+        get_args_for_table(tables) # get them again for the new fixture object
+        do_table tables
+      rescue Exception => e
+        exception fixture_name(tables), e
+        return
+      end
+      @listener.table_finished(tables)
+      interpret_following_tables tables
+    end
+    
+    def interpret_following_tables tables
+      tables = tables.more
+      until tables.nil?
+        fixture_name = fixture_name(tables)
+        unless fixture_name.nil?
+          begin
+            fixture = get_linked_fixture_with_args tables
+            fixture.do_table tables
+          rescue Exception => e
+            exception fixture_name, e
+          end
+        end
+        @listener.table_finished(tables)
+        tables = tables.more
+      end
+    end
+    
+    def get_linked_fixture_with_args tables
+      header = fixture_name tables
+      unless header.nil?
+        begin
+          fixture = (find_class header.text).new # using reflection
+          fixture.summary = @summary
+          fixture.counts = @counts
+          fixture.listener = @listener
+          fixture.get_args_for_table tables
+          return fixture
+        rescue Exception => e
+          exception header, e
+        end
+      end
+    end
+    
+    def get_args_for_table table
+      arg = table.parts.parts.more
+      args = []
+      while arg
+        args << arg.text
+        arg = arg.more
+      end
+      @args = args
+    end
+    
+    def fixture_name tables
+      tables.at 0, 0, 0
+    end
+    
+    def do_table table
+      do_rows table.parts.more
+    end
+
+    def do_rows rows
+      until rows.nil?
+        more = rows.more
+        do_row rows
+        rows = more
+      end
+    end
+
+    def do_row row
+      do_cells row.parts
+    end
+
+    def do_cells cells
+      i = 0
+      until cells.nil?
+        begin
+          do_cell cells, i
+        rescue Exception => e
+          exception cells, e
+        end
+        cells = cells.more
+        i += 1
+      end
+    end
+
+    def do_cell cell, column_number
+      ignore cell
+    end
+
+    # Annotation methods
+    GREEN = '#cfffcf'
+    RED = '#ffcfcf'
+    GRAY = '#efefef'
+    YELLOW = '#ffffcf'
+
+    def right cell
+      cell.add_to_tag(' bgcolor="' + GREEN + '"')
+      @counts.right += 1
+    end
+
+    def wrong cell, actual = nil
+      cell.add_to_tag(' bgcolor="' + RED + '"')
+      cell.body = Fixture.escape(cell.text)
+      @counts.wrong += 1
+      unless actual.nil?
+        cell.add_to_body(Fixture.label('expected') + '<hr>' + Fixture.escape(actual) + Fixture.label('actual'))
+      end
+    end
+
+    def ignore cell
+      cell.add_to_tag(' bgcolor="' + GRAY + '"')
+      @counts.ignores += 1
+    end
+
+    def exception cell, e
+      stacktrace = e.backtrace.join "\n"
+      message = e.message.gsub(/>/, '&gt;').gsub(/</, '&lt;')
+      cell.add_to_body "<hr><font size=-2><pre>#{message}\n#{stacktrace}</pre></font>"
+      cell.add_to_tag(' bgcolor="' + YELLOW + '"')
+      @counts.exceptions += 1
+    end
+    
+    def info cell, message
+      string = ' <font color="#808080">' + Fixture.escape(message) + '</font>'
+      cell.add_to_body string
+    end
+    
+    def error cell, message
+      cell.body = Fixture.escape(cell.text)
+      cell.add_to_body('<hr><pre>' + Fixture.escape(message) + '</pre>')
+      cell.add_to_tag(' bgcolor="' + YELLOW + '"')
+      @counts.exceptions += 1
+    end
+    
+    # Utility methods
+    
+    # This method was originally called counts, but the name has been
+    # changed to avoid shadowing the counts accessor attribute.
+    def totals
+      @counts.to_s
+    end
+
+    def Fixture.label s
+      ' <font size=-1 color="#c08080"><i>' + s + '</i></font>'
+    end
+
+    def Fixture.gray s
+      ' <font color="#808080">' + s + '</font>'
+    end
+
+    def Fixture.escape s
+      str = s.gsub(/&/, '&amp;').gsub(/</, '&lt;').gsub(/  /, ' &nbsp;')
+      # str.gsub(/\r\n/, '<br />').gsub(/\n\r/, '<br />').gsub(/\r/, '<br />').gsub(/\n/, '<br />')
+      str.gsub(/\r\n/, '<br />').gsub(/\r/, '<br />').gsub(/\n/, '<br />')
+    end
+
+    # Originally, this method built the name of a Java method from multiple,
+    # space-separated, downcased words, morphing them into a single camelcased
+    # word. Ruby just needs those words to be joined with an underscore. For
+    # historical reasons, this method still maintains its original name.
+    def Fixture.camel name
+      name.gsub(/ /, '_')
+    end
+
+    def parse string, klass
+      return ParseDate.parsedate(string) if klass == ParseDate
+      return ScientificDouble.value_of(string) if klass == ScientificDouble
+      return string if klass == String
+      nil
+    end
+
+    def check cell, adapter
+      text = cell.text
+      if text.empty?
+        begin
+          info cell, adapter.to_s(adapter.get)
+        rescue Exception
+          info cell, 'error'
+        end
+      elsif adapter.nil?
+        ignore cell
+      elsif text == 'error'
+        begin
+          result = adapter.invoke # TypeAdapter.invoke does not exist...
+          wrong cell, adapter.to_s(result)
+        rescue Exception => e
+          right cell # no IllegalAccessException?
+        end
+      else
+        begin
+          result = adapter.get
+          if adapter.equals(adapter.parse(text), result)
+            right cell
+          else
+            wrong cell, adapter.to_s(result)
+          end
+        rescue Exception => e
+          exception cell, e
+        end
+      end
+    end
+
+  end
+
+end

data/lib/fit/fixture_loader.rb

@@ -0,0 +1,75 @@
+module Fit
+
+  class FixtureLoader
+  
+    def load name
+      klass = find_fixture_class name
+      klass.new
+    end
+    
+    def find_fixture_class name
+      camelizedName = (name.split(/[^a-zA-Z0-9.:$]/).collect { |word| first = word.slice!(0,1).upcase; first + word }).join.chomp('.')
+      klass = ([camelizedName, camelizedName + 'Fixture'].collect { |n| find_class n }).find { |fixtureKlass| fixtureKlass }
+      raise "Fixture #{name} not found." unless klass
+      raise "#{name} is not a fixture." unless klass < Fixture
+      klass
+    end
+    
+    # Try to load the named class. We first see if it's already loaded by looking
+    # for the class name. If not, we convert the class name to a file name (by
+    # changing '::' to '/', then try to require that file. We then look for the
+    # constant again. This means that the class Example::Sqrt must be in the file
+    # Example/sqrt.rb or the file example/sqrt.rb.
+    def find_class name
+      klass = find_constant name
+      unless klass
+        ([''] + @@fixture_packages).detect do |prefix|
+          file_path = (prefix + name).gsub(/::/, '/').gsub(/\./, '/')
+          classname = basename = File::basename(file_path)
+          if basename.index('$')
+            basename_parts = basename.split(/\$/)
+            basename = basename_parts[0]
+            classname = basename_parts.join('::')
+          end
+          file_basename = basename.split(/([A-Z][^A-Z]+)/).delete_if {|e| e.empty?}.collect {|e| e.downcase!}.join('_')
+          file_dirname = File::dirname(file_path)
+          file_name = (file_dirname == '.' ? '' : file_dirname + '/') + file_basename
+          begin
+            begin
+              require file_name
+            rescue LoadError
+              require file_name.downcase
+            end
+          rescue LoadError
+            #raise "Couldn't load file #{file_name} or file #{file_name.downcase}"
+          end
+          if file_dirname == '.'
+            klass_name = classname
+          else
+            klass_name =  File::dirname(file_path).split(%r{/}).collect { |e|
+              e.index(/[A-Z]/).nil? ? e.capitalize : e
+            }.join('::') + "::#{classname}"
+          end
+          klass = find_constant klass_name
+        end
+      end
+      klass
+    end
+    
+    def find_constant name
+      class_name = name.gsub '.', '::'
+      classes = []
+      ObjectSpace.each_object(Class) { |klass| classes << klass }
+      classes.find { |klass| klass.name == class_name }
+    end
+    
+    @@fixture_packages=['Fit::']
+    # This method adds the name of a module as a 'package' we should search for fixtures.
+    # Supports import_fixture
+    def FixtureLoader.add_fixture_package module_name
+      @@fixture_packages << module_name + '::'
+    end
+    
+  end
+  
+end

data/lib/fit/import_fixture.rb

@@ -0,0 +1,9 @@
+require 'fit/fixture'
+
+module Fit
+  class ImportFixture < Fixture
+    def do_row row
+     FixtureLoader.add_fixture_package row.parts.text.gsub('.','::') 	    
+    end
+  end
+end

data/lib/fit/parse.rb

@@ -0,0 +1,206 @@
+# Copyright (c) 2002 Cunningham & Cunningham, Inc.
+# Released under the terms of the GNU General Public License version 2 or later.
+
+require 'fileutils' # for footnotes generation
+
+module Fit
+
+  class ParseException < Exception
+    attr_reader :error_offset
+    def initialize message, offset
+      super message
+      @error_offset = offset
+    end
+  end
+
+  # This ParseHolder class is necessary to cope with the different constructors
+  # in the Java version of FIT. One of them is the constructor for the Parse Ruby
+  # class, the other is a static method in the ParseHolder class.
+  #
+  # ParseHolder also maintain all the methods belonging to Parse which are instead
+  # called whenever in FIT a ParseHolder is created instead of a Parse.
+  class ParseHolder
+
+    attr_accessor :leader, :tag, :body, :end, :trailer
+    attr_accessor :more, :parts
+
+    def ParseHolder.create tag, body, parts, more
+      p = new
+      p.leader = "\n"
+      p.tag = "<#{tag}>"
+      p.body = body
+      p.end = "</#{tag}>"
+      p.trailer = ""
+      p.parts = parts
+      p.more = more
+      p
+    end
+
+    def leaf
+      @parts.nil? ? self : @parts.leaf
+    end
+
+    def add_to_tag text
+      @tag = @tag[0..-2] + "#{text}>"
+    end
+
+    def add_to_body text
+      @body += text
+    end
+    
+    def at i, *rest
+      node = (i == 0 || @more.nil?) ? self : @more.at(i - 1)
+      rest.each do |j|
+        node = node.parts.at(j)
+      end
+      node
+    end
+
+    def text
+      Parse.html_to_text @body
+    end
+
+    def last
+      @more.nil? ? self : @more.last
+    end
+
+    def size
+      @more.nil? ? 1 : @more.size + 1
+    end
+
+    def print out
+      out.print @leader
+      out.print @tag
+      if @parts
+        @parts.print out
+      else
+        out.print @body
+      end
+      out.print @end
+      if @more
+        @more.print out
+      else
+        out.print @trailer
+      end
+    end
+
+  end
+
+  class Parse < ParseHolder
+
+    MAX_INT = 2147483647 # hardcoded java.lang.Integer.MAX_VALUE
+    DEFAULT_TAGS = ['table', 'tr', 'td']
+
+    @@footnote_files = 0
+
+    def initialize text, tags = DEFAULT_TAGS, level = 0, offset = 0
+      tag = tags[level]
+      lc = text.downcase
+      start_tag = lc.index "<#{tag}"
+      raise ParseException.new("Can't find tag: #{tag}", offset) if start_tag.nil?
+      end_tag = lc.index('>', start_tag)
+      raise ParseException.new("Can't find tag: #{tag}", offset) if end_tag.nil?
+      end_tag += 1
+      start_end = find_matching_end_tag lc, end_tag, tag, offset
+      raise ParseException.new("Can't find tag: #{tag}", offset) if start_end.nil?
+      end_end = lc.index('>', start_end)
+      raise ParseException.new("Can't find tag: #{tag}", offset) if end_end.nil?
+      end_end += 1
+      start_more = lc.index "<#{tag}", end_end
+      
+      @leader = text[0...start_tag]
+      @tag = text[start_tag...end_tag]
+      @body = text[end_tag...start_end]
+      @end = text[start_end...end_end]
+      @trailer = text[end_end..-1]
+
+      if level + 1 < tags.size
+        @parts = Parse.new @body, tags, level + 1, offset + end_tag
+        @body = nil
+      else # check for nested table
+        index = @body.index "<#{tags[0]}"
+        unless index.nil?
+          @parts = Parse.new @body, tags, 0, offset + end_tag
+          @body = ''
+        end
+      end
+
+      unless start_more.nil?
+        @more = Parse.new @trailer, tags, level, offset + end_end
+        @trailer = nil
+      end
+    end
+
+    def find_matching_end_tag lc, match_from_here, tag, offset
+      from_here = match_from_here
+      count = 1
+      start_end = 0
+      while count > 0
+        embedded_tag = lc.index "<#{tag}", from_here
+        embedded_tag_end = lc.index "</#{tag}", from_here
+        # which one is closer?
+        raise ParseException.new("Can't find tag: #{tag}", offset) if embedded_tag.nil? and embedded_tag_end.nil?
+        embedded_tag = MAX_INT if embedded_tag.nil?
+        embedded_tag_end = MAX_INT if embedded_tag_end.nil?
+        if embedded_tag < embedded_tag_end
+          count += 1
+          start_end = embedded_tag
+          from_here = lc.index('>', embedded_tag) + 1
+        elsif embedded_tag_end < embedded_tag
+          count -= 1
+          start_end = embedded_tag_end
+          from_here = lc.index('>', embedded_tag_end) + 1
+        end
+      end
+      start_end
+    end
+
+    def Parse.html_to_text s
+      str = s.gsub(%r{<\s*br\s*/?\s*>}, '<br />').gsub(%r{<\s*/\s*p\s*>\s*<\s*p( .*?)?\s*>}, '<br />')
+      unescape(condense_whitespace(remove_tags(str)))
+    end
+
+    def Parse.remove_tags s
+      s.gsub(/<.*?>/m) { $& == '<br />' ? $& : '' }
+    end
+
+    def Parse.unescape s
+      str = s.gsub %r{<br />}, "\n"
+      # unescape HTML entities
+      str = str.gsub(%r{&lt;}, '<').gsub(%r{&gt;}, '>').gsub(%r{&nbsp;}, ' ').gsub(%r{&quot;}, '"').gsub(%r{&amp;}, '&')
+      # unescape smart quotes
+      str.gsub(/\223/, '"').gsub(/\224/, '"').gsub(/\221/, "'").gsub(/\222/, "'")
+    end
+
+    def Parse.condense_whitespace s
+      # NOT_BREAKING_SPACE is decimal character 160, hex a0, oct 240
+      s.gsub(%r{\s+}, ' ').gsub(/\240/, ' ').gsub(%r{&nbsp;}, ' ').strip
+    end
+
+    # The original implementation of footnote hardcodes the creation path,
+    # hence is somewhat broken. The use of a class variable lets external
+    # clients (like Rake and FitTask) decide where to generate footnotes.
+    @@footnote_path = 'Reports/'
+    def Parse.footnote_path=(path); @@footnote_path = path; end
+    def Parse.footnote_path; @@footnote_path; end
+    def footnote
+      return '[-]' if @@footnote_files >= 25
+      begin
+        this_footnote = (@@footnote_files += 1)
+        html = "footnotes/#{this_footnote}.html"
+        path = "#{@@footnote_path}#{html}"
+        FileUtils.mkpath File.dirname(path)
+        f = File.new(path, 'w')
+        print f
+        f.close
+        return "<a href=#{@@footnote_path}/#{html}>[#{this_footnote}]</a>"
+      rescue Exception => e
+        puts e.message
+        puts e.backtrace
+        return '[!]'
+      end
+    end
+
+  end
+
+end

data/lib/fit/primitive_fixture.rb

@@ -0,0 +1,52 @@
+# Copyright (c) 2002 Cunningham & Cunningham, Inc.
+# Released under the terms of the GNU General Public License version 2 or later.
+
+require 'fit/fixture'
+
+module Fit
+
+  class PrimitiveFixture < Fixture
+
+    # Format converters
+
+    def parse_integer cell
+      Integer cell.text
+    end
+
+    def parse_double cell
+      Float cell.text
+    end
+
+    def parse_boolean cell
+      cell.text.downcase == 'true' ? true : false
+    end
+
+    # Answer comparison
+
+    def check_value cell, value
+      if value.to_s == cell.text
+        right cell
+      else
+        wrong cell, value.to_s
+      end
+    end
+
+    def check_boolean cell, value
+      if value == parse_boolean(cell)
+        right cell
+      else
+        wrong cell, value.to_s
+      end
+    end
+
+    def check cell, expected, value
+      if expected == value
+        right cell
+      else
+        wrong cell, value
+      end
+    end
+
+  end
+
+end