cucumber_analytics 0.0.9 → 1.0.0

data/lib/cucumber_analytics/parsed_directory.rb

@@ -1,78 +0,0 @@
-module CucumberAnalytics
-  class ParsedDirectory
-
-
-    attr_reader :feature_files
-    attr_reader :feature_directories
-    attr_accessor :parent_element
-
-
-    # Creates a new ParsedDirectory object and, if *directory_parsed* is
-    # provided, populates the object.
-    def initialize(directory_parsed = nil)
-      CucumberAnalytics::Logging.logger.info('ParsedDirectory#initialize')
-
-      @directory = directory_parsed
-
-      @feature_files = []
-      @feature_directories = []
-
-      scan_directory if directory_parsed
-    end
-
-    # Returns the name of the directory.
-    def name
-      File.basename(@directory.gsub('\\', '/'))
-    end
-
-    # Returns the path of the directory.
-    def path
-      @directory
-    end
-
-    # Returns the number of sub-directories contained in the directory.
-    def directory_count
-      @feature_directories.count
-    end
-
-    # Returns the number of features files contained in the directory.
-    def feature_file_count
-      @feature_files.count
-    end
-
-    # Returns the immediate child elements of the directory (i.e. its .feature
-    # files and .feature file containing sub-directories).
-    def contains
-      @feature_files + @feature_directories
-    end
-
-
-    private
-
-
-    def scan_directory
-      entries = Dir.entries(@directory)
-      entries.delete '.'
-      entries.delete '..'
-
-      entries.each do |entry|
-        entry = @directory + '/' + entry
-
-        if File.directory?(entry)
-          found_directory = ParsedDirectory.new(entry)
-          found_directory.parent_element = self
-
-          @feature_directories << found_directory
-        end
-
-        if entry =~ /\.feature$/
-          found_feature_file = ParsedFile.new(entry)
-          found_feature_file.parent_element = self
-
-          @feature_files << found_feature_file
-        end
-      end
-    end
-
-  end
-end

data/lib/cucumber_analytics/parsed_feature.rb

@@ -1,97 +0,0 @@
-module CucumberAnalytics
-  class ParsedFeature < FeatureElement
-
-
-    attr_accessor :tags
-    attr_accessor :background
-    attr_accessor :tests
-
-
-    # Creates a new ParsedFeature object and, if *source_lines* is provided,
-    # populates the object.
-    def initialize(source_lines = nil)
-      CucumberAnalytics::Logging.logger.info('ParsedFeature#initialize')
-
-      super
-
-      @tags = []
-      @tests = []
-
-      parse_feature(source_lines) if source_lines
-    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? ParsedScenario }
-    end
-
-    # Returns the outlines contained in the feature.
-    def outlines
-      @tests.select { |test| test.is_a? ParsedScenarioOutline }
-    end
-
-    # Returns the number scenarios contained in the feature.
-    def scenario_count
-      scenarios.count
-    end
-
-    # Returns the number 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
-    # and tests).
-    def contains
-      [@background] + @tests
-    end
-
-
-    private
-
-
-    def parse_feature(source_lines)
-      CucumberAnalytics::Logging.logger.info('ParsedFeature#parse_feature')
-
-      parse_feature_element_tags(source_lines)
-      parse_feature_element(source_lines)
-    end
-
-    def parse_feature_element_description(source_lines)
-      CucumberAnalytics::Logging.logger.info('ParsedFeature#parse_feature_element_description')
-      CucumberAnalytics::Logging.logger.debug('source lines')
-      source_lines.each do |line|
-        CucumberAnalytics::Logging.logger.debug(line.chomp)
-      end
-
-      source_lines.delete_if { |line| World.ignored_line?(line) }
-
-      until source_lines.first =~ /#{World::TEST_ELEMENT_START_PATTERN}/ or
-          source_lines.empty?
-
-        @description << source_lines.first.strip
-        source_lines.shift
-      end
-    end
-
-  end
-end

data/lib/cucumber_analytics/parsed_file.rb

@@ -1,199 +0,0 @@
-module CucumberAnalytics
-  class ParsedFile
-
-
-    attr_reader :feature
-    attr_accessor :parent_element
-
-
-    # Creates a new ParsedFile object and, if *file_parsed* is provided,
-    # populates the object.
-    def initialize(file_parsed = nil)
-      CucumberAnalytics::Logging.logger.info('ParsedFile#initialize')
-
-      parse_file(file_parsed) if file_parsed
-    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 feature file(i.e. its
-    # feature).
-    def contains
-      @feature ? [@feature] : []
-    end
-
-    # Returns the number of features contained in the file.
-    def feature_count
-      @feature.nil? ? 0 : 1
-    end
-
-
-    private
-
-
-    def parse_file(file_parsed)
-      CucumberAnalytics::Logging.logger.info('ParsedFile#parse_file')
-      CucumberAnalytics::Logging.logger.debug("Parsing file: #{file_parsed}")
-
-      @file = file_parsed
-
-      file_lines = []
-      feature_lines = []
-      background_lines = []
-
-      File.open(@file, 'r') { |file| file_lines = file.readlines }
-
-      # collect feature tag lines
-      until file_lines.first =~ /^\s*Feature:/ or
-          file_lines.empty?
-
-        feature_lines << file_lines.first
-        file_lines.shift
-      end
-
-      # collect everything else until the end of the feature section
-      until file_lines.first =~ /#{World::TEST_ELEMENT_START_PATTERN}/ or
-          file_lines.empty?
-
-        feature_lines << file_lines.first
-        file_lines.shift
-      end
-
-      # create a new feature bases on the collected lines
-      if feature_lines.empty?
-        @feature = nil
-      else
-        found_feature = ParsedFeature.new(feature_lines)
-        found_feature.parent_element = self
-
-        @feature = found_feature
-      end
-
-
-      if file_lines.first =~ /^\s*Background:/
-
-        # collect the background description lines
-        until (file_lines.first =~ /^\s*(?:(?:Given )|(?:When )|(?:Then )|(?:And )|(?:\* )|@|Scenario:|(?:Scenario Outline:))/) or
-            file_lines.empty?
-
-          background_lines << file_lines.first
-          file_lines.shift
-        end
-
-        # collect everything else up to the first test
-        until file_lines.first =~ /^\s*(?:@|Scenario:|(?:Scenario Outline:))/ or
-            file_lines.empty?
-
-          if file_lines.first =~ /^\s*"""/
-            background_lines.concat(extract_doc_string!(file_lines))
-          else
-            background_lines << file_lines.first
-            file_lines.shift
-          end
-        end
-
-        # create a new background based on the collected lines
-        found_background = ParsedBackground.new(background_lines)
-        found_background.parent_element = @feature
-
-        @feature.background = found_background
-      end
-
-      parse_tests(file_lines)
-    end
-
-    def parse_tests(lines)
-      CucumberAnalytics::Logging.logger.info('ParsedFile#parse_tests')
-      CucumberAnalytics::Logging.logger.debug('lines')
-      lines.each do |line|
-        CucumberAnalytics::Logging.logger.debug(line.chomp)
-      end
-
-      until lines.empty?
-        # we'll need this in order to figure out whether we are dealing with a
-        # scenario or an outline
-        current_test_line = lines.index { |line| line =~ /^\s*(?:Scenario:|(?:Scenario Outline:))/ }
-
-        test_lines = []
-
-        # collect the tag lines
-        until lines.first =~ /^\s*(?:Scenario:|(?:Scenario Outline:))/
-          test_lines << lines.first
-          lines.shift
-        end
-
-        test_lines << lines.first
-        lines.shift
-
-        # collect the description lines
-        until (lines.first =~ /^\s*(?:(?:Given )|(?:When )|(?:Then )|(?:And )|(?:\* )|Scenario:|(?:Scenario Outline:))/) or
-            lines.empty?
-
-          test_lines << lines.first
-          lines.shift
-        end
-
-        # collect everything else up to the next test
-        until (lines.first =~ /^\s*(?:Scenario:|(?:Scenario Outline:))/) or
-            lines.empty?
-
-          if (lines.first =~ /^\s*"""/)
-            test_lines.concat(extract_doc_string!(lines))
-          else
-            test_lines << lines.first
-            lines.shift
-          end
-        end
-
-        # backtrack in order to not end up stealing the next test's tag lines
-        unless lines.empty?
-          while (test_lines.last =~ /^\s*@/) or World.ignored_line?(test_lines.last)
-            lines = [test_lines.pop].concat(lines)
-          end
-        end
-
-        # use the collected lines to create a scenario or an outline accordingly
-        if test_lines[current_test_line] =~ /^\s*Scenario Outline:/
-          next_test = ParsedScenarioOutline.new(test_lines)
-        else
-          next_test = ParsedScenario.new(test_lines)
-        end
-
-        next_test.parent_element = @feature
-        @feature.tests << next_test
-      end
-    end
-
-    def extract_doc_string!(lines)
-      CucumberAnalytics::Logging.logger.info('ParsedFile#extract_doc_string!')
-      CucumberAnalytics::Logging.logger.debug('lines')
-      lines.each do |line|
-        CucumberAnalytics::Logging.logger.debug(line.chomp)
-      end
-
-      doc_block = []
-
-      doc_block << lines.first
-      lines.shift
-
-      until lines.first =~ /^\s*"""/
-        doc_block << lines.first
-        lines.shift
-      end
-
-      doc_block << lines.first
-      lines.shift
-
-      doc_block
-    end
-
-  end
-end

data/lib/cucumber_analytics/parsed_scenario.rb

@@ -1,67 +0,0 @@
-module CucumberAnalytics
-  class ParsedScenario < TestElement
-
-
-    attr_accessor :tags
-
-
-    # Creates a new ParsedScenario object and, if *source_lines* is provided,
-    # populates the object.
-    def initialize(source_lines = nil)
-      CucumberAnalytics::Logging.logger.info('ParsedScenario#initialize')
-      CucumberAnalytics::Logging.logger.debug('source lines')
-      source_lines.each { |line| CucumberAnalytics::Logging.logger.debug(line.chomp) } if source_lines
-
-      super
-
-      @tags = []
-
-      parse_scenario(source_lines) if source_lines
-    end
-
-    # Returns tags which are applicable to the scenario which have been
-    # inherited from the feature level.
-    def applied_tags
-      additional_tags = @parent_element.tags
-      additional_tags.concat(@parent_element.applied_tags) if @parent_element.respond_to?(:applied_tags)
-
-      additional_tags
-    end
-
-    # Returns all tags which are applicable to the scenario.
-    def all_tags
-      applied_tags + @tags
-    end
-
-
-    private
-
-
-    def parse_scenario(source_lines)
-      CucumberAnalytics::Logging.logger.info('ParsedScenario#parse_scenario')
-
-      parse_feature_element_tags(source_lines)
-      parse_feature_element(source_lines)
-      parse_test_element_steps(source_lines)
-    end
-
-    def parse_feature_element_description(source_lines)
-      CucumberAnalytics::Logging.logger.info('ParsedScenario#parse_feature_element_description')
-      CucumberAnalytics::Logging.logger.debug('source lines')
-      source_lines.each do |line|
-        CucumberAnalytics::Logging.logger.debug(line.chomp)
-      end
-
-      until source_lines.first =~ /^\s*(?:(?:Given )|(?:When )|(?:Then )|(?:And )|(?:\* ))/ or
-          source_lines.empty?
-
-        unless World.ignored_line?(source_lines.first)
-          @description << source_lines.first.strip
-        end
-
-        source_lines.shift
-      end
-    end
-
-  end
-end

data/lib/cucumber_analytics/parsed_scenario_outline.rb

@@ -1,122 +0,0 @@
-module CucumberAnalytics
-  class ParsedScenarioOutline < TestElement
-
-
-    attr_accessor :tags
-    attr_accessor :examples
-
-
-    # Creates a new ParsedScenarioOutline object and, if *source_lines* is
-    # provided, populates the object.
-    def initialize(source_lines = nil)
-      CucumberAnalytics::Logging.logger.info('ParsedScenarioOutline#initialize')
-      CucumberAnalytics::Logging.logger.debug('source lines')
-      source_lines.each { |line| CucumberAnalytics::Logging.logger.debug(line.chomp) } if source_lines
-
-      super
-
-      @tags = []
-      @examples = []
-
-      parse_outline(source_lines) if source_lines
-    end
-
-    # Returns the immediate child elements of the outline (i.e. its example
-    # blocks).
-    def contains
-      @examples
-    end
-
-    # Returns tags which have been inherited from the feature level.
-    def applied_tags
-      additional_tags = @parent_element.tags
-      additional_tags.concat(@parent_element.applied_tags) if @parent_element.respond_to?(:applied_tags)
-
-      additional_tags
-    end
-
-    # Returns all tags which are applicable to the scenario.
-    def all_tags
-      applied_tags + @tags
-    end
-
-
-    private
-
-
-    def parse_outline(source_lines)
-      CucumberAnalytics::Logging.logger.info('ParsedScenarioOutline#parse_outline')
-
-      parse_feature_element_tags(source_lines)
-      parse_feature_element(source_lines)
-      parse_test_element_steps(source_lines)
-      parse_outline_examples(source_lines)
-    end
-
-    def parse_feature_element_description(source_lines)
-      CucumberAnalytics::Logging.logger.info('ParsedScenarioOutline#parse_feature_element_description')
-      CucumberAnalytics::Logging.logger.debug('source lines')
-      source_lines.each do |line|
-        CucumberAnalytics::Logging.logger.debug(line.chomp)
-      end
-
-      until source_lines.first =~ /^\s*(?:(?:Given )|(?:When )|(?:Then )|(?:And )|(?:\* )| (?:Examples: ))/ or
-          source_lines.empty?
-
-        unless World.ignored_line?(source_lines.first)
-          @description << source_lines.first.strip
-        end
-
-        source_lines.shift
-      end
-    end
-
-    def parse_outline_examples(source_lines)
-      CucumberAnalytics::Logging.logger.info('ParsedScenarioOutline#parse_outline_examples')
-      CucumberAnalytics::Logging.logger.debug('source lines')
-      source_lines.each do |line|
-        CucumberAnalytics::Logging.logger.debug(line.chomp)
-      end
-
-
-      until source_lines.empty?
-        example_lines = []
-
-        # collect the tag lines
-        until source_lines.first =~ /^\s*Examples:/
-          example_lines << source_lines.first
-          source_lines.shift
-        end
-
-        example_lines << source_lines.first
-        source_lines.shift
-
-        # collect the description lines
-        until (source_lines.first =~ /^\s*\|/) or source_lines.empty?
-          example_lines << source_lines.first
-          source_lines.shift
-        end
-
-        # collect everything else up to the next example
-        until (source_lines.first =~ /^\s*Examples:/) or source_lines.empty?
-          example_lines << source_lines.first
-          source_lines.shift
-        end
-
-        # backtrack in order to not end up stealing the next test's tag lines
-        unless source_lines.empty?
-          while  (example_lines.last =~ /^\s*@/) or World.ignored_line?(example_lines.last)
-            source_lines = [example_lines.pop].concat(source_lines)
-          end
-        end
-
-        # use the collected lines to create an example
-        example = OutlineExample.new(example_lines)
-        example.parent_element = self
-
-        @examples << example
-      end
-    end
-
-  end
-end

data/spec/background_spec.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-
-SimpleCov.command_name('ParsedBackground') unless RUBY_VERSION.to_s < '1.9.0'
-
-describe "ParsedBackground" do
-
-  it 'knows its parent element' do
-    file_path = "#{@default_file_directory}/#{@default_feature_file_name}"
-
-    File.open(file_path, "w") { |file|
-      file.puts('Feature: Test feature')
-      file.puts('  Background: Test background')
-    }
-
-    file = CucumberAnalytics::ParsedFile.new(file_path)
-
-    feature = file.feature
-    background = feature.background
-
-    background.parent_element.should equal feature
-  end
-
-end

data/spec/directory_spec.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-
-SimpleCov.command_name('ParsedDirectory') unless RUBY_VERSION.to_s < '1.9.0'
-
-describe "ParsedDirectory" do
-
-  it 'knows its parent element' do
-    directory = @default_file_directory
-    nested_directory = "#{directory}/nested_directory"
-    FileUtils.mkdir(nested_directory)
-
-    directory = CucumberAnalytics::ParsedDirectory.new(@default_file_directory)
-    nested_directory = directory.feature_directories.first
-
-    nested_directory.parent_element.should equal directory
-  end
-
-end

data/spec/example_spec.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-
-SimpleCov.command_name('OutlineExample') unless RUBY_VERSION.to_s < '1.9.0'
-
-describe "OutlineExample" do
-
-  it "knows all of its tags" do
-    feature = CucumberAnalytics::ParsedFeature.new
-    feature.tags = ['@feature_tag']
-    outline = CucumberAnalytics::ParsedScenarioOutline.new
-    outline.tags = ['@outline_tag']
-    example = CucumberAnalytics::OutlineExample.new
-    example.tags = ['@example_tag']
-
-    outline.parent_element = feature
-    example.parent_element = outline
-    example.all_tags.sort.should == ['@feature_tag', '@outline_tag', '@example_tag'].sort
-  end
-
-  it 'knows its parent element' do
-    file_path = "#{@default_file_directory}/#{@default_feature_file_name}"
-
-    File.open(file_path, "w") { |file|
-      file.puts('Feature: Test feature')
-      file.puts('  Scenario Outline: Test outline')
-      file.puts('  Examples: test examples')
-    }
-
-    file = CucumberAnalytics::ParsedFile.new(file_path)
-
-    outline = file.feature.tests.first
-    example = outline.examples.first
-
-    example.parent_element.should equal outline
-  end
-
-end

data/spec/file_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-
-SimpleCov.command_name('ParsedFile') unless RUBY_VERSION.to_s < '1.9.0'
-
-describe "ParsedFile" do
-
-  it 'knows its parent element' do
-    file_path = "#{@default_file_directory}/#{@default_feature_file_name}"
-
-    File.open(file_path, "w") { |file|
-      file.puts('Feature: Test feature')
-    }
-
-    directory = CucumberAnalytics::ParsedDirectory.new(@default_file_directory)
-    file = directory.feature_files.first
-
-    file.parent_element.should equal directory
-  end
-
-end

data/spec/outline_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-
-SimpleCov.command_name('ParsedOutline') unless RUBY_VERSION.to_s < '1.9.0'
-
-describe "ParsedOutline" do
-
-  it "knows all of its tags" do
-    feature = CucumberAnalytics::ParsedFeature.new
-    feature.tags = ['@feature_tag']
-    outline = CucumberAnalytics::ParsedScenarioOutline.new
-    outline.tags = ['@outline_tag']
-
-    outline.parent_element = feature
-    outline.all_tags.sort.should == ['@feature_tag', '@outline_tag'].sort
-  end
-
-  it 'knows its parent element' do
-    file_path = "#{@default_file_directory}/#{@default_feature_file_name}"
-
-    File.open(file_path, "w") { |file|
-      file.puts('Feature: Test feature')
-      file.puts('  Scenario Outline: Test outline')
-    }
-
-    file = CucumberAnalytics::ParsedFile.new(file_path)
-
-    feature = file.feature
-    outline = feature.tests.first
-
-    outline.parent_element.should equal feature
-  end
-end