greenpepper-ruby 0.0.1

data/bin/greenpepperize

@@ -0,0 +1,71 @@
+#!/usr/bin/env ruby
+
+# Greenpepperize the folder by deploying rake tasks
+require 'fileutils'
+
+module GreenPepper
+  module Deploy
+    FOLDERS = ["greenpepper/specifications", "greenpepper/results",
+      "greenpepper/fixtures", "lib/tasks"]
+    
+    def self.deploy
+      no_argument_error if ARGV.size != 1
+      deploy_path = File.expand_path ARGV[0]
+      inexistant_path_error if !File.exists? deploy_path
+      return if !confirm? deploy_path
+
+      gem_data_dir = File.join(File.dirname(__FILE__), '..', 'data')
+
+      # Create folders
+      FOLDERS.each{ |folder| FileUtils.mkdir_p File.join(deploy_path, folder)}
+
+      # Deploy files
+      FileUtils.cp File.join(gem_data_dir, 'greenpepper.rake'),
+        File.join(deploy_path, 'lib/tasks')
+      FileUtils.cp File.join(gem_data_dir, 'helper.rb'), 
+        File.join(deploy_path, 'greenpepper')
+
+      print_info
+    end
+
+    private
+    def self.confirm? path
+      puts "Do you want to deploy GreenPepper to \"#{path}\"? [y/n]"
+      begin
+        answer = STDIN.gets.chomp
+      end while answer != "y" && answer != "n"
+      answer == "y" ? true : false
+    end
+
+    def self.no_argument_error
+      puts "Invalid argument specified."
+      print_usage
+      exit 1
+    end
+    
+    def self.inexistant_path_error
+      puts "Inexistant path specified."
+      print_usage
+      exit 1
+    end
+
+    def self.print_usage
+      puts "usage: greenpepperize PATH"
+    end
+
+    def self.print_info
+      puts "The directory has been greenpeperized.\n\n" +
+        "The following rake tasks are now available: \n" +
+        " gp:all [name=\"spec\"]      - Download and run one or all" +
+        " specifications\n" +
+        " gp:download [name=\"spec\"] - Download one or all specifications" +
+        " from RedPepper server\n" +
+        " gp:run [name=\"spec\"]      - Execute one or all specifications" +
+        " from greenpepper/specification\n\n" +
+        "The greenpepper/helper.rb file can be used to configure the tasks.\n"
+    end
+  end
+end
+
+GreenPepper::Deploy.deploy
+exit 0

data/bin/greenpepperrails

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+=begin
+author : S�bastien Boisclair (sebastien.boisclair2@usherbrooke.ca)
+date: November 26, 2009
+=end
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), "../lib")
+$LOAD_PATH << File.join(File.dirname(__FILE__), "../bin")
+
+require 'rubygems'
+require 'greenpepper/railsargumentparser'
+require 'greenpepper/freetext'
+args = RailsArgumentParser.extract_args
+
+if !args[:env]
+  RAILS_ENV = "test"
+else
+  RAILS_ENV = args[:env] 
+end
+
+if args[:rails]
+  require File.join(args[:rails], 'config/environment.rb')
+  requires = Dir.glob File.join(args[:rails], "greenpepper", "fixtures", 
+   "*.rb")
+  requires.each { |req| require req }
+end
+
+index = ARGV.index('--help')
+if ARGV.length == 0 || index != nil
+  RailsArgumentParser.usage
+end
+
+load 'greenpepperruby'

data/bin/greenpepperruby

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+=begin
+author : Martin Provencher (martin.provencher@usherbrooke.ca)
+date: March 11, 2009
+=end
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), "../lib")
+$LOAD_PATH << File.join(File.dirname(__FILE__), "../../common")
+
+require 'greenpepper/core.rb'
+
+core = GreenPepper::GreenPepperCore.new
+ret = core.run ARGV
+
+exit(ret) if ret.is_a? Fixnum

data/data/greenpepper.rake

@@ -0,0 +1,37 @@
+# Tasks to download and execute GreenPepper specifications against the Rails
+# application. Tasks configuration file is located in greenpepper/helper.rb
+require 'greenpepper/greenpeppertask'
+require 'greenpepper/redpeppertask'
+
+# Load the configuration file
+load 'greenpepper/helper.rb'
+
+# Global GreenPepper namespace
+namespace :gp do
+
+  # Download and run all specifications
+  task :all do
+    Rake::Task["gp:download"].execute
+    Rake::Task["gp:run"].execute
+  end
+
+  # Download all the specifications hosted by the RedPepper server defined
+  # in the config file
+  GreenPepper::RedPepperTask.new(:download) do |t|
+    # Get the spec name, if any
+    t.spec_name = ENV['name']
+  end
+
+  # Execute all specifications in greenpepper/specifications
+  GreenPepper::GreenPepperTask.new(:run) do |t|
+    # Require Rails environment
+    require "config/environment"
+
+    # Require fixtures in greenpepper/fixtures
+    requires = Dir.glob File.join("greenpepper", "fixtures", "*.rb")
+    requires.each { |req| require req }
+    
+    # Get the spec name, if any
+    t.spec_name = ENV['name'] + '.html'
+  end
+end

data/data/helper.rb

@@ -0,0 +1,32 @@
+# GreenPepper rake tasks configuration file. Change this file to customize
+# the behavior of the gp:all, gp:download and gp:run tasks.
+require 'greenpepper/greenpepperconfig'
+
+# Include the freetext DSL. 
+require 'greenpepper/freetext'
+
+GreenPepper::GreenPepperConfig.configure do |config|
+  
+  ### RedPepper ###
+  #################
+  # Defines the RedPepper server URL from which to fetch the specifications
+  config.server = "http://greenpepper.kicks-ass.org/server"
+
+  # The directory to save the downloaded specifications to.
+  # Default : "greenpepper/specifications"
+  #config.path = "path/specifications"
+  
+  ### Specification ###
+  #####################
+  # The directory from which to execute the specifications
+  # Default : "greenpepper/specifications"
+  #config.spec_dir = "/my/spec/dir"
+
+  # The execution result directory.
+  # Defaut : "greenpepper/results"
+  #config.result_dir = "path/results"
+  
+  # The path of the GreenPepper core. If not specified, it searches for it in
+  # the ruby loadpath.
+  #config.greenpepper_path = "/my/core/path"
+end

data/data/tags

@@ -0,0 +1,6 @@
+!_TAG_FILE_FORMAT	2	/extended format; --format=1 will not append ;" to lines/
+!_TAG_FILE_SORTED	1	/0=unsorted, 1=sorted, 2=foldcase/
+!_TAG_PROGRAM_AUTHOR	Darren Hiebert	/dhiebert@users.sourceforge.net/
+!_TAG_PROGRAM_NAME	Exuberant Ctags	//
+!_TAG_PROGRAM_URL	http://ctags.sourceforge.net	/official site/
+!_TAG_PROGRAM_VERSION	5.7	//

data/lib/greenpepper/argumentparser.rb

@@ -0,0 +1,161 @@
+=begin
+author: Martin Provencher (martin.provencher@usherbrooke.ca)
+date: March 24, 2008
+=end
+module GreenPepper
+
+class ArgumentParser
+
+  attr_reader :execution_context, :writer_context
+
+  def initialize(args)
+    @execution_context = {:html_results_output => true,
+                          :xml_output          => false,
+                          :console_output      => "",
+                          :repository          => nil,
+                          :load_path           => Array.new,
+                          :input_document      => nil,
+                          :output_document     => nil}
+
+    @writer_context = {:no_exception_stack => false}
+
+    if args.empty?
+      @execution_context[:console_output] = ArgumentParser.usage
+    else
+      @parsed = parse_args args
+    end
+  end
+  
+  def parse_args(argv)
+    argv = [argv] unless argv.is_a? Array
+    args = argv.dup
+    arg_regex = /^\s*-.+\s*/
+    return false if args.size < 1
+
+    while arg = args.shift
+      if arg =~ arg_regex
+        case arg
+        when "--no-html-results"  #Not in doc
+          @execution_context[:html_results_output] = false
+        when "--no-exception-stack"
+          @writer_context[:no_exception_stack] = true
+        when "--help"
+          @execution_context[:console_output] = ArgumentParser.usage
+          return
+        when "--version"
+          @execution_context[:console_output] =
+            "#{$APP_NAME} version : #{$VERSION}"
+          return
+        when "--xml"
+          @execution_context[:xml_output] = true
+          @execution_context[:output_document] = args.shift unless
+            args[0] =~ arg_regex || args.size == 0
+          #Output to the specified output. If no specified output,
+          #outputting to INPUTFILENAME_output.xml
+        when "-r"
+          if args[0] =~ arg_regex || args.size == 0
+            @execution_context[:console_output] = ArgumentParser.usage
+            return
+          else
+            @execution_context[:repository] = args.shift
+          end
+        when "--loadpath"
+          if args[0] =~ arg_regex || args.size == 0
+            @execution_context[:console_output] = ArgumentParser.usage
+            return
+          else
+            while !(args[0] =~ arg_regex || args.size == 0)
+              @execution_context[:load_path] << args.shift
+            end
+          end
+            
+        else
+          @execution_context[:console_output] =
+            "#{arg.to_s} option is not recognize\n#{ArgumentParser.usage}"
+          return
+        end
+      else
+        if @execution_context[:input_document].nil?
+          @execution_context[:input_document] = arg
+        elsif @execution_context[:output_document].nil?
+          @execution_context[:output_document] = arg
+        end
+      end
+    end 
+
+    if (@execution_context[:input_document].nil?)
+      @execution_context[:console_output] = ArgumentParser.usage
+      return
+    else
+      if(@execution_context[:output_document].nil?)
+        extension_name = File.extname @execution_context[:input_document]
+        base_name = File.basename @execution_context[:input_document]
+        base_name.gsub!(extension_name, "")
+        extension_name = '.xml' if @execution_context[:xml_output]
+
+        @execution_context[:output_document] =
+          "#{base_name}_output#{extension_name}"
+      end
+    end
+  end
+  
+  def self.usage
+    str =  "Usage: ruby greenpepper.rb input_document "
+    str += "[ouput_document] [options]\n\n"
+    str += "--help          Display the help.\n"
+    str += "--version         Output version information.\n"
+    str += "-r CLASS;ARGS         The url of the repository of the" + 
+    str += " specifications.\n" 
+    str += "--no-html-results     This option will not print result in output.\n"
+    str += "--xml [output_document]   Generate XML report (default is plain text)."
+    str += " If output_document is specified, the xml report will outputed"
+    str += " in the specified file.\n"
+    str += "--no-exception-stack  Disable outputting of exception stack when" 
+    str += " execution exception are raised.\n"
+    str += "--load_path path1 [pathX] List of path to include for execution."
+    str
+  end
+
+=begin
+This doc came from greenpeppersoftware.com ... this will be needed to fill self.usage
+
+Usage: greenpepper [options] input [ouput]
+Run the input specification and produce a report in output file or in directory specified by -o
+
+Options:
+Ignore :-l, --locale LANG       Set application language (en, fr, ...)
+#-f, --sud CLASS;ARGS      Use CLASS as the system under development and instantiate it with ARGS
+#-o DIRECTORY          Produce reports in DIRECTORY (defaults to current directory)
+#-r CLASS;ARGS         Use CLASS as the document repository and instantiate it with ARGS (defaults to com.greenpepper.repository.FileSystemRepository)
+#-s, --suite           Run a suite rather than a single test (output must refer to a directory)
+-t SECTIONS           Filter input specification to only execute SECTIONS (comma separated list of sections)
+-a ARGS             Semicolon seperated list of assemblies fullName
+
+Ignore : --selector CLASS      Use CLASS as the interpreter selector (defaults to com.greenpepper.document.GreenPepperInterpreterSelector)
+#  --lazy          Set greenpepper in lazy mode for document execution
+#  --xml           Generate XML report (defaults to plain)
+#  --help          Display this help and exit
+#  --version         Output version information and exit
+Don't implement for now :   --debug           Enable debug mode
+#  --stop          Stop the execution of the specification on the first failure
+
+When no option is given,  GreenPepper defaults to the following rules:
+
+  * Input is a single specification, not a suite
+  * If output is not specified, reports are produced in the current directory
+  * Report is in plain format
+  * The operating system locale is used
+Not in story  * The input specification is not filtered
+  * The specification file must be located on the file system
+  * Fixtures are created using the default built-in mechanism
+  * Tables use  GreenPepper formalism
+  * Lazy mode is disabled
+  * Debug mode is disabled
+  * Will not stop the execution on first failure
+
+Any of the rules above can be overridden using command line switches.
+  
+=end 
+end
+
+end #module GreenPepper

data/lib/greenpepper/common/loadpath.rb

@@ -0,0 +1,7 @@
+module LoadPath
+  def self.load(paths)
+    paths.reverse.each{ |path|
+      $LOAD_PATH.unshift(path) unless $LOAD_PATH.include?(path)
+    }
+  end
+end

data/lib/greenpepper/context/htmlcontext.rb

@@ -0,0 +1,26 @@
+=begin
+author: Martin Provencher (mprovencher86@gmail.com)
+date: September 3, 2009
+=end
+
+module GreenPepper
+
+class ExampleContext
+  attr_accessor :index
+
+  def initialize(index = 0)
+    @index = index
+  end
+end
+
+class HtmlContext < ExampleContext
+  attr_accessor  :nb_table, :first_table_index
+
+  def initialize(index = 0, first_table_index = 0, nb_table = 1)
+    super(index)
+    @first_table_index = first_table_index
+    @nb_table = nb_table
+  end
+end
+
+end #module GreenPepper

data/lib/greenpepper/converter.rb

@@ -0,0 +1,347 @@
+=begin
+authors: Simon Mathieu (simon.math@gmail.com)
+     Sebastien Boisclair (sebboisclair@gmail.com)
+date: March 3, 2009
+=end
+module GreenPepper
+
+require 'singleton'
+require 'date'
+require 'greenpepper/grammar/arrayparser'
+
+class TypeConverter
+  include Singleton
+
+  def initialize
+    @converters = []
+  end
+
+  def convert_string(string)
+    @converters.each { |type|
+      if type.can_parse? string
+        return type.convert.call(string)
+      end
+    }
+    string
+  end
+  
+  def format_object(expected_string_format, object)
+    @converters.each { |type|
+      if type.can_parse? expected_string_format
+        return type.format.call(object, expected_string_format)
+      end
+    }
+    object.to_s
+  end
+
+  #Encapsulate all the type conversion logic for fixtures
+  def auto_convert_string(fixture, name, string)
+    parse_f = conversion_func name
+    if fixture.respond_to?(parse_f)
+      if string.is_a? Array
+        return fixture.send(parse_f, *string)
+      else
+        return fixture.send(parse_f, string)
+      end
+    else
+      if string.is_a? Array
+        return string.collect{|s| convert_string s}
+      else
+        return convert_string(string)
+      end
+    end
+  end
+
+  def auto_convert_object(fixture, name, expected_format, object)
+    format_f = format_func name
+    if fixture.respond_to?(format_f)
+      return fixture.send(format_f, object)
+    else
+      return format_object(expected_format, object)
+    end
+  end
+
+  def add_conversion_type(type)
+     @converters << type 
+  end
+
+  private
+  def conversion_func(name)
+    ("parse_" + NameResolver.format_column_name(name)).to_sym
+  end
+  
+  def format_func(name)
+    ("format_" + NameResolver.format_column_name(name)).to_sym
+  end
+end
+
+class TypeBase
+  def TypeBase.inherited(subclass)
+    TypeConverter.instance.add_conversion_type subclass 
+  end
+
+  def self.can_parse?(str)
+    regex === str
+  end
+  
+  def self.format
+    Proc.new{|object,expected_format| object.to_s}
+  end
+  
+end
+
+class ErrorType < TypeBase
+
+  def self.regex
+    /^[\s]*error[\s]*$/i
+  end
+
+  def self.convert
+    Proc.new{|s| Exception.new}
+  end
+  
+  def self.format
+    Proc.new{|object, expected_format|
+      if object.is_a? Exception 
+        expected_format 
+      else
+        object.to_s
+      end
+    }
+  end
+end
+
+class IntType < TypeBase
+
+  def self.regex
+    /^\s*-?[0-9]+\s*$/
+  end
+
+  def self.convert
+    Proc.new{|s| s.to_i}
+  end
+end
+
+
+class FloatType < TypeBase
+
+  def self.regex
+    /^\s*-?[0-9]*\.[0-9]+\s*$/
+  end
+
+  def self.convert
+    Proc.new{|s| s.to_f}
+  end
+
+  def self.format
+    Proc.new{ |b, expected_format|
+      if expected_format.match /^.[0-9]+$/
+        b.to_s[1..-1]
+      else
+        b.to_s
+      end
+    }
+  end
+end
+
+class BoolType < TypeBase
+  def self.regex
+    /^\s*(true|false|yes|no)\s*$/i
+  end
+
+  def self.convert
+    Proc.new{ |s| 
+      (/true|yes/i =~ s) != nil
+    }
+  end
+  
+  def self.format
+    Proc.new{ |b,expected_format|
+      yes = "yes"
+      no = "no"
+      
+      case expected_format
+        when /^True|False$/
+          b.to_s.capitalize
+        when /^yes|no$/
+          b ? yes : no
+        when /^Yes|No$/
+          b ? yes.capitalize : no.capitalize
+        else
+          b.to_s
+      end
+    }
+  end
+end
+
+class BlankStringType < TypeBase
+  def self.regex
+    /^\s*blank\s*$/i
+  end
+
+  def self.convert
+    Proc.new{ |s| 
+      "" 
+    }
+  end
+  
+  def self.format
+    Proc.new{ |s,expected_format| 
+      expected_format
+    }
+  end
+end
+
+class NilType < TypeBase
+  def self.regex
+    /^\s*(nil|null|none|nothing|\s*)\s*$/i
+  end
+
+  def self.convert
+    Proc.new{ |s| 
+      nil
+    }
+  end
+  
+  def self.format
+    Proc.new{ |n,expected_format|
+      #The server return some weird unicode char when  a cell is 
+      #empty and since ruby 1.8 doesn't like unicode in regex, we 
+      #have to do this ugly path here.
+      if /^\s*$/ === expected_format || expected_format[0] == 194
+        n.to_s
+      else
+        expected_format
+      end
+    }
+  end
+end
+
+class IsoDate < TypeBase
+  def self.regex
+    /^\s*(\d{4})\D?(0[1-9]|1[0-2])\D?([12]\d|0[1-9]|3[01])(\D?([01]\d|2[0-3])\D?([0-5]\d)\D?([0-5]\d)?\D?(\d{3})?([zZ]|([\+-])([01]\d|2[0-3])\D?([0-5]\d)?)?)?\s*$/
+  end
+
+  def self.convert
+    Proc.new{ |s| 
+      begin
+        DateTime.parse(s)
+      rescue ArgumentError => exception
+        raise(GreenPepperTypeError.new,"Can't parse date #{s}")
+      end
+    }
+  end
+  
+  def self.format
+    Proc.new{ |d,expected_format|
+      date_base_slash = d.year.to_s.rjust(4,"0") + "-" + 
+        d.month.to_s.rjust(2,"0") + "-" + d.day.to_s.rjust(2,"0")
+      date_base_frontslash = d.year.to_s.rjust(4,"0") + "/" + 
+        d.month.to_s.rjust(2,"0") + "/" + d.day.to_s.rjust(2,"0")
+      date_hour_min = d.hour.to_s.rjust(2,"0") + ":" + 
+        d.min.to_s.rjust(2,"0")
+      date_extension = "Z"
+      
+      case expected_format
+      when /^(\d+)\-(\d+)\-(\d+)\w(\d+):(\d+)\w$/
+        date_base_slash + "T" + date_hour_min + date_extension
+      when /^(\d+)\-(\d+)\-(\d+)\s(\d+):(\d+)$/
+        date_base_slash + " " + date_hour_min
+      when /^(\d+)\-(\d+)\-(\d+)\s(\d+):(\d+)\w$/
+        date_base_slash + " " + date_hour_min + date_extension
+      when /^(\d+)\-(\d+)\-(\d+)$/
+        date_base_slash
+      when /^(\d+)\/(\d+)\/(\d+)\w(\d+):(\d+)\w$/
+        date_base_frontslash + "T" + date_hour_min + date_extension
+      when /^(\d+)\/(\d+)\/(\d+)\s(\d+):(\d+)$/
+        date_base_frontslash + " " + date_hour_min
+      when /^(\d+)\/(\d+)\/(\d+)\s(\d+):(\d+)\w$/
+        date_base_frontslash + " " + date_hour_min + date_extension
+      when /^(\d+)\/(\d+)\/(\d+)$/
+        date_base_frontslash
+      else
+        d.to_s
+      end
+    }
+  end
+end
+
+class ExplicitStringType < TypeBase
+  def self.regex
+    /^\s*["'].*["']\s*$/
+  end
+
+  def self.convert
+    Proc.new{ |s| s[1..-2] }
+  end
+  
+  def self.format
+    Proc.new{ |str,expected_format|
+      if (expected_format.index("'") == 0)
+        "'" + str.to_s + "'"
+      else
+        "\"" + str.to_s + "\""
+      end
+    }
+  end
+end
+
+class EmptyArrayType < TypeBase
+  def self.regex
+    /^\s*empty\s*$/i
+  end
+
+  def self.convert
+    Proc.new{ |s| [] }
+  end
+  
+  def self.format
+    Proc.new{ |a,expected_format|  
+      expected_format
+    }
+  end
+end
+
+class ArrayType < TypeBase
+  def self.regex
+    /^\s*(\[([^,]*,?)*\])|(([^,]+,)+[^,]+,?)\s*$/
+  end
+
+  def self.convert
+    Proc.new{ |s|
+      data = ArrayGrammarModule.parse(s)
+      
+      data.collect{ |x|
+        TypeConverter.instance.convert_string x
+      }
+    }
+  end
+  
+  def self.format
+    Proc.new{ |a,expected_format|
+      if a != nil
+        expected = ArrayGrammarModule.parse(expected_format)
+
+        a.each_index{|i|
+          a[i] = TypeConverter.instance.format_object expected[i], 
+            a[i]
+        }
+
+        case expected_format
+        when /^\[([^,]*,)*\]$/
+          "[" + a.join(",") + ",]"
+        when /^\[([^,]*,?)*\]$/
+          "[" + a.join(",") + "]"
+        when /^([^,]+,)+[^,]+,$/
+          a.join(",") + ","
+        else
+          a.join(",")
+        end
+      else
+        ""
+      end
+    }
+  end
+end
+
+end #module GreenPepper