cuke_slicer 1.0.0 → 2.0.0

data/lib/cuke_slicer/extractors/file_extractor.rb

@@ -0,0 +1,32 @@
+require "cuke_slicer/helpers/matching_helpers"
+require "cuke_slicer/helpers/filter_helpers"
+require "cuke_slicer/helpers/extraction_helpers"
+
+
+module CukeSlicer
+  class FileExtractor
+
+    include ExtractionHelpers
+
+
+    def extract(target, filters, format, &block)
+      Array.new.tap do |test_cases|
+        unless target.feature.nil?
+          tests = target.feature.tests
+
+          runnable_elements = extract_runnable_elements(extract_runnable_block_elements(tests, filters, &block))
+
+          runnable_elements.each do |element|
+            case
+              when format == :file_line
+                test_cases << "#{element.get_ancestor(:feature_file).path}:#{element.source_line}"
+              when format == :test_object
+                test_cases << element
+            end
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/cuke_slicer/filters/filter_set.rb

@@ -0,0 +1,42 @@
+require "cuke_slicer/helpers/helpers"
+require "cuke_slicer/collections/tag_collection"
+require "cuke_slicer/collections/path_collection"
+
+
+module CukeSlicer
+  class FilterSet
+
+    include Helpers
+
+
+    def initialize filter_type, filter_value
+      self.filter_type = filter_type
+      self.filter_value = filter_value
+    end
+
+    def validate
+      block_unknown
+      block_invalid
+
+      if filter_value.is_a?(Array)
+        TagCollection.new(filter_value).validate if is_tag?(filter_type)
+        PathCollection.new(filter_value).validate if is_path?(filter_type)
+      end
+    end
+
+
+    private
+
+
+    def block_unknown
+      raise(ArgumentError, "Unknown filter '#{filter_type}'") unless CukeSlicer::Slicer.known_filters.include?(filter_type)
+    end
+
+    def block_invalid
+      raise(ArgumentError, "Invalid filter '#{filter_value}'. Must be a String, Regexp, or Array thereof. Got #{filter_value.class}") unless str_regex_arr?(filter_value)
+    end
+
+    attr_accessor :filter_type, :filter_value
+
+  end
+end

data/lib/cuke_slicer/helpers/extraction_helpers.rb

@@ -0,0 +1,40 @@
+module CukeSlicer
+  module ExtractionHelpers
+
+    include FilterHelpers
+
+
+    def extract_runnable_block_elements(things, filters, &block)
+      Array.new.tap do |elements|
+        things.each do |thing|
+          if thing.is_a?(CukeModeler::Outline)
+            elements.concat(thing.examples)
+          else
+            elements << thing
+          end
+        end
+
+        filter_excluded_paths(elements, filters[:excluded_paths])
+        filter_included_paths(elements, filters[:included_paths])
+        filter_excluded_tags(elements, filters[:excluded_tags])
+        filter_included_tags(elements, filters[:included_tags])
+
+        apply_custom_filter(elements, &block)
+      end
+    end
+
+    def extract_runnable_elements(things)
+      Array.new.tap do |elements|
+        things.each do |thing|
+          if thing.is_a?(CukeModeler::Example)
+            # Slicing in order to remove the parameter row element
+            elements.concat(thing.row_elements.slice(1, thing.row_elements.count - 1))
+          else
+            elements << thing
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/cuke_slicer/helpers/filter_helpers.rb

@@ -0,0 +1,60 @@
+module CukeSlicer
+  module FilterHelpers
+
+    include MatchingHelpers
+
+
+    def apply_custom_filter(elements, &block)
+      if block
+        elements.reject! do |element|
+          block.call(element)
+        end
+      end
+    end
+
+    def filter_excluded_tags(elements, filters)
+      if filters
+        filters = [filters] unless filters.is_a?(Array)
+
+        unless filters.empty?
+          elements.reject! do |element|
+            matching_tag?(element, filters)
+          end
+        end
+      end
+    end
+
+    def filter_included_tags(elements, filters)
+      if filters
+        filters = [filters] unless filters.is_a?(Array)
+
+        elements.keep_if do |element|
+          matching_tag?(element, filters)
+        end
+      end
+    end
+
+    def filter_excluded_paths(elements, filters)
+      if filters
+        filters = [filters] unless filters.is_a?(Array)
+
+        elements.reject! do |element|
+          matching_path?(element, filters)
+        end
+      end
+    end
+
+    def filter_included_paths(elements, filters)
+      if filters
+        filters = [filters] unless filters.is_a?(Array)
+
+        unless filters.empty?
+          elements.keep_if do |element|
+            matching_path?(element, filters)
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/cuke_slicer/helpers/helpers.rb

@@ -0,0 +1,21 @@
+module CukeSlicer
+  module Helpers
+
+    def str_regex?(parameter)
+      parameter.is_a?(String) or parameter.is_a?(Regexp)
+    end
+
+    def str_regex_arr?(parameter)
+      parameter.is_a?(String) or parameter.is_a?(Regexp) or parameter.is_a?(Array)
+    end
+
+    def is_tag?(parameter)
+      parameter.to_s =~ /tag/
+    end
+
+    def is_path?(parameter)
+      parameter.to_s =~ /path/
+    end
+
+  end
+end

data/lib/cuke_slicer/helpers/matching_helpers.rb

@@ -0,0 +1,47 @@
+module CukeSlicer
+  module MatchingHelpers
+
+    def matching_tag?(element, filters)
+      filters.each do |filter|
+        if filter.is_a?(Array)
+          filter_match = or_filter_match(element, filter)
+        else
+          filter_match = and_filter_match(element, filter)
+        end
+
+        return false unless filter_match
+      end
+
+      true
+    end
+
+    def and_filter_match(element, filter)
+      filter_match(element, filter)
+    end
+
+    def or_filter_match(element, filters)
+      filters.any? do |filter|
+        filter_match(element, filter)
+      end
+    end
+
+    def filter_match(element, filter)
+      if filter.is_a?(Regexp)
+        element.all_tags.any? { |tag| tag =~ filter }
+      else
+        element.all_tags.include?(filter)
+      end
+    end
+
+    def matching_path?(element, filters)
+      filters.any? do |filtered_path|
+        if filtered_path.is_a?(Regexp)
+          element.get_ancestor(:feature_file).path =~ filtered_path
+        else
+          element.get_ancestor(:feature_file).path == filtered_path
+        end
+      end
+    end
+
+  end
+end

data/lib/cuke_slicer/slicer.rb

@@ -1,3 +1,8 @@
+require "cuke_slicer/extractors/directory_extractor"
+require "cuke_slicer/extractors/file_extractor"
+require "cuke_slicer/filters/filter_set"
+
+
 module CukeSlicer
 
   # The object responsible for slicing up a Cucumber test suite into discrete test cases.
@@ -13,12 +18,16 @@ module CukeSlicer
     # exposes the underlying modeling objects and knowledge of how they work is then required to make good use of the
     # filter.
     #
+    # Finally, the test cases can be provided as a collection of file:line strings or as a collection of the object
+    # types used to represent test cases by the underlying modeling library.
+    #
     # @param target [String] the location that will be sliced up
     # @param filters [Hash] the filters that will be applied to the sliced test cases
-    def slice(target, filters = {}, &block)
+    # @param format [Symbol] the type of output: :file_line or :test_object
+    def slice(target, filters = {}, format, &block)
       validate_target(target)
       validate_filters(filters)
-
+      validate_format(format)
 
       begin
         target = File.directory?(target) ? CukeModeler::Directory.new(target) : CukeModeler::FeatureFile.new(target)
@@ -27,9 +36,9 @@ module CukeSlicer
       end
 
       if target.is_a?(CukeModeler::Directory)
-        sliced_tests = extract_test_cases_from_directory(target, filters, &block)
+        sliced_tests = DirectoryExtractor.new.extract(target, filters, format, &block)
       else
-        sliced_tests = extract_test_cases_from_file(target, filters, &block)
+        sliced_tests = FileExtractor.new.extract(target, filters, format, &block)
       end
 
       sliced_tests
@@ -51,198 +60,13 @@ module CukeSlicer
       raise(ArgumentError, "File or directory '#{target}' does not exist") unless File.exists?(target.to_s)
     end
 
-    def validate_filters(filter_sets)
-      filter_sets.each do |filter_type, filter_value|
-        raise(ArgumentError, "Unknown filter '#{filter_type}'") unless self.class.known_filters.include?(filter_type)
-        raise(ArgumentError, "Invalid filter '#{filter_value}'. Must be a String, Regexp, or Array thereof. Got #{filter_value.class}") unless filter_value.is_a?(String) or filter_value.is_a?(Regexp) or filter_value.is_a?(Array)
-
-        if filter_value.is_a?(Array)
-          validate_tag_collection(filter_value) if filter_type.to_s =~ /tag/
-          validate_path_collection(filter_value) if filter_type.to_s =~ /path/
-        end
-      end
-    end
-
-    def validate_tag_collection(filter_collection)
-      filter_collection.each do |filter|
-        raise(ArgumentError, "Filter '#{filter}' must be a String, Regexp, or Array. Got #{filter.class}") unless filter.is_a?(String) or filter.is_a?(Regexp) or filter.is_a?(Array)
-
-        validate_nested_tag_collection(filter) if filter.is_a?(Array)
-      end
-    end
-
-    def validate_nested_tag_collection(filter_collection)
-      filter_collection.each do |filter|
-        raise(ArgumentError, "Tag filters cannot be nested more than one level deep.") if filter.is_a?(Array)
-        raise(ArgumentError, "Filter '#{filter}' must be a String or Regexp. Got #{filter.class}") unless filter.is_a?(String) or filter.is_a?(Regexp)
-      end
-    end
-
-    def validate_path_collection(filter_collection)
-      filter_collection.each do |filter|
-        raise(ArgumentError, "Filter '#{filter}' must be a String or Regexp. Got #{filter.class}") unless filter.is_a?(String) or filter.is_a?(Regexp)
-      end
-    end
-
-    def extract_test_cases_from_directory(target, filters, &block)
-      entries = Dir.entries(target.path)
-      entries.delete '.'
-      entries.delete '..'
-
-      Array.new.tap do |test_cases|
-        entries.each do |entry|
-          entry = "#{target.path}/#{entry}"
-
-          case
-            when File.directory?(entry)
-              test_cases.concat(extract_test_cases_from_directory(CukeModeler::Directory.new(entry), filters, &block))
-            when entry =~ /\.feature$/
-              test_cases.concat(extract_test_cases_from_file(CukeModeler::FeatureFile.new(entry), filters, &block))
-            else
-              # Non-feature files are ignored
-          end
-        end
-      end
-    end
-
-    def extract_test_cases_from_file(target, filters, &block)
-      Array.new.tap do |test_cases|
-        unless target.feature.nil?
-          tests = target.feature.tests
-
-          runnable_elements = extract_runnable_elements(extract_runnable_block_elements(tests, filters))
-
-          apply_custom_filter(runnable_elements, &block)
-
-          runnable_elements.each do |element|
-            test_cases << "#{element.get_ancestor(:feature_file).path}:#{element.source_line}"
-          end
-        end
-      end
-    end
-
-    def extract_runnable_block_elements(things, filters)
-      Array.new.tap do |elements|
-        things.each do |thing|
-          if thing.is_a?(CukeModeler::Outline)
-            elements.concat(thing.examples)
-          else
-            elements << thing
-          end
-        end
-
-        filter_excluded_paths(elements, filters[:excluded_paths])
-        filter_included_paths(elements, filters[:included_paths])
-        filter_excluded_tags(elements, filters[:excluded_tags])
-        filter_included_tags(elements, filters[:included_tags])
-      end
-    end
-
-    def extract_runnable_elements(things)
-      Array.new.tap do |elements|
-        things.each do |thing|
-          if thing.is_a?(CukeModeler::Example)
-            # Slicing in order to remove the parameter row element
-            elements.concat(thing.row_elements.slice(1, thing.row_elements.count - 1))
-          else
-            elements << thing
-          end
-        end
-      end
-    end
-
-    def apply_custom_filter(elements, &block)
-      if block
-        elements.reject! do |element|
-          block.call(element)
-        end
-      end
-    end
-
-    def filter_excluded_tags(elements, filters)
-      if filters
-        filters = [filters] unless filters.is_a?(Array)
-
-        unless filters.empty?
-          elements.reject! do |element|
-            matching_tag?(element, filters)
-          end
-        end
-      end
-    end
-
-    def filter_included_tags(elements, filters)
-      if filters
-        filters = [filters] unless filters.is_a?(Array)
-
-        elements.keep_if do |element|
-          matching_tag?(element, filters)
-        end
-      end
-    end
-
-    def filter_excluded_paths(elements, filters)
-      if filters
-        filters = [filters] unless filters.is_a?(Array)
-
-        elements.reject! do |element|
-          matching_path?(element, filters)
-        end
-      end
-    end
-
-    def filter_included_paths(elements, filters)
-      if filters
-        filters = [filters] unless filters.is_a?(Array)
-
-        unless filters.empty?
-          elements.keep_if do |element|
-            matching_path?(element, filters)
-          end
-        end
-      end
-    end
-
-    def matching_tag?(element, filters)
-      filters.each do |filter|
-        if filter.is_a?(Array)
-          filter_match = or_filter_match(element, filter)
-        else
-          filter_match = and_filter_match(element, filter)
-        end
-
-        return false unless filter_match
-      end
-
-      true
-    end
-
-    def and_filter_match(element, filter)
-      filter_match(element, filter)
+    def validate_filters(filters)
+      filter_sets = filters.map { |filter_type, value| FilterSet.new(filter_type, value) }
+      filter_sets.each(&:validate)
     end
 
-    def or_filter_match(element, filters)
-      filters.any? do |filter|
-        filter_match(element, filter)
-      end
-    end
-
-    def filter_match(element, filter)
-      if filter.is_a?(Regexp)
-        element.all_tags.any? { |tag| tag =~ filter }
-      else
-        element.all_tags.include?(filter)
-      end
-    end
-
-    def matching_path?(element, filters)
-      filters.any? do |filtered_path|
-        if filtered_path.is_a?(Regexp)
-          element.get_ancestor(:feature_file).path =~ filtered_path
-        else
-          element.get_ancestor(:feature_file).path == filtered_path
-        end
-      end
+    def validate_format(format)
+      raise(ArgumentError, "Invalid Output Format: #{format}") unless [:test_object, :file_line].include?(format)
     end
 
   end