cucumber_analytics 0.0.9 → 1.0.0

data/lib/cucumber_analytics/doc_string.rb

@@ -0,0 +1,55 @@
+module CucumberAnalytics
+
+  # A class modeling the Doc String of a Step.
+
+  class DocString
+
+    # The parent object that contains *self*
+    attr_accessor :parent_element
+
+    # The content type associated with the doc string
+    attr_accessor :content_type
+
+    # The contents of the doc string
+    attr_accessor :contents
+
+
+    # Creates a new DocString object and, if *source* is provided, populates
+    # the object.
+    def initialize(source = nil)
+      @contents = []
+
+      parsed_doc_string = process_source(source)
+
+      build_doc_string(parsed_doc_string) if parsed_doc_string
+    end
+
+
+    private
+
+
+    def process_source(source)
+      case
+        when source.is_a?(String)
+          parse_doc_string(source)
+        else
+          source
+      end
+    end
+
+    def parse_doc_string(source_text)
+      base_file_string = "Feature:\nScenario:\n* step\n"
+      source_text = base_file_string + source_text
+
+      parsed_file = Parsing::parse_text(source_text)
+
+      parsed_file.first['elements'].first['steps'].first['doc_string']
+    end
+
+    def build_doc_string(doc_string)
+      @content_type = doc_string['content_type'] == "" ? nil : doc_string['content_type']
+      @contents = doc_string['value'].split($/)
+    end
+
+  end
+end

data/lib/cucumber_analytics/example.rb

@@ -0,0 +1,100 @@
+module CucumberAnalytics
+
+  # A class modeling a Cucumber Examples table.
+
+  class Example < FeatureElement
+
+    include Taggable
+
+    # The argument rows in the example table
+    attr_accessor :rows
+
+    # The parameters for the example table
+    attr_accessor :parameters
+
+
+    # Creates a new Example object and, if *source* is provided,
+    # populates the object.
+    def initialize(source = nil)
+      parsed_example = process_source(source)
+
+      super(parsed_example)
+
+      @tags = []
+      @rows = []
+      @parameters = []
+
+      build_example(parsed_example) if parsed_example
+    end
+
+    # Adds a row to the example table. The row can be given as a Hash of
+    # parameters and their corresponding values or as an Array of values which
+    # will be assigned in order.
+    def add_row(row)
+      case
+        when row.is_a?(Array)
+          @rows << Hash[@parameters.zip(row.collect { |value| value.strip })]
+        when row.is_a?(Hash)
+          @rows << row.each_value { |value| value.strip! }
+        else
+          raise(ArgumentError, "Can only add row from a Hash or an Array but received #{row.class}")
+      end
+    end
+
+    # Removes a row from the example table. The row can be given as a Hash of
+    # parameters and their corresponding values or as an Array of values
+    # which will be assigned in order.
+    def remove_row(row)
+      case
+        when row.is_a?(Array)
+          location = @rows.index { |row_hash| row_hash.values_at(*@parameters) == row.collect { |value| value.strip } }
+        when row.is_a?(Hash)
+          location = @rows.index { |row_hash| row_hash == row.each_value { |value| value.strip! } }
+        else
+          raise(ArgumentError, "Can only remove row from a Hash or an Array but received #{row.class}")
+      end
+
+      @rows.delete_at(location) if location
+    end
+
+
+    private
+
+
+    def process_source(source)
+      case
+        when source.is_a?(String)
+          parse_example(source)
+        else
+          source
+      end
+    end
+
+    def parse_example(source_text)
+      base_file_string = "Feature: Fake feature to parse\nScenario Outline:\n* fake step\n"
+      source_text = base_file_string + source_text
+
+      parsed_file = Parsing::parse_text(source_text)
+
+      parsed_file.first['elements'].first['examples'].first
+    end
+
+    def build_example(parsed_example)
+      populate_element_tags(parsed_example)
+      populate_example_parameters(parsed_example)
+      populate_example_rows(parsed_example)
+    end
+
+    def populate_example_parameters(parsed_example)
+      @parameters = parsed_example['rows'].first['cells']
+    end
+
+    def populate_example_rows(parsed_example)
+      parsed_example['rows'].shift
+      parsed_example['rows'].each do |row|
+        @rows << Hash[@parameters.zip(row['cells'])]
+      end
+    end
+
+  end
+end

data/lib/cucumber_analytics/feature.rb

@@ -0,0 +1,120 @@
+module CucumberAnalytics
+
+  # A class modeling a Cucumber Feature.
+
+  class Feature < FeatureElement
+
+    include Taggable
+    include Containing
+
+
+    # The Background object contained by the Feature
+    attr_accessor :background
+
+    # The TestElement objects contained by the Feature
+    attr_accessor :tests
+
+
+    # Creates a new Feature object and, if *source* is provided, populates the
+    # object.
+    def initialize(source = nil)
+      parsed_feature = process_source(source)
+
+      super(parsed_feature)
+
+      @tags = []
+      @tests = []
+
+      build_feature(parsed_feature) if parsed_feature
+    end
+
+    # Returns true if the feature contains a background, false otherwise.
+    def has_background?
+      !@background.nil?
+    end
+
+    # Returns the scenarios contained in the feature.
+    def scenarios
+      @tests.select { |test| test.is_a? Scenario }
+    end
+
+    # Returns the outlines contained in the feature.
+    def outlines
+      @tests.select { |test| test.is_a? Outline }
+    end
+
+    # Returns the number of scenarios contained in the feature.
+    def scenario_count
+      scenarios.count
+    end
+
+    # Returns the number of outlines contained in the feature.
+    def outline_count
+      outlines.count
+    end
+
+    # Returns the number of tests contained in the feature.
+    def test_count
+      @tests.count
+    end
+
+    # Returns the number of test cases contained in the feature.
+    def test_case_count
+      scenario_count + outlines.reduce(0) { |outline_sum, outline|
+        outline_sum += outline.examples.reduce(0) { |example_sum, example|
+          example_sum += example.rows.count
+        }
+      }
+    end
+
+    # Returns the immediate child elements of the feature (i.e. its Background,
+    # Scenario, and Outline objects.
+    def contains
+      [@background] + @tests
+    end
+
+
+    private
+
+
+    def process_source(source)
+      case
+        when source.is_a?(String)
+          parse_feature(source)
+        else
+          source
+      end
+    end
+
+    def parse_feature(source_text)
+      parsed_file = Parsing::parse_text(source_text)
+
+      parsed_file.first
+    end
+
+    def build_feature(parsed_feature)
+      populate_element_tags(parsed_feature)
+      populate_feature_elements(parsed_feature)
+    end
+
+    def populate_feature_elements(parsed_feature)
+      elements = parsed_feature['elements']
+
+      if elements
+        elements.each do |element|
+          case element['keyword']
+            when 'Scenario'
+              @tests << build_child_element(Scenario, element)
+            when 'Scenario Outline'
+              @tests << build_child_element(Outline, element)
+            when 'Background'
+              @background = build_child_element(Background, element)
+            else
+              raise(ArgumentError, "Unknown keyword: #{element['keyword']}")
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/cucumber_analytics/feature_element.rb

@@ -1,62 +1,44 @@
 module CucumberAnalytics
+
+  # A class modeling an basic element of a feature.
+
   class FeatureElement
 
+    # The name of the FeatureElement
+    attr_accessor :name
 
-    attr_reader :name
-    attr_reader :description
-    attr_accessor :parent_element
+    # The description of the FeatureElement
+    attr_accessor :description
 
+    # The parent object that contains *self*
+    attr_accessor :parent_element
 
-    # Creates a new FeatureElement object.
-    def initialize(source_lines = nil)
-      CucumberAnalytics::Logging.logger.info('FeatureElement#initialize')
 
+    # Creates a new FeatureElement object and, if *parsed_element* is provided,
+    # populates the object.
+    def initialize(parsed_element = nil)
       @name = ''
       @description =[]
+
+      build_feature_element(parsed_element) if parsed_element
     end
 
 
     private
 
 
-    def parse_feature_element(source_lines)
-      CucumberAnalytics::Logging.logger.info('FeatureElement#parse_feature_element')
-
-      parse_feature_element_name(source_lines)
-      parse_feature_element_description(source_lines)
+    def build_feature_element(parsed_element)
+      populate_feature_element_name(parsed_element)
+      populate_feature_element_description(parsed_element)
     end
 
-    #todo - move this elsewhere
-    def parse_feature_element_tags(source_lines)
-      CucumberAnalytics::Logging.logger.info('FeatureElement#parse_feature_element_tags')
-      CucumberAnalytics::Logging.logger.debug('source lines')
-      source_lines.each do |line|
-        CucumberAnalytics::Logging.logger.debug(line.chomp)
-      end
-
-      source_lines.take_while { |line| line !~ /^\s*(?:[A-Z a-z])+:/ }.tap do |tag_lines|
-        tag_lines.delete_if { |line| World.ignored_line?(line)}
-
-        tag_lines.join(' ').delete(' ').split('@').each do |tag|
-          @tags << "@#{tag.strip}"
-        end
-      end
-      @tags.shift
-
-      while source_lines.first !~  /^\s*(?:[A-Z a-z])+:/
-        source_lines.shift
-      end
+    def populate_feature_element_name(parsed_element)
+      @name = parsed_element['name']
     end
 
-    def parse_feature_element_name(source_lines)
-      CucumberAnalytics::Logging.logger.info('FeatureElement#parse_feature_element_name')
-      CucumberAnalytics::Logging.logger.debug('source lines')
-      source_lines.each do |line|
-        CucumberAnalytics::Logging.logger.debug(line.chomp)
-      end
-
-      @name.replace source_lines.first.match(/^\s*(?:[A-Z a-z])+:(.*)/)[1].strip
-      source_lines.shift
+    def populate_feature_element_description(parsed_element)
+      @description = parsed_element['description'].split("\n").collect { |line| line.strip }
+      @description.delete('')
     end
 
   end

data/lib/cucumber_analytics/feature_file.rb

@@ -0,0 +1,74 @@
+module CucumberAnalytics
+
+  # A class modeling a Cucumber .feature file.
+
+  class FeatureFile
+
+    include Containing
+
+
+    # The Feature objects contained by the FeatureFile
+    attr_accessor :features
+
+    # The parent object that contains *self*
+    attr_accessor :parent_element
+
+
+    # Creates a new FeatureFile object and, if *file_parsed* is provided,
+    # populates the object.
+    def initialize(file = nil)
+      @file = file
+      @features = []
+
+      if file
+        raise(ArgumentError, "Unknown file: #{file.inspect}") unless File.exists?(file)
+
+        parsed_file = parse_file(file)
+
+        build_file(parsed_file)
+      end
+    end
+
+    # Returns the name of the file.
+    def name
+      File.basename(@file.gsub('\\', '/'))
+    end
+
+    # Returns the path of the file.
+    def path
+      @file
+    end
+
+    # Returns the immediate child elements of the file(i.e. its Feature object).
+    def contains
+      @features
+    end
+
+    # Returns the number of features contained in the file.
+    def feature_count
+      @features.count
+    end
+
+    # Returns the Feature object contained by the FeatureFile.
+    def feature
+      @features.first
+    end
+
+
+    private
+
+
+    def parse_file(file_to_parse)
+      source_text = IO.read(file_to_parse)
+
+      Parsing::parse_text(source_text)
+    end
+
+    def build_file(parsed_file)
+      unless parsed_file.empty?
+        @features << build_child_element(Feature, parsed_file.first)
+      end
+    end
+
+  end
+end

data/lib/cucumber_analytics/outline.rb

@@ -0,0 +1,49 @@
+module CucumberAnalytics
+
+  # A class modeling a Cucumber Scenario Outline.
+
+  class Outline < TestElement
+
+    include Taggable
+
+
+    # The Example objects contained by the Outline
+    attr_accessor :examples
+
+
+    # Creates a new Outline object and, if *source* is provided, populates the
+    # object.
+    def initialize(source = nil)
+      parsed_outline = process_source(source)
+
+      super(parsed_outline)
+
+      @tags = []
+      @examples = []
+
+      build_outline(parsed_outline) if parsed_outline
+    end
+
+    # Returns the immediate child elements of the outline (i.e. its Example
+    # objects.
+    def contains
+      @examples + @steps
+    end
+
+
+    private
+
+
+    def build_outline(parsed_outline)
+      populate_element_tags(parsed_outline)
+      populate_outline_examples(parsed_outline['examples']) if parsed_outline['examples']
+    end
+
+    def populate_outline_examples(parsed_examples)
+      parsed_examples.each do |example|
+        @examples << build_child_element(Example, example)
+      end
+    end
+
+  end
+end

data/lib/cucumber_analytics/parsing.rb

@@ -0,0 +1,30 @@
+require 'stringio'
+require 'gherkin/formatter/json_formatter'
+require 'gherkin'
+
+module CucumberAnalytics
+
+  # A module providing source text parsing functionality.
+
+  module Parsing
+
+    class << self
+
+      # Parses the Cucumber feature given in *source_text* and returns an array
+      # containing the hash representation of its logical structure.
+      def parse_text(source_text)
+        raise(ArgumentError, "Cannot parse #{source_text.class} objects. Strings only.") unless source_text.is_a?(String)
+
+        io = StringIO.new
+        formatter = Gherkin::Formatter::JSONFormatter.new(io)
+        parser = Gherkin::Parser::Parser.new(formatter)
+        parser.parse(source_text, 'fake_file.txt', 0)
+        formatter.done
+
+        JSON.parse(io.string)
+      end
+
+    end
+
+  end
+end

data/lib/cucumber_analytics/scenario.rb

@@ -0,0 +1,31 @@
+module CucumberAnalytics
+
+  # A class modeling a Cucumber Scenario.
+
+  class Scenario < TestElement
+
+    include Taggable
+
+
+    # Creates a new Scenario object and, if *source* is provided, populates the
+    # object.
+    def initialize(source = nil)
+      parsed_scenario = process_source(source)
+
+      super(parsed_scenario)
+
+      @tags = []
+
+      build_scenario(parsed_scenario) if parsed_scenario
+    end
+
+
+    private
+
+
+    def build_scenario(scenario)
+      populate_element_tags(scenario)
+    end
+
+  end
+end