greenpepper-ruby 0.0.1

data/lib/greenpepper/pass/freetextpass.rb

@@ -0,0 +1,24 @@
+=begin
+Author: Simon Mathieu (simon.math@gmail.com)
+        Pascal Ouellet (pas.ouellet@gmail.com)
+Date: October 5, 2009
+=end
+
+module GreenPepper
+
+require 'greenpepper/factory/freetextexamplefactory'
+require 'greenpepper/parser/freetextparser'
+require 'greenpepper/writer/freetextwriter'
+
+require 'greenpepper/pass/greenpepperpass'
+
+class FreeTextPass < GreenPepperPass
+  def initialize()
+    parser = FreeTextParser.new
+    factory = FreeTextExampleFactory.new
+    writer = FreeTextWriter.new
+    super(parser, factory, writer)
+  end
+end
+
+end

data/lib/greenpepper/pass/greenpepperpass.rb

@@ -0,0 +1,92 @@
+=begin
+Author: Pascal Ouellet (pas.ouellet@gmail.com)
+Date: October 27, 2009
+=end
+
+
+
+module GreenPepper
+class GreenPepperPass
+ 
+  @@passes = []
+  attr_accessor :writer
+  # TODO Malformed do with table test
+  def initialize(parser, factory, writer)
+    @parser = parser
+    @factory = factory
+    @writer = writer
+    # Force LibXML to keep the line number when parsing
+    LibXML::XML::default_line_numbers = true
+  end
+  
+  def extract_data document, filename
+    # Extract the content of the document
+    execution_units = @parser.extract_content document, filename
+
+    # Build examples from the content
+    i = 0
+    new_execution_units = []
+    while i < execution_units.size
+      content = execution_units[i].content
+      context = execution_units[i].context
+
+      current_unit = i
+      @factory.push_content content
+      i += 1
+      while @factory.need_more_content?
+        
+        if i >= execution_units.size
+          raise GreenPepperMalformedTableError.new(
+            "Can't parse document, one of the table is not formated correctly.")
+        end
+
+        content = @factory.push_content execution_units[i].content
+        context.nb_table +=1 
+        i += 1
+      end
+      example = @factory.build_example
+      execution_units[current_unit].example = example
+      new_execution_units << execution_units[current_unit]
+    end
+    new_execution_units
+  end
+
+  def write document, execution_units, writer_options
+    if execution_units.size > 0
+      document = @writer.write document, execution_units, writer_options
+    end
+    document
+  end
+
+  def self.interpret(document, filename = 'UNKNOWN', writer_options = {})
+    ex_units = []  
+    @@passes.each{|pass| ex_units += pass.extract_data(document, filename)}
+
+    ex_units.sort!{|first, second|first.context.index <=> second.context.index}
+    # Execute examples
+    ex_units.each{ |ex_unit|
+      ex_unit.execute
+    }
+    
+    # Don't write unless we have to
+    pass_it = 0
+    @@passes.each{|pass|
+      temp_units = []
+      ex_units.each{|unit|
+        if pass.writer.support? unit
+          temp_units << unit
+        end
+      }
+
+      document = pass.write(document, temp_units, writer_options)
+    }
+    [ex_units, document]
+  end
+
+  def self.passes=(passes)
+    @@passes = passes
+  end
+end
+
+end
+

data/lib/greenpepper/pass/tablepass.rb

@@ -0,0 +1,38 @@
+=begin
+Author: Simon Mathieu (simon.math@gmail.com)
+        Pascal Ouellet (pas.ouellet@gmail.com)
+Date: October 5, 2009
+=end
+module GreenPepper
+
+require 'greenpepper/parser/htmlparser'
+require 'greenpepper/factory/examplefactory'
+require 'greenpepper/writer/htmlwriter'
+require 'greenpepper/factory/htmlexamplefactory'
+require 'greenpepper/factory/ruleforexamplefactory'
+require 'greenpepper/factory/importexamplefactory'
+require 'greenpepper/factory/setupexamplefactory'
+require 'greenpepper/factory/dowithexamplefactory'
+require 'greenpepper/factory/collectionexamplefactory'
+require 'greenpepper/factory/silentexamplefactory'
+
+require 'greenpepper/pass/greenpepperpass'
+
+class TablePass < GreenPepperPass
+  def initialize()
+    parser = HtmlParser.new
+    factory = HtmlExampleFactory.new([ImportExampleFactory.new,
+      RuleForExampleFactory.new,
+      SetupExampleFactory.new,
+      DoWithExampleFactory.new,
+      ListOfExampleFactory.new,
+      SetOfExampleFactory.new,
+      SubsetOfExampleFactory.new,
+      SupersetOfExampleFactory.new,
+      SilentExampleFactory.new
+    ])
+    writer = HtmlWriter.new
+    super(parser, factory, writer)
+  end
+end
+end

data/lib/greenpepper/railsargumentparser.rb

@@ -0,0 +1,46 @@
+=begin
+author : S�bastien Boisclair (sebastien.boisclair2@usherbrooke.ca)
+date: November 26, 2009
+=end
+module RailsArgumentParser
+
+  def self.extract_args
+    args = {}
+
+    env = extract_single_arg("--env")
+    args[:env] = env
+
+    path = extract_single_arg("--rails")
+    args[:rails] = path
+    args
+  end
+
+  def self.extract_single_arg(argument) 
+    ind = ARGV.index(argument)
+    result = nil
+    if ind != nil
+      if ind + 1 >= ARGV.length
+        puts "Wrong number of arguments.\n" 
+        puts argument + " needs a linked argument."
+        ARGV.delete_at(ind)
+      else
+        result = ARGV[ind+1] 
+        ARGV.delete_at(ind+1)
+        ARGV.delete_at(ind)
+      end
+    end
+    result
+  end
+
+  def self.usage
+    index = ARGV.index('--help')
+    if ARGV.length == 0 || index != nil
+      puts "Usage: ruby greenpepperrails input_document output_document [option]"
+      puts "--rails        path to the rails application"
+      puts "--env        name of the environment of rails application"
+      puts "all the options that can be used with greenpepper.rb can be used " +
+           "with greenpepperrails\n\n"
+    end
+
+  end
+end

data/lib/greenpepper/redpeppertask.rb

@@ -0,0 +1,89 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'libxml'
+require 'rake'
+require 'rake/tasklib'
+require 'net/http'
+require 'cgi'
+require 'greenpepper/greenpepperconfig'
+
+module GreenPepper
+class RedPepperTask < Rake::TaskLib
+  attr_accessor :server, :path, :spec_id, :spec_name
+
+  def initialize(name, http = Net::HTTP)
+    @name = name
+    @http_client = http
+    @path = 'greenpepper/specifications'
+
+    yield self if block_given?
+    load_config
+    define
+  end
+
+  private
+  # Create the tasks defined by this task lib.
+  def define
+    task @name do
+      if @spec_id.nil? && @spec_name.nil?
+        download_all_specs
+      else
+        if @spec_name
+          url = get_url_for_name @spec_name
+          name = @spec_name
+        elsif @spec_id
+          url = get_url_for_id @spec_id
+          name = @spec_id.to_s
+        end
+        page = get_page(url)
+        name = parse_for_name(page)
+      
+        write_page page, name
+      end
+    end
+  end
+
+  def download_all_specs
+    all_ids_string = @http_client.get URI.parse("#{@server}/specifications/all")
+    all_ids_string.split("\n").each do |id|
+      url = get_url_for_id(id)
+      page = get_page(url)
+      name = parse_for_name page
+      write_page page, name
+    end
+  end
+
+  def get_url_for_id id
+    "#{@server}/specifications/spec/#{id}"
+  end
+
+  def get_url_for_name name
+    "#{@server}/specifications/spec/name/#{CGI::escape name}"
+  end
+
+  def get_page url
+    @http_client.get URI.parse(url)
+  end
+
+  def write_page(page, name)
+    filepath = File.join @path, name + '.html'
+    FileUtils.mkdir_p @path if !File.directory?(@path)
+    File.open(filepath, 'w') { |f| f.write page }
+  end
+
+   def parse_for_name page
+     page_parse = (LibXML::XML::HTMLParser.string page).parse
+     name = ""
+     page_parse.find("//title").each {|t| name = t.content}
+     name.strip
+   end
+
+
+  def load_config
+    config = GreenPepperConfig.instance
+    GreenPepperConfig.maybe_set self, "@server", config
+    GreenPepperConfig.maybe_set self, "@path", config
+  end
+end
+end

data/lib/greenpepper/repository/atlassianrepository.rb

@@ -0,0 +1,100 @@
+=begin
+author: Éloise Dubé (eloise.dube@gmail.com)
+date: March 29, 2009
+=end
+module GreenPepper
+
+  require 'cgi'
+  require 'xmlrpc/client'
+  require 'greenpepper/exception/greenpepperexception'
+
+  class AtlassianRepository
+
+    def initialize(uri, server = nil)
+      uri = AtlassianURI.new(uri) if uri.is_a?(String)
+      @uri = uri
+      server = Confluence::Server.new(@uri.url, @uri.handler) unless server
+      @repo = server
+    end
+
+    def load_document(filename)
+      filename = CGI::unescape(filename)
+
+      parse_input_filename filename
+      return @repo.getRenderedSpecification(@uri.username, @uri.password, 
+        [@uri.space, @input_filename, false, true])
+    end
+
+    def parse_input_filename(filename)
+      # format of filename : FILENAME?ATTRIBUTES
+      @file_attributes = Hash.new
+
+      filename_parts = filename.split "?"
+      @input_filename = filename_parts[0]
+      if filename_parts.size > 1
+        attribute_parts = filename_parts[1].split "="
+        @file_attributes[attribute_parts[0]] = attribute_parts[1]
+      end
+    end
+  end
+
+  class AtlassianURI
+    attr_reader :uri, :url, :handler, :space, :username, :password
+    def initialize(uri)
+      @uri = uri
+      uri_parts = @uri.split ";"
+      if uri_parts.size < 2 
+        raise GreenPepperRepositoryError.new("Bad format of URI. " + uri) 
+      end
+
+      success = /(.*)\?handler=(.*)&(.*)#(.*)/ === uri_parts[1]
+      if success == false
+        raise GreenPepperRepositoryError.new(
+          "Can't parse confluence URL")
+      end
+      @url = $1
+      @handler = $2
+      @space = $4
+      attribute_parts = $3.split "="
+
+      @username = ""
+      @password = ""
+
+      if uri_parts.size > 2
+        @username = uri_parts[2]
+        @password = uri_parts[3]
+      end
+    end
+  end
+
+  # A useful helper for running Confluence XML-RPC from Ruby. 
+  # Also takes care of re-logging in if your login times out.
+  #
+  # Source code :
+  # http://confluence.atlassian.com/display/CONFEXT/Confluence4r
+  module Confluence
+    class ServerFactory
+      def create_server(server_url)
+        XMLRPC::Client.new2 server_url
+      end
+    end
+    class Server
+      def initialize(server_url, handler, factory = ServerFactory.new)
+        unless server_url[-11..-1] == "/rpc/xmlrpc"
+          server_url += "/rpc/xmlrpc" 
+        end
+        server = factory.create_server server_url
+        @conf = server.proxy handler
+      end
+
+      def method_missing(method_name, *args)
+        begin
+          @conf.send(method_name, *(args))
+        rescue XMLRPC::FaultException => e
+          raise e.faultString
+        end
+      end
+    end
+  end
+
+end #module GreenPepper

data/lib/greenpepper/writer/consolewriter.rb

@@ -0,0 +1,21 @@
+=begin
+author: Martin Provencher (martin.provencher@usherbrooke.ca)
+date: March 18, 2009
+=end
+module GreenPepper
+
+require 'greenpepper/example/ruleforexample'
+
+class ConsoleWriter
+  def initialize results
+    @results = results
+  end
+
+  def output
+    results = HtmlTableExecutionResults.get_all_results(@results)
+    total = results.successes + results.failures + results.ignored + results.errors
+    "#{total} tests: #{results.successes} right, #{results.failures}" +
+      " wrong, #{results.ignored} ignored, #{results.errors} exception(s)"
+  end
+end
+end #module GreenPepper

data/lib/greenpepper/writer/freetextresult.rb

@@ -0,0 +1,233 @@
+=begin
+author: Simon Mathieu (simon.math@gmail.com)
+date: October 3, 2009
+=end
+module GreenPepper
+
+require 'greenpepper/writer/html'
+require 'greenpepper/writer/result'
+require 'greenpepper/converter'
+require 'cgi'
+
+module KeywordFormat
+  def indent(text)
+    "<div class=\"greenpepper-freetext-indent\">#{text}</div>"
+  end
+  
+  def indent2(text)
+    "<div class=\"greenpepper-freetext-indent2\">#{text}</div>"
+  end
+
+  def newline(text)
+    "<div class=\"greenpepper-freetext\">#{text}</div>"
+  end
+
+  def highlight(color, text)
+    "<font style=\"background-color: #{color};\">#{text}</font>"
+  end
+
+  def yellow_highlight(text)
+    highlight(Html::YELLOW, text)
+  end
+
+  def green_highlight(text)
+    highlight(Html::GREEN, text)
+  end
+  
+  def red_highlight(text)
+    highlight(Html::RED, text)
+  end
+
+  def grey_highlight(text)
+    highlight(Html::GREY, text)
+  end
+
+  def error(error)
+    res = indent yellow_highlight("#{error.class}: " + 
+      "#{CGI::escapeHTML error.to_s}")
+    if error.backtrace
+      res += '<hr/>'
+      error.backtrace.each { |step|
+        res << indent2(yellow_highlight(CGI::escapeHTML(step)))
+      }
+    end
+    res
+  end
+end
+
+class GivenSuccess < ExampleResult
+  def write(action)
+    action
+  end
+
+  def success?
+    true
+  end
+end
+
+class WhenSuccess < ExampleResult
+  def write(action)
+    action
+  end
+
+  def success?
+    true
+  end
+end
+
+class ThenResults < ExampleResult
+  include KeywordFormat
+  attr_accessor :expectations
+
+  def initialize(regex, expectations)
+    @regex, @expectations = regex, expectations
+  end
+
+  def write(action)
+    expected_lines = []
+    match_data = @regex.match action
+    i = match_data.size - 1
+    while i > 0
+      start_index = match_data.offset(i)[0]
+      end_index = match_data.offset(i)[1]
+      
+      # Type conversion of expected and received value
+      converter = TypeConverter.instance
+      expected = converter.format_object(match_data[i],
+        @expectations[i-1].expected)
+      received = converter.format_object(match_data[i],
+        @expectations[i-1].received)
+
+      # Highlight match
+      action = action[0...start_index] + 
+        then_highlight(expected, 
+        @expectations[i-1].check_result) + 
+        action[end_index..-1]
+
+      # Write expected lines for failures
+      unless @expectations[i-1].check_result
+        expected_lines << indent( 
+          red_highlight("Expected value was #{expected}, " +
+          "but #{received} was received"))
+      end
+      i -= 1
+    end
+
+    expected_lines.reverse.each do |line|
+      action += line
+    end
+
+    action
+  end
+
+  def then_highlight(string, result)
+    result ? green_highlight(string) : red_highlight(string)
+  end
+
+  def update_stats(results)
+    @expectations[0..-1].each do |exp|
+      exp.check_result ? results.add_success : results.add_failure
+    end
+  end
+end
+
+class AskSuccess < ExampleResult
+  include KeywordFormat
+  attr_accessor :answer
+
+  def initialize(answer)
+    @answer = answer
+  end
+
+  def write(action)
+    action + indent("Answer: " + grey_highlight(@answer))
+  end
+
+  def success?
+    true
+  end
+end
+
+class CheckSuccess < ExampleResult
+  include KeywordFormat
+
+  def write(action)
+    green_highlight action
+  end
+
+  def update_stats(results)
+    results.add_success
+  end
+
+  def success?
+    true
+  end
+end
+
+class HeaderSuccess < ExampleResult
+  def initialize(fixture_name)
+    @fixture_name = fixture_name
+  end
+
+  def write(action)
+    "Scenario: #{@fixture_name}"
+  end
+
+  def success?
+    true
+  end
+end
+
+class KeywordError < ExampleResult
+  include KeywordFormat
+  def update_stats(results)
+    results.add_error
+  end
+
+  def error?
+    true
+  end
+end
+
+class ActionError < KeywordError
+  attr_reader :exception
+
+  def initialize(exception)
+    @exception = exception
+  end
+
+  def write(action)
+    newline(yellow_highlight(action)) + 
+      error(@exception)
+  end
+end
+
+class HeaderError < KeywordError
+  def initialize(fixture_name, error)
+    @fixture_name = fixture_name
+    @error = error
+  end
+
+  def write(action)
+    "Scenario: " + yellow_highlight(@fixture_name) + 
+      indent(error(@error))
+  end
+end
+
+class CheckFailure < ExampleResult
+  include KeywordFormat
+
+  def write(action)
+    red_highlight action
+  end
+
+  def update_stats(results)
+    results.add_failure
+  end
+
+  def failure?
+    true
+  end
+end
+
+end