fit 1.1

data/lib/eg/all_combinations.rb

@@ -0,0 +1,44 @@
+# Copyright (c) 2002 Cunningham & Cunningham, Inc.
+# Released under the terms of the GNU General Public License version 2 or later.
+
+require 'eg/all_files'
+
+module Eg
+
+  class AllCombinations < AllFiles
+    def initialize
+      super
+      @lists = []
+      @case_number = 1
+    end
+    def do_table table
+      @row = table.parts.last
+      super
+      combinations
+    end
+    protected
+    def do_row_files row, files
+      @lists << files
+    end
+    def combinations index = 0, combination = @lists
+      if index == @lists.size
+        do_case combination
+      else
+        files = @lists[index]
+        files.each do |f|
+          comb = combination.dup
+          comb[index] = f
+          combinations(index + 1, comb)
+        end
+      end
+    end
+    def do_case combination
+      number = tr(td('#' + @case_number.to_s, nil), nil)
+      @case_number += 1
+      number.leaf.add_to_tag 'colspan="2"'
+      @row.last.more = number
+      do_files number, combination
+    end
+  end
+
+end

data/lib/eg/all_files.rb

@@ -0,0 +1,94 @@
+# 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 Eg
+
+  class AllFiles < Fit::Fixture
+    @@file_stack = []
+    def do_row row
+      cell = row.leaf
+      files = expand cell.text
+      if files.size > 0
+        do_row_files row, files
+      else
+        ignore cell
+        cell.add_to_body Fit::Fixture.gray('no match')
+      end
+    end
+    def expand pattern; Dir[pattern]; end
+    protected
+    def do_row_files row, files; do_files row, files; end
+    def do_files row, files
+      files.each do |filename|
+        cells = td(File.basename(filename), td('', nil))
+        row = (row.more = tr(cells, row.more))
+        fixture = Fit::Fixture.new
+        run(filename, fixture, cells)
+        summarize(fixture, filename)
+      end
+    end
+    def run filename, fixture, cells
+      if push_and_check(filename)
+        ignore cells
+        cells.add_to_body Fit::Fixture.gray('recursive')
+        return
+      end
+      begin
+        input = File.open(filename) {|f| f.read}
+        if input.index('<wiki>')
+          tables = Fit::Parse.new(input, ['wiki', 'table', 'tr', 'td'])
+          fixture.do_tables tables.parts
+        else
+          tables = Fit::Parse.new(input, ['table', 'tr', 'td'])
+          fixture.do_tables tables
+        end
+        cells.more.add_to_body Fit::Fixture.gray(fixture.totals)
+        if fixture.total_errors.zero?
+          right cells.more
+        else
+          wrong cells.more
+          cells.more.add_to_body tables.footnote
+        end
+      rescue Exception => e
+        exception cells, e
+      end
+      pop filename
+    end
+    def push_and_check filename
+      return true if @@file_stack.member? filename
+      @@file_stack << filename
+      false
+    end
+    def pop filename; @@file_stack.delete filename; end
+    def tr cells, more
+      Fit::ParseHolder.create('tr', nil, cells, more)
+    end
+    def td text, more
+      Fit::ParseHolder.create('td', Fit::Fixture.gray(text), nil, more)
+    end
+    private
+    def summarize fixture, filename
+      fixture.summary['input file'] = filename
+      fixture.summary['input update'] = File.open(filename) {|f| f.mtime.to_s}
+      run_totals = @summary.include?('counts run') ? @summary['counts run'] : Fit::Counts.new
+      run_totals.tally fixture.counts
+      @summary['counts run'] =  run_totals
+    end
+    # Self test.
+    class Expand < Fit::ColumnFixture
+      attr_accessor :path
+      def initialize
+        super
+        @fixture = AllFiles.new
+      end
+      def expansion
+        files = @fixture.expand @path
+        files.sort.collect {|filename| File.basename(filename)}
+      end
+    end
+  end
+
+end

data/lib/eg/all_pairs.rb

@@ -0,0 +1,172 @@
+# Copyright (c) 2002 Cunningham & Cunningham, Inc.
+# Released under the terms of the GNU General Public License version 2 or later.
+
+require 'eg/all_combinations'
+require 'set'
+
+module Eg
+
+  class AllPairs < AllCombinations
+    
+    attr_accessor :steps, :to_item, :vars, :pairs
+    @@rank = 0
+    def AllPairs.rank; @@rank; end
+    
+    def initialize
+      super
+      @steps = 0
+      @to_item = {}
+      @vars = []
+      @pairs = Set.new
+    end
+    
+    protected
+    
+    def combinations
+      populate
+      generate
+    end
+
+    # Populate
+
+    def populate
+      do_all_vars
+      do_all_var_pairs
+    end
+
+    def do_all_vars
+      @@rank = 0
+      @lists.each_with_index do |files, i|
+        var = Var.new i, files
+        @vars << var
+        do_all_items var, files
+      end
+    end
+
+    def do_all_items var, files
+      files.each_with_index do |file, i|
+        item = Item.new var, i, @@rank
+        @@rank += 1
+        @to_item[file] = item
+        var.items << item
+      end
+    end
+
+    def do_all_var_pairs
+      @vars.each_with_index do |var, i|
+        j = i + 1
+        while j < @vars.size
+          do_all_item_pairs @vars[i], @vars[j]
+          j += 1
+        end
+      end
+    end
+
+    def do_all_item_pairs vl, vr
+      vl.items.each do |var_left|
+        vr.items.each do |var_right|
+          @pairs << Pair.new(var_left, var_right)
+        end
+      end
+    end
+
+    # Generate
+
+    def generate
+      while @pairs.sort.first.used.zero?
+        emit next_case
+      end
+    end
+
+    def next_case
+      slug = [nil] * @vars.size
+      while not is_full?(slug)
+        p = next_fit slug
+        fill slug, p
+      end
+      slug
+    end
+    private :next_case
+
+    def fill slug, pair
+      slug[pair.left.var.index] = pair.left
+      slug[pair.right.var.index] = pair.right
+      pair.used += 1
+      @pairs << pair
+    end
+
+    def is_full? slug
+      slug.each {|s| return false if s.nil?}
+      true
+    end
+
+    def next_fit slug
+      hold = []
+      pair = next_pair
+      while not pair.is_fit?(slug)
+        hold << pair
+        pair = next_pair
+      end
+      @pairs += hold
+      pair
+    end
+
+    def next_pair
+      first = @pairs.sort.first
+      @pairs.delete first
+      @steps += 1
+      first
+    end
+
+    def emit slug
+      combination = []
+      slug.each {|s| combination << s.file}
+      do_case combination
+    end
+
+    # Helper classes
+
+    class Var
+      attr_accessor :files, :items
+      attr_accessor :index
+      def initialize index, files
+        @index, @files = index, files
+        @items = []
+      end
+    end
+
+    class Item
+      attr_accessor :var
+      attr_accessor :index, :rank
+      def initialize v, i, n
+        @var, @index, @rank = v, i, n
+      end
+      def file; var.files[@index]; end
+      def is_fit? slug
+        slug[var.index].nil? or slug[var.index] == self
+      end
+    end
+
+    class Pair
+      attr_accessor :left, :right
+      attr_accessor :used
+      def initialize left, right
+        @left, @right = left, right
+        @used = 0
+      end
+      def is_fit? slug
+        @left.is_fit?(slug) and @right.is_fit?(slug)
+      end
+      def rank
+        AllPairs.rank * (AllPairs.rank * @used + @left.rank) + @right.rank
+      end
+      def <=> obj
+        rank - obj.rank
+      end
+    end
+
+    # No self test classes.
+
+  end
+
+end

data/lib/eg/arithmetic_column_fixture.rb

@@ -0,0 +1,35 @@
+# 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/scientific_double'
+
+module Eg
+
+  class ArithmeticColumnFixture < Fit::ColumnFixture
+    attr_accessor :x, :y
+    @@metadata = { 'sin()' => Fit::ScientificDouble, 'cos()' => Fit::ScientificDouble }
+    def plus
+      x + y
+    end
+    def minus
+      x - y
+    end
+    def times
+      x * y
+    end
+    def divide
+      x / y
+    end
+    def floating
+      Float(x) / Float(y)
+    end
+    def sin
+      Fit::ScientificDouble.new Math.sin(x / 180.0 * Math::PI)
+    end
+    def cos
+      Fit::ScientificDouble.new Math.cos(x / 180.0 * Math::PI)
+    end
+  end
+
+end

data/lib/eg/arithmetic_fixture.rb

@@ -0,0 +1,29 @@
+# Copyright (c) 2002 Cunningham & Cunningham, Inc.
+# Released under the terms of the GNU General Public License version 2 or later.
+
+require 'fit/primitive_fixture'
+
+module Eg
+
+  class ArithmeticFixture < Fit::PrimitiveFixture
+    def initialize
+      super
+      @x = @y = 0
+    end
+    def do_rows rows
+      super(rows.more) # skip column heads
+    end
+    def do_cell cell, column_index
+      case column_index
+        when 0 then @x = parse_integer(cell);
+        when 1 then @y = parse_integer(cell);
+        when 2 then check(cell, parse_integer(cell), @x + @y)
+        when 3 then check(cell, parse_integer(cell), @x - @y)
+        when 4 then check(cell, parse_integer(cell), @x * @y)
+        when 5 then check(cell, parse_integer(cell), @x / @y)
+        else ignore(cell)
+      end
+    end
+  end
+
+end

data/lib/eg/binary_chop.rb

@@ -0,0 +1,100 @@
+# 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 Eg
+
+  class BinaryChop < Fit::ColumnFixture
+
+    attr_accessor :key
+
+    def execute
+      @array = [] if @array.nil?
+    end
+
+    def array= value
+      unless value.kind_of? Array
+        @array = [value]
+      else
+        @array = value
+      end
+    end
+    def array; @array; end
+
+    def result
+      chop_friday key, array
+    end
+
+    def mon; chop_monday(key, array); end
+    def tue; chop_tuesday(key, array); end
+    def wed; chop_wednesday(key, array); end
+    def thr; chop_thursday(key, array); end
+    def fri; chop_friday(key, array); end
+
+    # Search methods
+
+    def chop_monday key, array
+      min = 0
+      max = array.size - 1
+      while min <= max
+        probe = (min + max) / 2
+        if key == array[probe]
+          return probe
+        elsif key > array[probe]
+          min = probe + 1
+        else
+          max = probe - 1
+        end
+      end
+      -1
+    end
+
+    def chop_tuesday key, array
+      min = 0
+      max = array.size - 1
+      while min <= max
+        probe = (min + max) / 2
+        case key <=> array[probe]
+          when 0 then return probe
+          when 1 then min = probe + 1
+          when -1 then max = probe - 1
+          else raise "Unexpected result from <=>"
+        end
+      end
+      -1
+    end
+
+    def chop_wednesday key, array
+      return -1 if array.size.zero?
+      probe = array.size / 2
+      return probe if key == array[probe]
+      return chop_wednesday(key, array[0, probe]) if key < array[probe]
+      result = chop_wednesday(key, array[(probe + 1)..-1])
+      return (result < 0) ? result : result + probe + 1
+    end
+
+    def chop_thursday key, array
+      min = 0
+      max = array.size - 1
+      while min <= max
+        probe = (rand * (max - min) + min).to_i
+        if key == array[probe]
+          return probe
+        elsif key > array[probe]
+          min = probe + 1
+        else
+          max = probe - 1
+        end
+      end
+      -1
+    end
+
+    def chop_friday key, array
+      array.each_with_index {|e, i| return i if key == e}
+      -1
+    end
+
+  end
+
+end

data/lib/eg/calculator.rb

@@ -0,0 +1,69 @@
+# 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/scientific_double'
+
+module Eg
+
+  class Hp35
+    attr_reader :r
+    def initialize
+      @r = [0, 0, 0, 0]
+      @s = 0
+    end
+    def key key
+      if key.kind_of? Numeric
+        push key.to_f
+      else
+        case key
+          when 'enter' then push
+          when '+' then push(pop() + pop())
+          when '-' then n = pop(); push(pop() - n)
+          when '*' then push(pop() * pop())
+          when '/' then n = pop(); push(pop() / n)
+          when 'x^y' then push(pop() ** pop())
+          when 'clx' then @r[0] = 0
+          when 'clr' then @r[0] = @r[1] = @r[2] = @r[3] = 0
+          when 'chs' then @r[0] = -@r[0]
+          when 'x<>y' then @r[0], @r[1] = @r[1], @r[0]
+          when 'r!' then @r[3] = pop()
+          when 'sto' then @s = @r[0]
+          when 'rcl' then push(@s)
+          when 'sqrt' then push(Math.sqrt(pop()))
+          when 'ln' then push(Math.log(pop()))
+          when 'sin' then push(Math.sin(pop() / 180 * Math::PI))
+          when 'cos' then push(Math.cos(pop() / 180 * Math::PI))
+          when 'tan' then push(Math.tan(pop() / 180 * Math::PI))
+          else raise "Can't do key: #{key}"
+        end
+      end
+    end
+    def push value = nil
+      3.downto(1) {|i| @r[i] = @r[i - 1]}
+      @r[0] = value unless value.nil?
+    end
+    def pop
+      result = @r[0]
+      0.upto(2) {|i| @r[i] = @r[i + 1]}
+      result
+    end
+  end
+
+  class Calculator < Fit::ColumnFixture
+    attr_accessor :volts, :key
+    @@metadata = { 'x()' => Fit::ScientificDouble, 'y()' => Fit::ScientificDouble,
+                   'z()' => Fit::ScientificDouble, 't()' => Fit::ScientificDouble }
+    @@hp = Hp35.new
+    def points; false; end
+    def flash; false; end
+    def watts; 0.5; end
+    def reset; key = nil; end
+    def execute; @@hp.key(key) unless key.nil?; end
+    def x; Fit::ScientificDouble.new @@hp.r[0]; end
+    def y; Fit::ScientificDouble.new @@hp.r[1]; end
+    def z; Fit::ScientificDouble.new @@hp.r[2]; end
+    def t; Fit::ScientificDouble.new @@hp.r[3]; end
+  end
+
+end

data/lib/eg/column_index.rb

@@ -0,0 +1,85 @@
+# Copyright (c) 2002 Cunningham & Cunningham, Inc.
+# Released under the terms of the GNU General Public License version 2 or later.
+
+require 'fit/row_fixture'
+require 'set'
+
+module Eg
+
+  class ColumnIndex < Fit::RowFixture
+
+    def do_rows rows
+      @rows = rows
+      super
+    end
+
+    def query
+      # first find what classes are mentioned in the table...
+      names = Set.new
+      column_index = 0
+      cell = @rows.parts
+      until cell.nil?
+        break if cell.text == 'className'
+        column_index += 1
+        cell = cell.more
+      end
+      row = @rows.more
+      until row.nil?
+        names.add row.at(0, column_index).text
+        row = row.more
+      end
+      # ...then find the columns in these classes
+      columns = []
+      names.each do |name|
+        obj = Fit::FixtureLoader.new.find_class(name).new
+        attributes = obj.methods - Object.new.methods
+        setters = attributes.dup.delete_if {|a| a[-1..-1] != "="}
+        attributes -= setters
+        setters.each do |s|
+          getter = s[0..-2]
+          if attributes.include? getter
+            attributes.delete getter
+            columns << Column.create(obj, getter)
+          end
+        end
+        attributes.each do |m|
+          meth = obj.method(m.to_sym)
+          columns << Column.create(obj, "#{m}()") if meth.arity.zero?
+        end
+      end
+      columns 
+    end
+
+    def get_target_class; Column; end
+
+    def parse string, klass
+      return parse_class(string) if klass == Class
+      super
+    end
+
+    def parse_class name
+      Fit::FixtureLoader.new.find_class(name)
+    end
+    
+    # Helper class
+
+    class Column
+      attr_accessor :column, :class_name, :column_name, :column_type
+      @@metadata = { 'column_name' => String, 'column_type' => Class, 'column' => Object, 'class_name' => Class }
+      def Column.metadata; @@metadata; end
+      def Column.create obj, attribute
+        c = new
+        c.column = attribute
+        c.class_name = obj.class
+        column_name = attribute.to_s
+        column_name_parts = column_name.split(/_/)
+        c.column_name = column_name_parts.shift
+        column_name_parts.each {|name| c.column_name += name.capitalize}
+        c.column_type = obj.class.metadata[column_name]
+        c
+      end
+    end
+    
+  end
+
+end

data/lib/eg/division.rb

@@ -0,0 +1,13 @@
+# 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 Eg
+
+  class Division < Fit::ColumnFixture
+    attr_accessor :numerator, :denominator
+    def quotient; @numerator.to_f / @denominator.to_f; end
+  end
+
+end

data/lib/eg/echo_args_fixture.rb

@@ -0,0 +1,9 @@
+require 'fit/row_fixture'
+
+module Eg
+  class EchoArgsFixture < Fit::RowFixture
+    def query
+      @args
+    end
+  end
+end