cuporter 0.3.10 → 0.3.12

data/config/cuporter.example.yml

@@ -0,0 +1,8 @@
+# use a set of defaults like this to support primarily command line usage.
+---
+defaults:
+  report: tree
+  format: html
+  link_assets: true
+  use_copied_public_assets: true
+

data/config/option_set.rb

@@ -0,0 +1,79 @@
+# Copyright 2011 ThoughtWorks, Inc. Licensed under the MIT License
+module Cuporter
+  module Config
+
+    class OptionSet
+
+      attr_reader :options
+
+      def initialize(file_config = {})
+        # CLI options replace any found in the file
+        cli_options_over_file_options = file_config.merge(Cuporter::Config::CLI::Options.options)
+
+        # defaults will be used for anything not so far specified in the file
+        # or CLI
+        @options = post_process(Cuporter::Config::DEFAULTS.merge(cli_options_over_file_options))
+      end
+
+      def [](key)
+        @options[key]
+      end
+
+      def output_file(format)
+        if (file = @options[:output_file].find {|f| f =~ ext_for(format) })
+          File.open(file, "w")
+        end
+      end
+
+      def dump
+        col_1_max = @options.keys.max_by {|i| i.to_s.length }.to_s.size
+        @options.each do |key, value|
+          puts ":#{key.to_s.ljust(col_1_max, ' ')} => #{value.inspect}"
+        end
+      end
+
+      def dry_run?
+        @options[:dry_run]
+      end
+
+      private
+
+      def post_process(options)
+        options[:input_file_pattern] = options.delete(:input_file) || "#{options.delete(:input_dir)}/**/*.feature"
+        options[:root_dir] = options[:input_file_pattern].split(File::SEPARATOR).first
+        options[:filter_args] = Cuporter::Config::CLI::FilterArgsBuilder.new(options.delete(:tags)).args
+        options[:output_file].each_with_index do |file_path, i|
+          options[:output_file][i] = full_path(options[:output_home], file_path.dup )
+        end
+
+        unless options[:output_file].find {|f| f =~ /\.html$/ }
+          options[:copy_public_assets] = options[:use_copied_public_assets] = false
+        end
+
+        unless options[:output_file].empty?
+          options[:log_dir] = File.dirname(options[:output_file].first)
+        end
+        options
+      end
+
+      def full_path(root_dir, file_path)
+        path = root_dir.empty? ? file_path : File.join(root_dir, file_path)
+        expanded_path = File.expand_path(path)
+        path_nodes = expanded_path.split(File::SEPARATOR)
+        file = path_nodes.pop
+        FileUtils.makedirs(path_nodes.join(File::SEPARATOR))
+        expanded_path
+      end
+
+      def ext_for(format)
+        case format
+        when 'text', 'pretty'
+          /\.txt$/
+        else
+          /\.#{format}$/
+        end
+      end
+
+    end
+  end
+end

data/config/yaml_file/option_set_collection.rb

@@ -0,0 +1,42 @@
+# Copyright 2011 ThoughtWorks, Inc. Licensed under the MIT License
+module Cuporter
+  module Config
+    module YamlFile
+      class OptionSetCollection
+
+        def self.path
+          Cuporter::Config::CLI::Options[:config_file] || "config/cuporter.yml"
+        end
+
+        def self.config_file
+          return [] unless File.exists?(path)
+
+          require 'yaml'
+          yaml = YAML.load_file(path)
+          if yaml["option_sets"]
+            yaml["option_sets"].map do |option_set|
+              cast(option_set["options"])
+            end
+          else
+            yaml["defaults"].empty? ? [] : [cast(yaml["defaults"])]
+          end
+        end
+
+        def self.cast(option_set)
+          pairs = {}
+          option_set.each do |key, value|
+            pairs[key.to_sym] = case key
+                                when /^(tags|output_file|format)$/i
+                                  value.is_a?(Array) ? value : [value]
+                                else
+                                  value
+                                end
+          end
+
+          return pairs
+        end
+
+      end # class
+    end  # File
+  end  # Config
+end

data/lib/cuporter.rb

@@ -1,14 +1,12 @@
 # Copyright 2010 ThoughtWorks, Inc. Licensed under the MIT License
 $LOAD_PATH.unshift( File.expand_path("#{File.dirname(__FILE__)}"))
-$LOAD_PATH.unshift( File.expand_path("#{File.dirname(__FILE__)}/.."))
 require 'cuporter/extensions/string'
+require 'cuporter/logging'
 require 'cuporter/node'
 require 'cuporter/formatters/text'
 require 'cuporter/formatters/csv'
 require 'cuporter/filter'
 require 'cuporter/feature_parser'
-require 'cuporter/tag_nodes_parser'
-require 'cuporter/node_parser'
 require 'cuporter/document'
 require 'cuporter/document/assets'
 require 'cuporter/document/html_document'

data/lib/cuporter/feature_parser.rb

@@ -1,16 +1,11 @@
-# Copyright 2010 ThoughtWorks, Inc. Licensed under the MIT License
+# Copyright 2011 ThoughtWorks, Inc. Licensed under the MIT License
+require 'cuporter/feature_parser/language'
+require 'cuporter/feature_parser/parser_base'
+require 'cuporter/feature_parser/tag_nodes_parser'
+require 'cuporter/feature_parser/node_parser'
 
 module Cuporter
-  class FeatureParser
-    FEATURE_LINE          = /^\s*(Feature:[^#]*)/u
-    TAG_LINE              = /^\s*(@\w.+)/u
-    SCENARIO_LINE         = /^\s*(Scenario:[^#]*)$/u
-    SCENARIO_OUTLINE_LINE = /^\s*(Scenario Outline:[^#]*)$/u
-    SCENARIO_SET_LINE     = /^\s*(Scenarios:[^#]*)$/u
-    EXAMPLE_SET_LINE      = /^\s*(Examples:[^#]*)$/u
-    EXAMPLE_LINE          = /^\s*(\|.*\|)\s*$/u
-    PY_STRING_LINE        = /^\s*"""\s*$/u
-
+  module FeatureParser
     # adds a node to the doc for each cucumber '@' tag, populated with features and
     # scenarios
     def self.tag_nodes(file, report, filter, root_dir)
@@ -25,64 +20,5 @@ module Cuporter
       parser.root = root_dir
       parser.parse_feature
     end
-    attr_writer :root
-
-    def initialize(file)
-      @file = file
-      @current_tags = []
-      @lines = File.read(@file).split(/\n/)
-    end
-
-    def file_relative_path
-      @file_relative_path ||= @file.sub(/^.*#{@root}\//,"#{@root}/")
-    end
-
-    def parse_feature
-      @open_comment_block = false
-
-      @lines.each do |line|
-        next if @open_comment_block && line !~ PY_STRING_LINE
-
-        case line
-        when PY_STRING_LINE
-          # toggle, to declare the multiline comment 'heredoc' open or closed
-          @open_comment_block = !@open_comment_block
-        when TAG_LINE
-          # may be more than one tag line
-          @current_tags |= clean_cuke_line($1).split(/\s+/)
-        when FEATURE_LINE
-          @feature = new_feature_node(clean_cuke_line($1), file_relative_path)
-          @current_tags = []
-        when SCENARIO_LINE
-          # How do we know when we have read all the lines from a "Scenario Outline:"?
-          # One way is when we encounter a "Scenario:"
-          close_scenario_outline
-
-          handle_scenario_line(clean_cuke_line($1))
-          @current_tags = []
-        when SCENARIO_OUTLINE_LINE
-          # ... another is when we hit a subsequent "Scenario Outline:"
-          close_scenario_outline
-
-          @scenario_outline  = new_scenario_outline_node(clean_cuke_line($1))
-          @current_tags = []
-        when EXAMPLE_SET_LINE, SCENARIO_SET_LINE
-          handle_example_set_line if @example_set
-
-          @example_set = new_example_set_node(clean_cuke_line($1))
-          @current_tags = []
-        when @example_set && EXAMPLE_LINE
-          new_example_line(clean_cuke_line($1))
-        end
-      end
-
-      # EOF is the final way that we know we are finished with a "Scenario Outline"
-      close_scenario_outline
-      return @feature
-    end
-
-    def clean_cuke_line(sub_expression)
-      sub_expression.strip.escape_apostrophe
-    end
   end
 end

data/lib/cuporter/feature_parser/language.rb

@@ -0,0 +1,41 @@
+# Copyright 2011 ThoughtWorks, Inc. Licensed under the MIT License
+begin
+  require 'gherkin/i18n'
+rescue LoadError => ex
+  $gherkin_warning = %Q{Warning: Rubygems could not find Gherkin.  Cuporter will use an old gherkin (2.3.3) language file.
+         Make sure the 'gherkin' gem is installed by checking your rvm config, your bundler config, or gem list.
+
+         "#{ex.class}: #{ex.message}"
+         "#{ex.backtrace.join("\n\t\t")}"
+  }
+  require 'cuporter/feature_parser/old_gherkin_yaml/i18n'
+end
+
+module Cuporter
+  module FeatureParser
+    class Language
+
+      attr_reader :feature_line, :scenario_line, :scenario_outline_line, :examples_line
+
+      def initialize(line_1)
+        @iso_code = 'en'
+        if (line_1.to_s =~ LANGUAGE_LINE)
+          @iso_code = $1
+          warn($gherkin_warning) if $gherkin_warning
+        end
+        @feature_line          = pattern_for('feature')
+        @scenario_line         = pattern_for('scenario')
+        @scenario_outline_line = pattern_for('scenario_outline')
+        @examples_line         = pattern_for('examples')
+      end
+
+      private
+
+      def pattern_for(keyword)
+        /^\s*((#{Gherkin::I18n::LANGUAGES[@iso_code][keyword]}):[^#]*)/u
+      end
+      
+      LANGUAGE_LINE = /^\s*#\s*language:\s*([\w-]+)/u
+    end
+  end
+end

data/lib/cuporter/feature_parser/node_parser.rb

@@ -0,0 +1,64 @@
+# Copyright 2011 ThoughtWorks, Inc. Licensed under the MIT License
+
+module Cuporter
+  module FeatureParser
+    class NodeParser < ParserBase
+
+      # ++sub_expression++ is the paren group in the regex, dereferenced with $1 in the caller
+      def new_feature_node(sub_expression, file)
+        f = Node.new_node(:Feature, @doc, :cuke_name => sub_expression, :tags => @current_tags, :file_path => file)
+        f.filter = @filter
+        f
+      end
+
+      def handle_scenario_line(sub_expression)
+        if @filter.pass?(@current_tags | @feature.tags)
+          @feature.add_child(Node.new_node(:Scenario, @doc, :cuke_name => sub_expression, :tags => @current_tags))
+        end
+      end
+
+      def new_scenario_outline_node(sub_expression)
+        so = Node.new_node(:ScenarioOutline, @doc, :cuke_name => sub_expression, :tags => @current_tags)
+        so.filter = @filter
+        so
+      end
+
+      def handle_example_set_line
+        if @filter.pass?(@feature.tags | @scenario_outline.tags | @example_set.tags)
+          @scenario_outline.add_child @example_set
+        end
+      end
+
+      def new_example_set_node(sub_expression)
+        es = Node.new_node(:Examples, @doc, :cuke_name => sub_expression, :tags => @current_tags)
+        es.filter = @filter
+        es
+      end
+
+      def new_example_line(sub_expression)
+        example_type = :ExampleHeader
+        # if the example set has a child already, then it must be the header
+        example_type = :Example if @example_set.has_children?
+        @example_set.add_child(Node.new_node(example_type, @doc, :cuke_name => sub_expression))
+      end
+
+      def close_scenario_outline
+        if @scenario_outline
+          if @example_set
+            handle_example_set_line
+            @example_set = nil
+          end
+          @feature.add_child(@scenario_outline) if @scenario_outline.has_children?
+          @scenario_outline = nil
+        end
+      end
+
+      def initialize(file, doc, filter)
+        super(file)
+        @filter = filter
+        @doc = doc
+      end
+
+    end
+  end
+end

data/lib/cuporter/feature_parser/old_gherkin_yaml/i18n.rb

@@ -0,0 +1,9 @@
+require 'yaml'
+
+module Gherkin
+  class I18n
+
+    LANGUAGES            = YAML.load_file(File.dirname(__FILE__) + '/i18n.yml')
+
+  end
+end

data/lib/cuporter/feature_parser/parser_base.rb

@@ -0,0 +1,84 @@
+# Copyright 2010 ThoughtWorks, Inc. Licensed under the MIT License
+
+module Cuporter
+  module FeatureParser
+    class ParserBase
+      TAG_LINE              = /^\s*(@\w.+)/u
+      EXAMPLE_LINE          = /^\s*(\|.*\|)\s*$/u
+      PY_STRING_LINE        = /^\s*"""\s*$/u
+   
+      def initialize(file)
+        @file = file
+        @current_tags = []
+        @lines = File.read(@file).split(/\n/)
+        @lang  = Language.new(@lines.first)
+      end
+      attr_reader :lang
+      attr_writer :root
+
+      def file_relative_path
+        @file_relative_path ||= @file.sub(/^.*#{@root}\//,"#{@root}/")
+      end
+   
+      def parse_feature
+        begin
+          handle_lines
+        rescue Exception => ex
+           Cuporter.log_error(ex, "Error parsing file", "at line #{@line_no}:", @file, 
+                             %Q{\n\tIf this file can be run by Cucumber with no Gherkin lexing or parsing errors,
+           please submit a bug ticket @ github including: 1) this feature file or its contents, and 2) this stack trace.
+                             })
+        end
+        return @feature
+      end
+
+      def handle_lines
+        @open_comment_block = false
+   
+        @lines.each_with_index do |line, i|
+          @line_no = i + 1
+          next if @open_comment_block && line !~ PY_STRING_LINE
+   
+          case line
+          when PY_STRING_LINE
+            # toggle, to declare the multiline comment 'heredoc' open or closed
+            @open_comment_block = !@open_comment_block
+          when TAG_LINE
+            # may be more than one tag line
+            @current_tags |= clean_cuke_line($1).split(/\s+/)
+          when @lang.feature_line
+            @feature = new_feature_node(clean_cuke_line($1), file_relative_path)
+            @current_tags = []
+          when @lang.scenario_line
+            # How do we know when we have read all the lines from a "Scenario Outline:"?
+            # One way is when we encounter a "Scenario:"
+            close_scenario_outline
+   
+            handle_scenario_line(clean_cuke_line($1))
+            @current_tags = []
+          when @lang.scenario_outline_line
+            # ... another is when we hit a subsequent "Scenario Outline:"
+            close_scenario_outline
+   
+            @scenario_outline  = new_scenario_outline_node(clean_cuke_line($1))
+            @current_tags = []
+          when @lang.examples_line
+            handle_example_set_line if @example_set
+   
+            @example_set = new_example_set_node(clean_cuke_line($1))
+            @current_tags = []
+          when @example_set && EXAMPLE_LINE
+            new_example_line(clean_cuke_line($1))
+          end
+        end
+   
+        # EOF is the final way that we know we are finished with a "Scenario Outline"
+        close_scenario_outline
+      end
+   
+      def clean_cuke_line(sub_expression)
+        sub_expression.strip.escape_apostrophe
+      end
+    end
+  end
+end

data/lib/cuporter/feature_parser/tag_nodes_parser.rb

@@ -0,0 +1,96 @@
+# Copyright 2011 ThoughtWorks, Inc. Licensed under the MIT License
+
+module Cuporter
+  module FeatureParser
+    class TagNodesParser < ParserBase
+
+      # ++sub_expression++ is the paren group in the regex, dereferenced with $1 in the caller
+      def new_feature_node(sub_expression, file)
+        {:cuke_name => sub_expression, :tags => @current_tags, :file_path => file}
+      end
+
+      def handle_scenario_line(sub_expression)
+        if @filter.pass?(@feature[:tags] | @current_tags)
+          s = {:cuke_name => sub_expression, :tags => @current_tags}
+
+          (@feature[:tags] | s[:tags]).each do |tag|
+            next unless @filter.pass?([tag])
+            add_scenario(tag, @feature, s)
+          end
+        end
+      end
+
+      def new_scenario_outline_node(sub_expression)
+        {:cuke_name => sub_expression, :tags => @current_tags}
+      end
+
+      def handle_example_set_line
+      end
+
+      def new_example_set_node(sub_expression)
+        {:cuke_name => sub_expression.to_s.strip, :tags => @current_tags}
+      end
+
+      def new_example_line(sub_expression)
+        context_tags = (@feature[:tags] | @scenario_outline[:tags] | @example_set[:tags])
+        if @filter.pass?(context_tags)
+          e = {:cuke_name => sub_expression}
+
+          context_tags.each do |tag|
+            next unless @filter.pass?([tag])
+            add_example(tag, @feature, @scenario_outline, @example_set, e)
+          end
+        end
+      end
+
+      def close_scenario_outline
+        if @scenario_outline
+          if @example_set
+            @example_set = nil
+          end
+          @scenario_outline = nil
+        end
+      end
+      def add_scenario(tag, feature, scenario)
+        unless ( t = @report.tag_node(tag))
+          t = @report.add_child(Node.new_node(:tag, @doc, 'cuke_name' => tag))
+        end
+        unless ( f = t.feature_node(feature) )
+          f = t.add_child(Node.new_node(:Feature, @doc, feature))
+        end
+        f.add_child(Node.new_node(:Scenario, @doc, scenario))
+      end
+
+      def add_example(tag, feature, scenario_outline, example_set, example)
+        unless ( t = @report.tag_node(tag))
+          t = @report.add_child(Node.new_node(:Tag, @doc, 'cuke_name' => tag))
+        end
+        unless ( f = t.feature_node(feature) )
+          f = t.add_child(Node.new_node(:Feature, @doc, feature))
+        end
+        unless ( so = f.scenario_outline_node(scenario_outline) )
+          so = f.add_child(Node.new_node(:ScenarioOutline, @doc, scenario_outline))
+        end
+
+        # The first Example is an ExampleHeader, which does not get counted or
+        # numbered.  If the ExampleSet is new, it has no children, and therefore
+        # this is the first and should be an ExampleHeader.
+        example_type = :Example
+        unless ( es = so.example_set_node(example_set) )
+          es = so.add_child(Node.new_node(:Examples, @doc, example_set))
+          example_type = :ExampleHeader
+        end
+        es.add_child(Node.new_node(example_type, @doc, example))
+      end
+
+
+      def initialize(file, report, filter)
+        super(file)
+        @filter = filter
+        @report = report
+        @doc = report.document
+      end
+
+    end
+  end
+end