greenpepper-ruby 0.0.1

data/lib/greenpepper/core.rb

@@ -0,0 +1,152 @@
+=begin
+author: Simon Mathieu (simon.math@gmail.com)
+date: Feburary 20, 2008
+=end
+module GreenPepper
+
+require 'rubygems'
+require 'libxml'
+
+require 'greenpepper/converter'
+require 'greenpepper/argumentparser'
+require 'greenpepper/common/loadpath'
+require 'greenpepper/pass/freetextpass'
+require 'greenpepper/pass/tablepass'
+require 'greenpepper/repository/atlassianrepository'
+require 'greenpepper/writer/consolewriter'
+require 'greenpepper/writer/htmlwriter'
+require 'greenpepper/writer/xmlwriter'
+require 'greenpepper/writer/output'
+require 'greenpepper/logger'
+require 'greenpepper/executionunit'
+require 'greenpepper/pass/greenpepperpass'
+
+$APP_NAME = "GreenPepper"
+$VERSION = 0.1
+
+class GreenPepperCore
+
+  def initialize(log = Logger.new(STDERR))
+    @log = log
+
+    # Disable libXML stderr output
+    LibXML::XML::Error.reset_handler
+  end
+
+=begin
+entry point for the application
+=end
+  def run(args)
+    argument_parser = ArgumentParser.new args
+    execution_context = argument_parser.execution_context
+    @writer_options = argument_parser.writer_context
+    
+    LoadPath.load execution_context[:load_path]
+
+    console_output = execution_context[:console_output] 
+    unless console_output == ""
+      puts console_output
+      @log.log console_output
+      return
+    end
+     
+    begin
+
+      results_array = Array.new
+      table_pass = TablePass.new
+      freetext_pass = FreeTextPass.new
+
+      GreenPepperPass.passes = [freetext_pass, table_pass]
+
+      execution_units = []
+      interpreted_html = read_input_file(execution_context)
+
+      # Don't execute if input file is empty
+      if interpreted_html.strip != ""
+        execution_units, interpreted_html = 
+          GreenPepperPass.interpret interpreted_html, 
+          execution_context[:input_document], @writer_options
+
+        results_array = ExecutionUnit.result_list(execution_units) 
+        if execution_context[:html_results_output] && 
+          !execution_context[:xml_output]
+          interpreted_html = write_results interpreted_html, results_array
+        end
+      end
+
+      console_output = ConsoleOutput.new 
+      console_output.print_output ConsoleWriter.new(results_array).output
+
+      if execution_context[:xml_output]
+        xml_writer = XmlWriter.new interpreted_html 
+        interpreted_html = xml_writer.write_results results_array 
+      end
+
+      output = FileOutput.new execution_context[:output_document]
+      output.print_output interpreted_html 
+      return results_array
+
+    rescue GreenPepperLibXmlError, GreenPepperMalformedTableError => ex
+      @log.log_error "#{ex.to_s}\n #{print_backtrace ex.backtrace}"
+      return -1
+    rescue Exception => ex
+      @log.error "Internal Error."
+      @log.log "#{ex.to_s}\n #{print_backtrace ex.backtrace}"
+      raise ex
+    end
+    return 0
+  end
+
+  private
+
+  def write_results(html, results_array)
+    html_doc = (LibXML::XML::Parser.string html, 
+      :encoding => LibXML::XML::Encoding::UTF_8,
+      :options => LibXML::XML::Parser::Options::NOBLANKS).parse
+
+    all_result = HtmlTableExecutionResults.get_all_results(results_array)
+
+    # We define another XML tree, since <table> is already the node of
+    # html_doc. We can't add another table to the actual one
+    root = LibXML::XML::Parser.string(
+      "<table><tr><td>Successes: #{all_result.successes}</td>" +
+      "<td>Failures: #{all_result.failures}</td>" +
+      "<td>Errors: #{all_result.errors}</td></tr></table>").
+      parse.root
+
+    results = root.copy(true)
+
+    node = html_doc.find_first 'body'
+    node = html_doc.root if node.nil?
+    if node.first?
+      node.first.prev = results
+    else
+      node << results
+    end
+    html_doc.to_s
+  end
+
+  def print_backtrace backtrace
+    result = ""
+    backtrace.each{|s|
+      result << "\t" << s.to_s << "\n"
+    }
+  end
+
+  def read_input_file(execution_context)
+    if execution_context[:repository] != nil
+      repo = AtlassianRepository.new execution_context[:repository]
+      html = repo.load_document execution_context[:input_document]
+    else
+      file_path = execution_context[:input_document]
+      if !File.exists? file_path 
+        raise GreenPepperFileNotFoundError.new(
+          "Cannot open input file : #{execution_context[:input_document]}")
+      end
+
+      html = File.open(file_path, 'r') { |f| f.read } 
+    end
+    html
+   end
+end
+end #module GreenPepper

data/lib/greenpepper/example/collectionexample.rb

@@ -0,0 +1,305 @@
+=begin
+author: Steven Denis (denis.steven@gmail.com)
+    Pascal Ouellet (pas.ouellet@gmail.com)
+date: March 30, 2009
+=end
+
+require 'greenpepper/example/executionresults'
+require 'greenpepper/exception/greenpepperexception'
+require 'greenpepper/example/examplewithfixture'
+require 'greenpepper/example/nameresolver'
+require 'greenpepper/converter'
+
+module GreenPepper
+
+class CollectionExample < ExampleWithFixture
+  attr_reader :data, :headers_array
+
+  FIRST_DATA_ROW = 2
+
+  def initialize(fixture_name)
+    super fixture_name
+    @headers_array = []
+    @data = []
+  end
+
+  def add_row(data)
+    @data.push data
+  end
+
+  def add_headers(headers)
+    @headers_array += headers
+  end
+
+  def add_header(header)
+    @headers_array.push header
+  end
+
+  def do_execute(results, fixture_class)
+    fixture = instantiate_fixture fixture_class
+    
+    if fixture.respond_to? 'query'
+      begin
+        collection = fixture.query
+      rescue
+        results.add FIXTURE_NAME_ROW, FIXTURE_NAME_COLUMN, WriteExceptionExampleResult.new($!)
+        return results
+      end
+    else
+      ex = GreenPepperMissingMethodError.new(
+        "Cannot find method 'query' on fixture #{fixture.class}.")
+      results.add FIXTURE_NAME_ROW, FIXTURE_NAME_COLUMN, WriteExceptionExampleResult.new(ex)
+      return results
+    end
+
+    header_error = false
+    collection_object = collection[FIXTURE_NAME_ROW]
+
+    index_list = [] 
+    @headers_array.each_with_index do |header, header_index|
+
+      if header =='' ||!collection_object.respond_to?(header)
+        error = GreenPepperMissingHeaderError.new(
+          "Cannot find '#{header}' on object '#{fixture.class}'.")
+        results.add HEADER_ROW, header_index, WriteExceptionExampleResult.new(error)
+        index_list << header_index
+      else
+        results.add HEADER_ROW, header_index, NoExampleResult.new
+      end
+    end
+    index_list.each{|index| @headers_array[index] = nil if index != -1}
+
+    collection_data = []
+    collection.each do |collection_element|
+      collection_row = []
+      @headers_array.each do |header|        
+        if header != nil
+          begin
+            field_value = NameResolver.get_instance_field(
+              collection_element, header)
+            collection_row << field_value
+          rescue => error
+            collection_row << error
+          end
+        else
+          collection_row << nil
+        end
+      end
+      collection_data << collection_row
+    end
+    
+    
+    example_data = []
+    @data.each_index do |row_index|
+      example_row = []
+      @headers_array.each_with_index do |header, header_index|
+        if header != nil
+          example_row << TypeConverter.instance.auto_convert_string(
+            collection_object, header, @data[row_index][header_index])
+        else
+          example_row << nil
+        end
+      end
+      example_data << example_row
+    end
+    do_execute_collection(results, example_data, collection_data)
+  end
+  
+end
+
+
+class ListOfExample < CollectionExample
+  def do_execute_collection(results, example_data, collection_data)
+    table_size = [collection_data.size, example_data.size].max
+
+    table_size.times do |row_index|
+      result_compiled = false
+      @headers_array.each_with_index do |header, column_index|
+        if header == nil
+          results.add row_index + FIRST_DATA_ROW, column_index, NoExampleResult.new
+        else
+          if row_index < example_data.size
+            expected_value = example_data[row_index][column_index] 
+          else
+            expected_value = :Surplus
+          end
+
+          if row_index < collection_data.size
+            received_value = collection_data[row_index][column_index]
+          else
+            received_value = :Missing
+          end
+          result, result_compiled = execute_cell(expected_value, received_value, 
+            result_compiled)
+          results.add row_index + FIRST_DATA_ROW, column_index, result
+        end
+      end
+      results.successes += 1 if result_compiled == false
+    end
+    return results
+  end
+  
+  def execute_cell(expected_value, received_value, result_compiled)
+    next_result_compiled = true
+    if result_compiled == false
+      if received_value.is_a? Exception
+        result = WriteExceptionExampleResult.new received_value
+      elsif expected_value == :Surplus
+        result = WriteSurplusExampleResult.new received_value
+      elsif received_value == :Missing
+        result = WriteMissingExampleResult.new
+      elsif (expected_value == received_value) 
+        next_result_compiled = false
+        result = SuccessExampleResult.new true
+      else
+        result = WriteExpectedExampleResult.new expected_value, received_value
+      end
+    else
+      if received_value.is_a? Exception
+        result = WriteExceptionExampleResult.new received_value, true
+      elsif expected_value == :Surplus
+        result = WriteSurplusExampleResult.new received_value, true
+      elsif received_value == :Missing
+        result = WriteMissingExampleResult.new true
+      elsif (expected_value == received_value)
+        result = SuccessExampleResult.new true
+      else
+        result = WriteExpectedExampleResult.new expected_value, received_value, true
+      end
+    end
+
+    return result, next_result_compiled
+  end
+end
+
+class CollectionSetExample < CollectionExample
+  def initialize (fixture_name, found_handler,
+          not_found_handler, remain_handler,
+          error_handler = CollectionHandler::ERROR_HANDLER)
+    super fixture_name
+    @found_handler = found_handler
+    @not_found_handler = not_found_handler
+    @remain_handler = remain_handler
+    @error_handler = error_handler
+  end
+
+  def do_execute_collection(results, example_data, collection_data)
+    collection = collection_data.dup
+    last_row_idx = example_data.size
+
+    example_data.each_with_index do |example_row, row_index|
+      index = collection.index(example_row)
+      if index 
+        @found_handler.call results, example_row, row_index
+        collection.delete_at index 
+      else
+        @not_found_handler.call results, example_row, row_index
+      end
+    end
+
+    collection.each do |remaining_row|
+      if remaining_row.find { |value| value.is_a? Exception}
+        @error_handler.call results, remaining_row, last_row_idx
+      else
+        @remain_handler.call results, remaining_row, last_row_idx
+      end
+      last_row_idx += 1
+    end
+  end
+end
+
+class SetOfExample < CollectionSetExample 
+  def initialize (fixture_name)
+    super fixture_name,
+      CollectionHandler::SUCCESS_HANDLER,
+      CollectionHandler::MISSING_HANDLER,
+      CollectionHandler::SURPLUS_HANDLER
+
+  end
+end
+
+class SupersetOfExample < CollectionSetExample
+  def initialize (fixture_name)
+    super fixture_name,
+      CollectionHandler::SUCCESS_HANDLER,
+      CollectionHandler::IGNORE_HANDLER,
+      CollectionHandler::SURPLUS_HANDLER
+  end
+end
+
+class SubsetOfExample < CollectionSetExample
+  def initialize (fixture_name)
+    super fixture_name,
+      CollectionHandler::SUCCESS_HANDLER,
+      CollectionHandler::MISSING_HANDLER,
+      CollectionHandler::NO_OP_HANDLER
+  end
+end
+
+module CollectionHandler
+  private
+  FIRST_DATA_ROW = 2
+
+  def self.handler(action)
+    return lambda do |results, row, row_index|
+      row.each_with_index do |value, col_index|
+        if col_index == 0
+          results.add row_index + FIRST_DATA_ROW, col_index, action.create(value)
+        else
+          results.add row_index + FIRST_DATA_ROW, col_index, action.create(value, true)
+        end
+      end
+    end
+  end
+
+  class CollectionSuccessResult
+    def self.create(value, silent = false)
+      SuccessExampleResult.new silent
+    end
+  end
+
+  class CollectionSurplusResult
+    def self.create(value, silent = false)
+      WriteSurplusExampleResult.new value, silent
+    end
+  end
+
+  class CollectionMissingResult
+    def self.create(value, silent = false)
+      WriteMissingExampleResult.new silent
+    end
+  end
+
+  class CollectionIgnoredResult
+    def self.create(value, silent = false)
+      NoExampleResult.new silent
+    end
+  end
+
+  public
+  SUCCESS_HANDLER = handler CollectionSuccessResult
+  SURPLUS_HANDLER = handler CollectionSurplusResult
+  MISSING_HANDLER = handler CollectionMissingResult
+  IGNORE_HANDLER  = handler CollectionIgnoredResult
+  NO_OP_HANDLER   = lambda {}
+
+  ERROR_HANDLER = lambda do |results, row, row_index|
+    row.each_with_index do |value, col_index|
+      if col_index == 0
+        if value.is_a? Exception 
+          result = WriteExceptionExampleResult.new(value)
+        else   
+          result = WriteTextExampleResult.new(value)
+        end
+      else
+        if value.is_a? Exception 
+          result = WriteExceptionExampleResult.new value, true
+        else   
+          result = WriteTextExampleResult.new value, true
+        end
+      end
+      results.add row_index + FIRST_DATA_ROW, col_index, result
+    end
+  end
+end
+end #module GreenPepper