fit 1.1

data/lib/fat/standard_annotation_fixture.rb

@@ -0,0 +1,58 @@
+# Copyright (c) 2002 Cunningham & Cunningham, Inc.
+# Released under the terms of the GNU General Public License version 2 or later.
+
+require 'fit/column_fixture'
+require 'fat/string_writer'
+
+module Fat
+
+  class StandardAnnotationFixture < Fit::ColumnFixture
+  
+    attr_accessor :original_html, :annotation, :text
+
+    def initialize
+      super
+      @original_html = 'Text'
+    end
+
+    def output
+      parse = Fit::Parse.new @original_html, ['td']
+      testbed = Fit::Fixture.new
+      case @annotation
+        when 'right' then testbed.right(parse)
+        when 'wrong' then testbed.wrong(parse, @text)
+        when 'error' then testbed.error(parse, @text)
+        when 'info' then testbed.info(parse, @text)
+        when 'ignore' then testbed.ignore(parse)
+        else return "unknown type: #@type"
+      end
+      generate_output parse
+    end
+
+    def do_cell cell, column
+      begin
+        if column == 4
+          cell.body = rendered_output
+        else
+          super
+        end
+      rescue Exception => e
+        exception cell, e
+      end
+    end
+
+    def rendered_output
+      '<table border="1"><tr>' + output + '</tr></table>'
+    end
+
+    # Code smell note: copied from Fat::ParseFixture
+    def generate_output parse
+      result = StringWriter.new
+      parse.print result
+      result.to_s
+    end
+
+    private :generate_output
+  end
+
+end

data/lib/fat/string_writer.rb

@@ -0,0 +1,12 @@
+# Copyright (c) 2002 Cunningham & Cunningham, Inc.
+# Released under the terms of the GNU General Public License version 2 or later.
+
+module Fat
+
+  class StringWriter
+    def initialize; @s = ''; end
+    def print s; @s += s.to_s; end
+    def to_s; @s; end
+  end
+
+end

data/lib/fat/table.rb

@@ -0,0 +1,23 @@
+# Copyright (c) 2002 Cunningham & Cunningham, Inc.
+# Released under the terms of the GNU General Public License version 2 or later.
+
+require 'fit/fixture'
+require 'fit/parse'
+
+module Fat
+
+  class Table < Fit::Fixture
+    @@table = nil
+    def Table.table; @@table; end
+    def Table.table= table; @@table = table; end
+    def do_rows rows
+      @@table = Fit::ParseHolder.create('table', nil, Table.copy(rows), nil)
+      # evaluate the rest of the table like a runner
+      Fit::Fixture.new.do_tables @@table
+    end
+    def Table.copy tree
+      tree.nil? ? nil : Fit::ParseHolder.create(tree.tag, tree.body, Table.copy(tree.parts), Table.copy(tree.more))
+    end
+  end
+
+end

data/lib/fat/table_parse_fixture.rb

@@ -0,0 +1,33 @@
+# Copyright (c) 2002 Cunningham & Cunningham, Inc.
+# Released under the terms of the GNU General Public License version 2 or later.
+
+require 'fit/column_fixture'
+
+module Fat
+
+  class TableParseFixture < Fit::ColumnFixture
+    attr_accessor :html, :row, :column
+    def cell_body
+      cell.body
+    end
+    def cell_tag
+      cell.tag
+    end
+    def row_tag
+      row.tag
+    end
+    def table_tag
+      table.tag
+    end
+    def cell
+      row.at 0, @column - 1
+    end
+    def row
+      table.at 0, @row - 1
+    end
+    def table
+      Fit::Parse.new(@html)
+    end
+  end
+
+end

data/lib/fat/text_to_html_fixture.rb

@@ -0,0 +1,21 @@
+# Copyright (c) 2002 Cunningham & Cunningham, Inc.
+# Released under the terms of the GNU General Public License version 2 or later.
+
+require 'fit/column_fixture'
+require 'fit/fixture'
+
+module Fat
+
+  class TextToHtmlFixture < Fit::ColumnFixture
+    attr_accessor :text
+    def html
+      @text = unescape_ascii @text
+      Fit::Fixture.escape @text
+    end
+    def unescape_ascii text
+      text.gsub(/\\n/, "\n").gsub(/\\r/, "\r")
+    end    
+    private :unescape_ascii
+  end
+
+end

data/lib/fit/action_fixture.rb

@@ -0,0 +1,65 @@
+# Copyright (c) 2002 Cunningham & Cunningham, Inc.
+# Released under the terms of the GNU General Public License version 2 or later.
+
+require 'fit/fixture'
+require 'fit/type_adapter'
+
+module Fit
+
+  class ActionFixture < Fixture
+
+    attr_reader :cells
+    protected :cells
+    @@actor = nil
+
+    def ActionFixture.actor; @@actor; end
+    def ActionFixture.actor= value
+      @@actor = value
+    end
+
+    def do_cells cells
+      @cells = cells
+      begin
+        send(cells.text)
+      rescue Exception => e
+        exception cells, e
+      end
+    end
+
+    def start
+      klass = find_class @cells.more.text # using reflection
+      @@actor = klass.new
+    end
+
+    # ActionFixture.enter could be called with regular methods
+    # featuring a single argument, or on setters methods of the
+    # form 'name=' when an assignment on an attr is tried.
+    def enter
+      method_name = Fixture.camel @cells.more.text
+      parameter = @cells.more.more.text
+      adapter = TypeAdapter.for(@@actor, method_name, false)
+      adapter.type = @@actor.class.metadata[method_name]
+      argument = adapter.parse(parameter)
+      m = @@actor.method method_name
+      if m.arity == 1
+        @@actor.send(method_name, argument)
+      else
+        adapter.set argument
+      end
+    end
+
+    def press
+      method_name = Fixture.camel @cells.more.text
+      @@actor.send method_name
+    end
+
+    def check
+      method_name = Fixture.camel @cells.more.text
+      adapter = TypeAdapter.for(@@actor, method_name, false)
+      adapter.type = @@actor.class.metadata[method_name]
+      super(@cells.more.more, adapter)
+    end
+
+  end
+
+end

data/lib/fit/column_fixture.rb

@@ -0,0 +1,104 @@
+# Copyright (c) 2002 Cunningham & Cunningham, Inc.
+# Released under the terms of the GNU General Public License version 2 or later.
+
+require 'fit/fixture'
+require 'fit/type_adapter'
+
+module Fit
+
+  class ColumnFixture < Fixture
+
+    attr_accessor :column_bindings, :has_executed
+    protected :column_bindings, :column_bindings=, :has_executed, :has_executed=
+
+    # Traversal
+
+    def do_rows rows
+      bind rows.parts
+      super(rows.more)
+    end
+
+    def do_row row
+      @has_executed = false
+      begin
+        reset
+        super
+        execute if not @has_executed
+      rescue Exception => e
+        exception row.leaf, e
+      end
+    end
+
+    def do_cell cell, column_index
+      adapter = @column_bindings[column_index]
+      begin
+        text = cell.text
+        if text.empty?
+          check cell, adapter
+        elsif adapter.nil?
+          ignore cell
+        elsif adapter.is_output?
+          check cell, adapter
+        else
+          adapter.set(adapter.parse(text))
+        end
+      rescue Exception => e
+        exception cell, e
+      end
+    end
+
+    def check cell, adapter
+      unless @has_executed
+        begin
+          execute
+        rescue Exception => e
+          exception cell, e
+        end
+        @has_executed = true
+      end
+      super
+    end
+
+    def reset
+      # about to process first cell of row
+    end
+
+    def execute
+      # about to process first method call of row
+    end
+
+    # Utility
+
+    protected
+
+    def bind heads
+      @column_bindings = []
+      until heads.nil?
+        name = heads.text
+        begin
+          if name.empty?
+            @column_bindings << nil
+          else
+            suffix = ''
+            if name =~ /\(\)$/
+              suffix = '()'
+              name = name[0...-2]
+            end
+            name = name.split(/([a-zA-Z][^A-Z]+)/).delete_if {|e| e.empty?}.collect {|e| e.downcase}.join('_')
+            name += suffix
+            adapter = TypeAdapter.for(self, name)
+            adapter.type = get_target_class.metadata[name]
+            @column_bindings << adapter
+          end
+        rescue Exception => e
+          exception heads, e
+        end
+        heads = heads.more
+      end
+    end
+
+    def get_target_class; self.class; end
+
+  end
+
+end

data/lib/fit/file_runner.rb

@@ -0,0 +1,80 @@
+# Copyright (c) 2002 Cunningham & Cunningham, Inc.
+# Released under the terms of the GNU General Public License version 2 or later.
+
+require 'fit/fixture'
+require 'fit/parse'
+
+require 'fileutils' # for report generation
+
+module Fit
+
+  class FileRunner
+    attr_accessor :input, :tables, :fixture, :output
+
+    def initialize
+      @fixture = Fixture.new
+    end
+
+    def run args
+      process_args args
+      process
+      $stderr.puts @fixture.totals
+      exit @fixture.total_errors
+    end
+
+    def process_args args
+      error "Usage: #{File.basename($0)} input_file output_file" unless args.size == 2
+
+      input_name = File.expand_path args[0]
+      input_file = File.open input_name
+      output_name = File.expand_path args[1]
+      FileUtils.mkpath File.dirname(output_name)
+      @output = File.open output_name, 'w'
+      @fixture.summary['input file'] = input_name
+      @fixture.summary['input update'] = input_file.mtime.to_s
+      @fixture.summary['output file'] = output_name
+      @input = input_file.read
+      input_file.close
+    end
+
+    def process
+      begin
+        unless @input.index('<wiki>').nil?
+          @tables = Parse.new @input, ['wiki', 'table', 'tr', 'td']
+          @fixture.do_tables @tables.parts
+        else
+          @tables = Parse.new @input, ['table', 'tr', 'td']
+          @fixture.do_tables @tables
+        end
+      rescue Exception => e
+        exception e
+      end
+      @tables.print @output
+      @output.close
+    end
+
+    def exception e
+      @tables = ParseHolder.create 'body', 'Unable to parse input. Input ignored.', nil, nil
+      @fixture.exception @tables, e
+    end
+
+    def error msg
+      $stderr.puts msg
+      exit -1
+    end
+
+    protected :exception, :error
+
+  end
+
+end
+
+# The main loop of the program
+# if __FILE__ == $0
+#   begin
+#     Fit::FileRunner.new.run ARGV
+#   rescue Exception => e
+#     $stderr.puts e.message
+#     exit -1
+#   end
+# end

data/lib/fit/fit_protocol.rb

@@ -0,0 +1,62 @@
+require 'fit/fixture'
+
+module Fit
+  
+  class FitProtocol
+    
+    def FitProtocol.read_size(input)
+      str_value = read(10, input)
+      return str_value.to_i
+    end
+    
+    def FitProtocol.read(bytes, input)
+      value = input.read(bytes)
+      return value
+    end
+    
+    def FitProtocol.read_document(input)
+      byte_count = read_size(input)
+      return read(byte_count, input)
+    end
+    
+    def FitProtocol.read_counts(input)
+      counts = Counts.new
+      counts.right = FitProtocol.read_size(input)
+      counts.wrong = FitProtocol.read_size(input)
+      counts.ignores = FitProtocol.read_size(input)
+      counts.exceptions = FitProtocol.read_size(input)
+      return counts
+    end  
+    
+    def FitProtocol.write_size(size, output)
+      formatted_size = FitProtocol.format_number(size)
+      output.write(formatted_size) 
+      output.flush
+    end
+    
+    def FitProtocol.write_document(document, output)
+      FitProtocol.write_size(document.size, output)
+      output.write(document)
+      output.flush
+    end
+    
+    def FitProtocol.write_counts(counts, output)
+      FitProtocol.write_size(0, output)
+      FitProtocol.write_size(counts.right, output)
+      FitProtocol.write_size(counts.wrong, output)
+      FitProtocol.write_size(counts.ignores, output)
+      FitProtocol.write_size(counts.exceptions, output)
+    end
+    
+    def FitProtocol.format_number(size)
+      number_of_zeros = 10 - size.to_s.size
+      formatted_value = ""
+      number_of_zeros.times do
+        formatted_value << '0'
+      end
+      formatted_value << size.to_s
+      return formatted_value
+    end
+  end
+  
+end

data/lib/fit/fit_server.rb

@@ -0,0 +1,173 @@
+# Written by Object Mentor, Inc. 2005
+# Copyright (c) 2002 Cunningham & Cunningham, Inc.
+# Released under the terms of the GNU General Public License version 2 or later.
+
+require 'fit/fixture'
+require 'fit/parse'
+require 'fit/fit_protocol'
+require 'socket'
+
+module Fit
+  
+  class FitServer
+  
+    attr_accessor :host, :port, :test_ticket, :verbose
+    attr_reader :reason_for_bad_connection, :counts
+  
+    def run(args)
+      if args(args)
+        connected = establish_connection
+        if not connected
+          puts "Could not connect. " + @reason_for_bad_connection
+          return -1
+        else
+          process
+          close_connection
+          finish
+          return exit_code
+        end
+      else
+        usage
+        return -1
+      end    
+    end
+
+    def args(arg_list)
+      begin
+        arg_count = arg_list.size
+        if arg_count == 4 and  arg_list.shift == '-v'
+          @verbose = true
+        elsif arg_count != 3
+          return false
+        end
+        @host = arg_list.shift
+        @port = arg_list.shift.to_i
+        return false if @port.zero?;
+        @test_ticket = arg_list.shift
+        return true
+      rescue => exception
+        return false
+      end
+    end
+  
+    def usage
+      puts "Usage: ruby FitServer.rb [options] <host> <port> <test_ticket>"
+      puts "  -v: verbose"
+    end
+    
+    def build_request
+      return "GET /?responder=socketCatcher&ticket=" + @test_ticket + " HTTP/1.1\r\n\r\n"
+    end
+    
+    def close_connection
+      @socket.close
+    end
+    
+    def establish_connection
+      say "Connecting to " + @host.to_s + ":" + @port.to_s
+      @socket = TCPSocket.new(@host, @port)
+      @socket.print(build_request)
+      @socket.flush
+      status = FitProtocol.read_size(@socket)
+      unless status.zero?
+        @reason_for_bad_connection = FitProtocol.read(status, @socket)
+        say "\t> failed to connect: " + @reason_for_bad_connection
+        return false
+      else
+        say "\t> connected"
+        return true
+      end
+    end
+    
+    def process
+      @fixture_listener = TablePrintingFixtureListener.new(@socket)
+      @counts = Counts.new
+      document_size = 0
+      begin
+        while ((document_size = FitProtocol.read_size(@socket)) != 0)
+          begin
+            say "Processing document with " + document_size.to_s + " bytes"
+            document = FitProtocol.read(document_size, @socket)
+            tables = Parse.new(document, ['table', 'tr', 'td'])
+            new_fixture
+            @fixture.do_tables(tables)
+            say "\t> " + @fixture.counts.to_s
+            @counts.tally(@fixture.counts)
+          rescue Fit::ParseException => e
+            exception(e)
+          end
+        end
+      rescue => e
+        exception(e)
+      end
+    end
+    
+    def new_fixture
+      @fixture = Fixture.new
+      @fixture.listener = @fixture_listener
+    end
+    
+    def good_connection?
+      return reason_for_bad_connection.nil?
+    end
+    
+    def finish
+      say "Final counts: " + @counts.to_s
+      say "Exiting with code " + exit_code().to_s
+    end
+    
+    def exit_code()
+      return @counts.wrong + @counts.exceptions
+    end
+    
+    def say(message)
+      puts message if @verbose
+    end
+    
+    def exception(e)
+      say "Exception occured!"
+      say "\t> " + e.to_s
+      parse = ParseHolder.create("span",  "Exception occurred: ", nil, nil)
+      if @fixture.nil?
+        new_fixture
+      end
+      @fixture.exception(parse, e)
+      @counts.exceptions = @counts.exceptions + 1
+      @fixture_listener.table_finished(parse)
+      @fixture_listener.tables_finished(@fixture.counts)
+    end
+    
+  end  
+
+  class PrintString
+    def initialize; @buffer = ''; end
+    def print text; @buffer += text; end
+    def to_s; @buffer; end
+  end
+  
+  class TablePrintingFixtureListener
+    def initialize(socket)
+      @socket = socket
+    end
+    
+    def table_finished(tableParse)
+      buffer = PrintString.new
+      print_table(tableParse, buffer)
+      FitProtocol.write_document(buffer.to_s, @socket)
+    end
+    
+    def print_table(table, output)
+      more = table.more
+      table.more = nil
+      if table.trailer.nil?
+        table.trailer = ""
+      end
+      table.print(output)
+      table.more = more
+    end
+    
+    def tables_finished(counts)
+      FitProtocol.write_counts(counts, @socket)
+    end
+  end
+end