greenpepper-ruby 0.0.1

data/lib/greenpepper/example/dowithexample.rb

@@ -0,0 +1,192 @@
+=begin
+author: Simon Mathieu (simon.math@gmail.com)
+date: March 9, 2009
+=end
+
+require 'greenpepper/example/examplewithfixture'
+require 'greenpepper/example/nameresolver'
+require 'greenpepper/converter'
+require 'greenpepper/example/executionresults'
+
+module GreenPepper
+
+class DoWithExample < ExampleWithFixture
+  attr_reader :lines
+
+  def initialize(fixture_name, line_factory = DoWithLineFactory.new)
+    super fixture_name
+    @lines = []
+    @line_factory = line_factory
+  end
+
+  def do_execute(results, fixture_class)
+    fixture = instantiate_fixture fixture_class
+
+    if fixture.is_a? Class
+      e = GreenPepperSecurityError.new(
+        "Can't instantiate a subclass of Class.")
+      results.add FIXTURE_NAME_ROW, FIXTURE_NAME_COLUMN, WriteExceptionExampleResult.new(e)
+      return results
+    end
+
+    @lines.each_with_index{ |line, line_index|
+      begin
+        res = line.execute(fixture)
+      rescue => error
+        res = WriteExceptionExampleResult.new(error)
+      end
+      unless res.nil?
+        results.add line_index + FIRST_DATA_ROW, line.result_column, res
+      end
+    }
+    results
+  end
+
+  def add_function_call(function, result_column, *params)
+    @lines << @line_factory.create_function_call(function,
+      result_column, params)
+  end
+
+  def add_check(function, result_column, expected_val, *params)
+    @lines << @line_factory.create_check(function, 
+      result_column, expected_val, params)
+  end
+
+  def add_accept(function, result_column, *params)
+    @lines << @line_factory.create_accept(function, result_column, params)
+  end
+
+  def add_reject(function, result_column, *params)
+    @lines << @line_factory.create_reject(function, result_column, params)
+  end
+end
+
+class DoWithLineFactory
+  def create_function_call(function, result_column, params)
+    DoWithLineNoKeyword.new(function, result_column, params)
+  end
+
+  def create_check(function, result_column, expected_val, params)
+    DoWithLineCheck.new(function, result_column, expected_val, params)
+  end
+
+  def create_accept(function, result_column, params)
+    DoWithLineAccept.new(function, result_column, params)
+  end
+
+  def create_reject(function, result_column, params)
+    DoWithLineReject.new(function, result_column, params)
+  end
+end
+
+class DoWithLine
+  attr_reader :function, :parameters, :result_column
+
+  def initialize(func, column, params)
+    @parameters = params
+    @function = NameResolver.format_column_name func
+    @result_column = column
+  end
+
+  def function?
+    false
+  end
+
+  def check?
+    false
+  end
+
+  def accept?
+    false
+  end
+
+  def reject?
+    false
+  end
+
+  protected
+  def call_func(fixture)
+    if !fixture.respond_to? @function
+      ErrorHelper.raise_greenpepper_missing_method @function, fixture
+    end
+    @parameters = convert_values(@parameters, fixture)
+    fixture.send @function, *@parameters
+  end
+
+  private
+  def convert_values(string_values, fixture)
+    TypeConverter.instance.auto_convert_string(
+      fixture, @function, string_values)
+  end
+end
+
+class DoWithLineNoKeyword < DoWithLine
+  def execute(fixture)
+    call_func fixture
+    nil #Do not add a result
+  end
+
+  def function?
+    true
+  end
+end
+
+class DoWithLineCheck < DoWithLine
+  def initialize(func, column, expected_value, params)
+    super func, column, params
+    @expected_value = expected_value
+  end
+
+  def execute(fixture)
+    res = call_func fixture
+    #For Check functions, we need to have a way in the fixture to 
+    #convert the string in the fixture. The function called by the
+    #converter will be parse_check_#{@function}
+    expected = TypeConverter.instance.auto_convert_string(
+        fixture, 'check_' + @function, @expected_value)
+    return SuccessExampleResult.new if res == expected
+
+    formated_result = TypeConverter.instance.auto_convert_object(
+        fixture, 
+        'check_' + @function, 
+        @expected_value,
+        res)
+
+    WriteExpectedExampleResult.new formated_result, @expected_value
+  end
+
+  def check?
+    true
+  end
+end
+
+class DoWithLineAccept < DoWithLine
+  def execute(fixture)
+    res = call_func fixture
+    return SuccessExampleResult.new if res == true
+    FailureExampleResult.new
+  end
+
+  def accept?
+    true
+  end
+end
+
+class DoWithLineReject < DoWithLine
+  def execute(fixture)
+    begin
+      res = call_func fixture
+    rescue Exception => e
+      res = false
+    end
+
+    return SuccessExampleResult.new if res == false
+    FailureExampleResult.new
+  end
+
+  def reject?
+    true
+  end
+end
+
+end

data/lib/greenpepper/example/exampleheader.rb

@@ -0,0 +1,41 @@
+=begin
+author: S�bastien Boisclair (Sebastien.Boisclair2@usherbrooke.ca)
+date: September 15, 2009
+=end
+
+module GreenPepper
+class ExampleBaseHeader
+  attr_accessor :name
+
+  def initialize(name="", name_resolver = NameResolver)
+    @name = name
+    @name_resolver= name_resolver
+    @formated_name = name_resolver.format_column_name name
+  end
+
+  def to_s
+    @name
+  end
+
+  def verify_accessor(fixture_class)
+      return NoExampleResult.new(true) if @name == ''
+      if fixture_class.method_defined? "#{@formated_name}"
+        return NoExampleResult.new(true)
+      else
+        error = GreenPepperMissingHeaderError.new(
+          "Cannot find method \"#{@formated_name}\".")
+        return WriteExceptionExampleResult.new(error)
+      end
+  end
+end
+
+class ExampleInputHeader < ExampleBaseHeader
+  def execute(value, fixture, value_format = nil)
+    if @formated_name.strip != ''
+      return NoExampleResult.new if !fixture.respond_to? @formated_name
+      @name_resolver.set_instance_field fixture, @formated_name, value 
+    end
+    nil
+  end
+end
+end

data/lib/greenpepper/example/examplewithfixture.rb

@@ -0,0 +1,73 @@
+=begin
+author: Simon Mathieu (simon.math@gmail.com)
+date: March 19, 2009
+=end
+
+require 'greenpepper/example/executionresults'
+require 'greenpepper/example/nameresolver'
+
+module GreenPepper
+  class ExampleWithFixture
+    attr_accessor :fixture_name, :fixture_arguments, :headers
+    
+    EXAMPLE_NAME_ROW = 0
+    EXAMPLE_NAME_COLUMN = 0
+    FIXTURE_NAME_ROW = 0
+    FIXTURE_NAME_COLUMN = 1
+    HEADER_ROW = 1
+    FIRST_DATA_ROW = 1
+
+    def initialize(fixture_name)
+      if fixture_name == nil
+        raise GreenPepperMalformedTableError.new(
+        'No fixture name provided') 
+      end
+      @fixture_name = fixture_name
+      @fixture_arguments = []
+      @headers = []
+    end
+
+    def add_fixture_argument(value)
+      @fixture_arguments << 
+        TypeConverter.instance.convert_string(value)
+    end
+
+    def execute
+      fixture_class = NameResolver.solve_fixture_name(@fixture_name)
+      results = HtmlTableExecutionResults.new
+
+      if fixture_class.nil?
+        results.add FIXTURE_NAME_ROW, FIXTURE_NAME_COLUMN, 
+          ErrorExampleResult.new
+        return results
+      end
+
+      begin
+        check_headers fixture_class, results, HEADER_ROW
+        do_execute results, fixture_class
+      rescue GreenPepperError => e
+        raise e
+      rescue Exception => e
+        results.add FIXTURE_NAME_ROW, FIXTURE_NAME_COLUMN, 
+          WriteExceptionExampleResult.new(e)
+      end
+      results
+    end
+
+    protected 
+    def check_headers(fixture, results, row_number)
+      @headers.each_with_index do |header,header_index|
+        result = header.verify_accessor(fixture)
+        results.add(row_number, header_index, result)
+      end
+    end
+
+    def instantiate_fixture(fixture_class)
+      if fixture_class.instance_method(:initialize).arity > 0
+        fixture_class.new *@fixture_arguments
+      else
+        fixture_class.new
+      end
+    end
+  end
+end

data/lib/greenpepper/example/executionresults.rb

@@ -0,0 +1,160 @@
+=begin
+author: Martin Provencher (martin.provencher@usherbrooke.ca)
+date: April 25, 2009
+=end
+module GreenPepper
+
+require 'greenpepper/writer/htmlresult'
+
+class ExecutionResults
+  attr_accessor :successes, :failures, :errors, :ignored
+
+  def initialize
+    @successes = 0
+    @failures = 0
+    @errors = 0
+    @ignored = 0
+  end
+
+  def add_success
+    @successes += 1
+  end
+
+  def add_failure
+    @failures += 1
+  end
+
+  def add_error
+    @errors += 1
+  end
+
+  def add_ignore
+    @ignored += 1
+  end
+
+  def self.get_all_results(results_array)
+    results = HtmlTableExecutionResults.new
+
+    results_array.each{ |result|
+      results.successes += result.successes
+      results.failures += result.failures
+      results.errors += result.errors
+      results.ignored += result.ignored
+    }
+    results
+  end
+
+  protected
+  def update_stats(result)
+    unless result.silent
+      @successes += 1 if result.success?
+      @failures += 1 if result.failure?
+      @errors += 1 if result.error?
+      @ignored += 1 if result.ignored?
+    end
+  end
+end
+
+class FreeTextExecutionResults < ExecutionResults
+  attr_reader :results
+  def initialize
+    super
+    @results = []
+  end  
+
+  def add_result(result)
+    @results << result
+    result.update_stats(self)
+  end
+
+  def [](value)
+    results[value]
+  end
+
+  def to_s
+    @results.join("\n")
+  end
+end
+
+class HtmlTableExecutionResults < ExecutionResults
+  attr_accessor :context
+  attr_reader :size
+
+  def initialize
+    super
+    @results = Array.new
+    @size = 0
+  end  
+
+  def add(row, column, result)
+    (row - (@results.size - 1)).times{ @results << []} 
+    (column - (@results[row].size - 1)).times{ @results[row] << nil}
+    
+    result.row = row
+    result.column = column
+    @results[row][column] = result
+    @size += 1
+
+    update_stats result
+    result
+  end
+
+  def delete_at(row, column)
+    result = @results[row][column] unless check_index(row, column) == false
+    return nil if result == nil
+
+    unless result.silent
+      @successes -= 1 if result.success?
+      @failures -= 1 if result.failure?
+      @errors -= 1 if result.error?
+      @ignored -= 1 if result.ignored?
+    end
+
+    @results[row][column] = nil
+    @size -= 1
+    result
+  end
+
+  def each
+    @results.each{ |row|
+      row.each{ |result|
+        yield result unless result == nil
+      }
+    }
+  end
+
+  def each_with_index_and_nil
+    @results.each_with_index{ |row, row_idx|
+      row.each_with_index{ |cell, cell_idx|
+        yield cell, row_idx, cell_idx
+      }
+    }
+  end
+
+  def at(row, column)
+    return @results[row][column] unless check_index(row, column) == false
+    nil 
+  end
+
+  def to_s
+    s = ""
+    @results.each{|row|
+      s << "|"
+      row.each{|result|
+        s << sprintf("%25s |", result.class.to_s)
+      }
+      s << "\n"
+    }
+    s[-1] = ""
+    s
+  end
+
+  private
+  def check_index(row, column)
+    return false if row >= @results.size or column >= @results[row].size
+    true
+  end
+
+end
+
+end #module GreenPepper