greenpepper-ruby 0.0.1

data/lib/greenpepper/writer/freetextwriter.rb

@@ -0,0 +1,44 @@
+=begin
+author: Simon Mathieu (simon.math@gmail.com) 
+date: October 3, 2009 
+=end
+
+module GreenPepper
+
+require 'rubygems'
+require 'libxml'
+
+require 'greenpepper/writer/freetextresult'
+require 'greenpepper/parser/freetextparser'
+require 'greenpepper/parser/scenario'
+
+class FreeTextWriter
+  include KeywordFormat
+
+  def support? execution_unit 
+    execution_unit.result.is_a? FreeTextExecutionResults 
+  end
+  # Write the results
+  # Returns a string of the document
+  def write(html_doc, execution_units, write_options ={})
+    
+    html_results = []
+    execution_units.each{ |unit|
+        html_results << example_to_html(unit.example, unit.result)
+    }
+
+    # Use the parser to replace the old scenario with the new one
+    parser = FreeTextParser.new
+    parser.replace_scenarios html_doc, html_results
+  end
+
+  # Visible for testing
+  def example_to_html(ex, results)
+    res = newline(results[0].write(nil))
+    results[1..-1].each_with_index{ |result, index|
+      res += indent(result.write(ex.actions[index]))
+    }
+    res
+  end
+end
+end

data/lib/greenpepper/writer/html.rb

@@ -0,0 +1,14 @@
+=begin
+author: Pascal Ouellet (pas.ouellet@gmail.com)
+date: March 17, 2009
+=end
+module GreenPepper
+
+module Html
+  # HTML Hex colors
+  RED = "#F08080"
+  YELLOW = "#F0E68C"
+  GREEN = "#98FB98"
+  GREY ="#D3D3D3"
+end
+end #module GreenPepper

data/lib/greenpepper/writer/htmldocwriter.rb

@@ -0,0 +1,82 @@
+=begin
+author: Simon Mathieu (simon.math@gmail.com)
+date: March 13, 2009
+=end
+module GreenPepper
+
+require 'rubygems'
+require 'libxml'
+require 'greenpepper/writer/htmlruleforwriter'
+require 'greenpepper/writer/htmlimportwriter'
+require 'greenpepper/writer/htmlsetupwriter'
+require 'greenpepper/writer/htmldowithwriter'
+require 'greenpepper/writer/htmlcollectionwriter'
+require 'greenpepper/writer/nullwriter'
+
+class HtmlDocumentWriter
+  attr_reader :modified_doc
+  def initialize(base_html)
+    @html_doc = (LibXML::XML::HTMLParser.string base_html, 
+           :encoding => LibXML::XML::Encoding::UTF_8,
+           :options => LibXML::XML::HTMLParser::Options::NOBLANKS).parse
+    @table_index = 0
+    @modified_doc = ""
+    @tables = @html_doc.find '//table'
+  end
+
+  def write(results)
+    table = @tables[@table_index]
+    w = create_writer results, table
+    @modified_doc = (w.write results)
+    @modified_doc = @modified_doc.doc.root.to_s unless @modified_doc == nil
+
+    @table_index += w.table_count
+    @modified_doc
+  end
+
+  def write_results(all_results)
+    stats_doc = ""
+
+    # We define another XML tree, since <table> is already the node of
+    # html_doc. We can't add another table to the actual one
+    stats = LibXML::XML::Parser.string(
+      "<table><tr><td>Successes: #{all_results.successes}</td>" +
+      "<td>Failures: #{all_results.failures}</td>" +
+      "<td>Errors: #{all_results.errors}</td></tr></table>").
+      parse.root.copy(true)
+      
+
+    node = @html_doc.find_first 'body'
+    node = @html_doc.root if node == nil
+    if node.first?
+      node.first.prev = stats
+    else
+      node << stats
+    end
+    @modified_doc = @html_doc.to_s
+  end
+
+  private
+  def create_writer(results, table)
+    # TODO: Why is doesn't this create an exception? None of those class exist
+    # anymore.
+    if results.class == RuleForExampleExecutionStats
+      row_modifier = HtmlRuleForWriter.create_row_modifier 
+      w = HtmlRuleForWriter.new table, row_modifier
+    elsif results.class == ImportExampleExecutionStats
+      row_modifier = HtmlImportWriter.create_row_modifier 
+      w = HtmlImportWriter.new table, row_modifier
+    elsif results.class == SetupExampleExecutionStats
+       row_modifier = HtmlSetupWriter.create_row_modifier 
+      w = HtmlSetupWriter.new table, row_modifier
+    elsif results.class == DoWithExampleExecutionStats
+      w = HtmlDoWithWriter.new table
+    elsif results.class == CollectionExampleExecutionStats
+      row_modifier = HtmlCollectionWriter.create_row_modifier 
+      w = HtmlCollectionWriter.new table, row_modifier 
+    else
+      w = NullWriter.new table
+    end
+  end
+end
+end #module GreenPepper

data/lib/greenpepper/writer/htmlresult.rb

@@ -0,0 +1,192 @@
+=begin
+author: Martin Provencher (martin.provencher@usherbrooke.ca)
+date: April 25, 2009
+=end
+module GreenPepper
+
+require 'greenpepper/writer/html'
+require 'greenpepper/exception/greenpepperexception'
+require 'greenpepper/writer/result'
+
+class HtmlExampleResult < ExampleResult
+  attr_accessor :row, :column
+
+  def write(cell, options = {})
+    unless cell.instance_of? LibXML::XML::Node
+      raise GreenPepperArgumentError.new 
+    end
+    cell
+  end
+end
+
+class NoExampleResult < HtmlExampleResult
+end
+
+class WriteTextExampleResult < HtmlExampleResult
+  def initialize(result, silent=false)
+    super(silent)
+    @result = result
+  end
+
+  def write(cell, options = {})
+    cell.content = "" if cell.content == " "
+    cell = super(cell, options)
+    cell << @result
+    cell
+  end
+end
+
+class SuccessExampleResult < HtmlExampleResult
+  def success?
+    true
+  end
+
+  def write(cell, options = {})
+    cell = super(cell, options)
+    cell["style"] = "background-color: #{Html::GREEN}"
+    cell
+  end
+end
+
+class FailureExampleResult < HtmlExampleResult
+  def failure?
+    true
+  end
+
+  def write(cell, options = {})
+    cell = super(cell, options)
+    cell["style"] = "background-color: #{Html::RED}"
+    cell
+  end
+end
+
+class ErrorExampleResult < HtmlExampleResult
+  def error?
+    true
+  end
+
+  def write(cell, options = {})
+    cell = super(cell, options)
+    cell["style"] = "background-color: #{Html::YELLOW}"
+    cell
+  end
+end
+
+class IgnoredExampleResult < HtmlExampleResult 
+  def ignored?
+    true
+  end
+
+  def write(cell, options = {})
+    cell["style"] = "background-color: #{Html::GREY}"
+    cell
+  end
+end
+
+class WriteIgnoredExampleResult < WriteTextExampleResult
+  def ignored?
+    true
+  end
+
+  def write(cell, options = {})
+    cell = super(cell, options)
+    cell["style"] = "background-color: #{Html::GREY}"
+    cell
+  end
+end
+
+class WriteSucessExampleResult < SuccessExampleResult
+  def write(cell, options = {})
+    cell = super(cell, options)
+    cell << "Success"
+  end
+end
+
+class WriteFailExampleResult < FailureExampleResult
+  def write(cell, options = {})
+    cell = super(cell, options)
+    cell << "Fail"
+  end
+end
+
+class WriteExpectedExampleResult < FailureExampleResult
+  attr_reader :expected, :received
+  def initialize(expected, received, silent=false)
+    super(silent)
+    @expected = expected
+    @received = received
+  end
+
+  def write(cell, options = {})
+    cell = super(cell, options)
+    
+    cell.children.each{|current_node|current_node.remove!}
+    cell << LibXML::XML::Node.new_text("")
+
+    expected_node = LibXML::XML::Node.new "b", "Expected: "
+    cell << expected_node
+    cell << @expected 
+
+    received_node = LibXML::XML::Node.new "b", " Received: "
+    cell << received_node
+    cell << @received 
+  end
+end
+
+class WriteExceptionExampleResult < ErrorExampleResult
+  attr :exception
+
+  def initialize(exception, silent=false)
+    super(silent)
+    @exception = exception
+  end
+
+  def write(cell, options = {})
+    cell = super(cell, options)
+
+    cell.content = "#{@exception.class}: #{@exception.to_s}"
+    if @exception.backtrace && !options[:no_exception_stack]
+      cell << LibXML::XML::Node.new('hr')
+      @exception.backtrace.each { |step|
+        cell << step
+        cell << LibXML::XML::Node.new('br')
+      }
+    end
+    cell
+  end
+end
+
+class WriteMissingExampleResult < FailureExampleResult
+  def write(cell, options = {})
+    super(cell, options)
+
+    missing = LibXML::XML::Node.new('i')
+    missing << "Missing "
+
+    content = cell.content
+
+    cell.content = ""
+    cell << missing
+    cell << content
+  end
+end
+
+class WriteSurplusExampleResult < FailureExampleResult
+  attr_reader :value
+  def initialize(value, silent=false)
+    super(silent)
+    @value = value
+  end
+
+  def write(cell, options = {})
+    super(cell, options)
+    surplus = LibXML::XML::Node.new('i')
+    surplus << "Surplus "
+
+    cell.content = ""
+    cell << surplus
+    cell << @value
+  end
+end
+
+end #module GreenPepper

data/lib/greenpepper/writer/htmlwriter.rb

@@ -0,0 +1,112 @@
+=begin
+author: Martin Provencher (martin.provencher@usherbrooke.ca)
+date: April 25, 2009
+=end
+module GreenPepper
+
+require 'rubygems'
+require 'libxml'
+require 'greenpepper/example/executionresults'
+require 'greenpepper/context/htmlcontext'
+require 'greenpepper/parser/table'
+
+class HtmlWriter
+  attr_reader :execution_units
+
+  def initialize
+  end
+
+  def output
+    @html_doc.to_s
+  end
+
+  def support? execution_unit 
+    execution_unit.result.is_a? HtmlTableExecutionResults 
+  end
+
+  def load_document(base_html, execution_units, write_options = {})
+    @html_doc = (LibXML::XML::HTMLParser.string base_html, 
+      :encoding => LibXML::XML::Encoding::UTF_8,
+      :options => LibXML::XML::HTMLParser::Options::NOBLANKS).parse
+    @execution_units = execution_units
+    @tables = @html_doc.find('//table').to_a
+    @write_options = write_options
+
+    nb_results_table = 0
+    @execution_units.each{ |unit|
+      nb_results_table += unit.context.nb_table
+    }
+
+    if @tables.size != nb_results_table
+      raise "Execution results doesn't have the same number of html " +
+        "table than the file"
+    end
+  end
+
+  def write(base_html, execution_units, write_options = {})
+
+    load_document(base_html, execution_units, write_options)
+
+    @execution_units.each{ |unit|
+      all_example_table = []
+
+      @tables[unit.context.first_table_index, unit.context.nb_table].each{
+        |table|
+        all_example_table << table
+      }
+      write_results_to_html all_example_table, unit.result
+    }
+
+    @html_doc.to_s
+  end
+
+  private
+  def write_results_to_html(tables, result)
+    rows = []
+    tables.each{ |table|
+      rows += table.find('.//tr').to_a
+    }
+
+    result.each{ |result|
+      missing_row = result.row - (rows.size-1)
+      if missing_row > 0
+        unless rows.size > 0
+          raise GreenPepperMalformedTableError.new(
+            "Error : Example without row")
+        end
+        copy_row = rows[-1].copy true
+
+        missing_row.times {
+          new_row = LibXML::XML::Node.new rows[-1].name
+          copy_row.each_element{ |cell| 
+            new_row << LibXML::XML::Node.new(cell.name)
+          }
+
+          rows[-1].parent << new_row
+          rows << new_row
+        }
+      end
+
+      cells = rows[result.row].find('.//td|.//th').to_a
+
+      missing_cell = result.column - (cells.size-1)
+      if missing_cell > 0
+        unless cells.size > 0
+          raise GreenPepperMalformedTableError.new(
+            "Error : Example without cell") 
+        end
+        copy_cell = cells[-1].copy true
+
+        missing_cell.times{
+          new_cell = LibXML::XML::Node.new cells[-1].name
+
+          cells[-1].parent << new_cell
+          cells << new_cell
+        }
+      end
+
+      result.write cells[result.column], @write_options
+    }
+  end
+end
+end #module GreenPepper

data/lib/greenpepper/writer/output.rb

@@ -0,0 +1,26 @@
+=begin
+author: Martin Provencher(martin.provencher@usherbrooke.ca)
+date: Mars 4, 2009
+=end
+module GreenPepper
+
+class FileOutput
+  def initialize(output_document)
+    @output_document = output_document
+  end
+
+  def print_output(result)
+    dir = File.dirname @output_document
+    Dir.mkdir(dir) unless File.exists? dir
+    File.open(@output_document, "w") { |f| f.write result }
+  end    
+end
+
+class ConsoleOutput
+  def print_output(result)
+    puts result
+    result
+  end    
+end
+
+end #module GreenPepper