guard-cucumber 1.4.1 → 1.5.1

data/lib/guard/cucumber/inspector.rb

@@ -1,12 +1,10 @@
 module Guard
   class Cucumber
-
     # The inspector verifies of the changed paths are valid
     # for Guard::Cucumber.
     #
     module Inspector
       class << self
-
         # Clean the changed paths and return only valid
         # Cucumber features.
         #
@@ -14,10 +12,12 @@ module Guard
         # @param [Array<String>] feature_sets the feature sets
         # @return [Array<String>] the valid feature files
         #
-        def clean(paths, feature_sets)
+        def clean(paths, sets)
           paths.uniq!
           paths.compact!
-          paths = paths.select { |p| cucumber_file?(p, feature_sets) || cucumber_folder?(p, feature_sets) }
+          paths = paths.select do |p|
+            cucumber_file?(p, sets) || cucumber_folder?(p, sets)
+          end
           paths = paths.delete_if { |p| included_in_other_path?(p, paths) }
           clear_cucumber_files_list
           paths
@@ -32,7 +32,8 @@ module Guard
         # @return [Boolean] when the file is the feature folder
         #
         def cucumber_folder?(path, feature_sets)
-          path.match(/^\/?(#{ feature_sets.join('|') })/) && !path.match(/\..+$/)
+          sets = feature_sets.join("|")
+          path.match(/^\/?(#{ sets })/) && !path.match(/\..+$/)
         end
 
         # Tests if the file is valid.
@@ -42,7 +43,7 @@ module Guard
         # @return [Boolean] when the file valid
         #
         def cucumber_file?(path, feature_sets)
-          cucumber_files(feature_sets).include?(path.split(':').first)
+          cucumber_files(feature_sets).include?(path.split(":").first)
         end
 
         # Scans the project and keeps a list of all
@@ -53,7 +54,8 @@ module Guard
         # @return [Array<String>] the valid files
         #
         def cucumber_files(feature_sets)
-          @cucumber_files ||= Dir.glob("#{ feature_sets.join(',') }/**/*.feature")
+          glob = "#{ feature_sets.join(",") }/**/*.feature"
+          @cucumber_files ||= Dir.glob(glob)
         end
 
         # Clears the list of features in this project.
@@ -70,8 +72,16 @@ module Guard
         #
         def included_in_other_path?(path, paths)
           paths = paths.select { |p| p != path }
-          massaged = path[0...(path.index(':') || path.size)]
-          paths.any? { |p| (path.include?(p) && (path.gsub(p, '')).include?('/')) || massaged.include?(p) }
+          massaged = path[0...(path.index(":") || path.size)]
+          paths.any? { |p| _path_includes(path, p, massaged) }
+        end
+
+        private
+
+        def _path_includes(path, p, massaged)
+          includes = path.include?(p)
+          return true if includes && path.gsub(p, "").include?("/")
+          massaged.include?(p)
         end
       end
     end

data/lib/guard/cucumber/inspector.rb.orig

@@ -0,0 +1,77 @@
+module Guard
+  class Cucumber
+    # The inspector verifies of the changed paths are valid
+    # for Guard::Cucumber.
+    #
+    module Inspector
+      class << self
+        # Clean the changed paths and return only valid
+        # Cucumber features.
+        #
+        # @param [Array<String>] paths the changed paths
+        # @param [Array<String>] feature_sets the feature sets
+        # @return [Array<String>] the valid feature files
+        #
+        def clean(paths, feature_sets)
+          paths.uniq!
+          paths.compact!
+          paths = paths.select { |p| cucumber_file?(p, feature_sets) || cucumber_folder?(p, feature_sets) }
+          paths = paths.delete_if { |p| included_in_other_path?(p, paths) }
+          clear_cucumber_files_list
+          paths
+        end
+
+        private
+
+        # Tests if the file is the features folder.
+        #
+        # @param [String] path the file
+        # @param [Array<String>] feature_sets the feature sets
+        # @return [Boolean] when the file is the feature folder
+        #
+        def cucumber_folder?(path, feature_sets)
+          path.match(/^\/?(#{ feature_sets.join('|') })/) && !path.match(/\..+$/)
+        end
+
+        # Tests if the file is valid.
+        #
+        # @param [String] path the file
+        # @param [Array<String>] feature_sets the feature sets
+        # @return [Boolean] when the file valid
+        #
+        def cucumber_file?(path, feature_sets)
+          cucumber_files(feature_sets).include?(path.split(":").first)
+        end
+
+        # Scans the project and keeps a list of all
+        # feature files in the `features` directory.
+        #
+        # @see #clear_jasmine_specs
+        # @param [Array<String>] feature_sets the feature sets
+        # @return [Array<String>] the valid files
+        #
+        def cucumber_files(feature_sets)
+          @cucumber_files ||= Dir.glob("#{ feature_sets.join(",") }/**/*.feature")
+        end
+
+        # Clears the list of features in this project.
+        #
+        def clear_cucumber_files_list
+          @cucumber_files = nil
+        end
+
+        # Checks if the given path is already contained
+        # in the paths list.
+        #
+        # @param [Sting] path the path to test
+        # @param [Array<String>] paths the list of paths
+        #
+        def included_in_other_path?(path, paths)
+          paths = paths.select { |p| p != path }
+          massaged = path[0...(path.index(":") || path.size)]
+          paths.any? { |p| (path.include?(p) && (path.gsub(p, "")).include?("/")) || massaged.include?(p) }
+        end
+      end
+    end
+  end
+end

data/lib/guard/cucumber/notification_formatter.rb

@@ -1,13 +1,13 @@
-require 'guard'
-require 'guard/notifier'
-require 'cucumber/formatter/console'
-require 'cucumber/formatter/io'
+require "guard"
+require "guard/notifier"
+require "cucumber/formatter/console"
+require "cucumber/formatter/io"
 
 module Guard
   class Cucumber
-
     # The notification formatter is a Cucumber formatter that Guard::Cucumber
-    # passes to the Cucumber binary. It writes the `rerun.txt` file with the failed features
+    # passes to the Cucumber binary. It writes the `rerun.txt` file with the
+    # failed features
     # an creates system notifications.
     #
     # @see https://github.com/cucumber/cucumber/wiki/Custom-Formatters
@@ -23,7 +23,7 @@ module Guard
       # @param [String, IO] path_or_io the path or IO to the feature file
       # @param [Hash] options the options
       #
-      def initialize(step_mother, path_or_io, options)
+      def initialize(step_mother, _path_or_io, options)
         @options = options
         @file_names = []
         @step_mother = step_mother
@@ -33,7 +33,7 @@ module Guard
       #
       # @param [Array[Cucumber::Ast::Feature]] features the ran features
       #
-      def after_features(features)
+      def after_features(_features)
         notify_summary
         write_rerun_features if !@file_names.empty?
       end
@@ -53,7 +53,7 @@ module Guard
       #
       def after_feature_element(feature_element)
         if @rerun
-          @file_names << feature_element.file_colon_line
+          @file_names << feature_element.location.to_s
           @rerun = false
         end
       end
@@ -65,14 +65,16 @@ module Guard
       # @param [Symbol] status the status of the step
       # @param [Integer] source_indent the source indentation
       # @param [Cucumber::Ast::Background] background the feature background
-      # @param [String] file name and line number describing where the step is used
+      # @param [String] file name and line number describing where the step is
+      # used
       #
-      def step_name(keyword, step_match, status, source_indent, background, file_colon_line)
+      def step_name(_keyword, step_match, status, _src_indent, _bckgnd, _loc)
         if [:failed, :pending, :undefined].index(status)
           @rerun = true
           step_name = step_match.format_args(lambda { |param| "*#{ param }*" })
 
-          ::Guard::Notifier.notify step_name, :title => @feature_name, :image => icon_for(status)
+          options = { title: @feature_name, image: icon_for(status) }
+          ::Guard::Notifier.notify(step_name, options)
         end
       end
 
@@ -84,22 +86,25 @@ module Guard
       def notify_summary
         icon, messages = nil, []
 
-        [:failed, :skipped, :undefined, :pending, :passed].reverse.each do |status|
+        [:failed, :skipped, :undefined, :pending, :passed].reverse.
+          each do |status|
           if step_mother.steps(status).any?
             step_icon = icon_for(status)
             icon = step_icon if step_icon
-            messages << dump_count(step_mother.steps(status).length, 'step', status.to_s)
+            len = step_mother.steps(status).length
+            messages << dump_count(len, "step", status.to_s)
           end
         end
 
-        ::Guard::Notifier.notify messages.reverse.join(', '), :title => 'Cucumber Results', :image => icon
+        msg = messages.reverse.join(", ")
+        ::Guard::Notifier.notify msg, title: "Cucumber Results", image: icon
       end
 
       # Writes the `rerun.txt` file containing all failed features.
       #
       def write_rerun_features
-        File.open('rerun.txt', 'w') do |f|
-          f.puts @file_names.join(' ')
+        File.open("rerun.txt", "w") do |f|
+          f.puts @file_names.join(" ")
         end
       end
 
@@ -110,17 +115,16 @@ module Guard
       #
       def icon_for(status)
         case status
-          when :passed
-            :success
-          when :pending, :undefined, :skipped
-            :pending
-          when :failed
-            :failed
-          else
-            nil
+        when :passed
+          :success
+        when :pending, :undefined, :skipped
+          :pending
+        when :failed
+          :failed
+        else
+          nil
         end
       end
-
     end
   end
 end

data/lib/guard/cucumber/notification_formatter.rb.orig

@@ -0,0 +1,124 @@
+require "guard"
+require "guard/notifier"
+require "cucumber/formatter/console"
+require "cucumber/formatter/io"
+
+module Guard
+  class Cucumber
+    # The notification formatter is a Cucumber formatter that Guard::Cucumber
+    # passes to the Cucumber binary. It writes the `rerun.txt` file with the failed features
+    # an creates system notifications.
+    #
+    # @see https://github.com/cucumber/cucumber/wiki/Custom-Formatters
+    #
+    class NotificationFormatter
+      include ::Cucumber::Formatter::Console
+
+      attr_reader :step_mother
+
+      # Initialize the formatter.
+      #
+      # @param [Cucumber::Runtime] step_mother the step mother
+      # @param [String, IO] path_or_io the path or IO to the feature file
+      # @param [Hash] options the options
+      #
+      def initialize(step_mother, _path_or_io, options)
+        @options = options
+        @file_names = []
+        @step_mother = step_mother
+      end
+
+      # Notification after all features have completed.
+      #
+      # @param [Array[Cucumber::Ast::Feature]] features the ran features
+      #
+      def after_features(_features)
+        notify_summary
+        write_rerun_features if !@file_names.empty?
+      end
+
+      # Before a feature gets run.
+      #
+      # @param [Cucumber::Ast::FeatureElement] feature_element
+      #
+      def before_feature_element(feature_element)
+        @rerun = false
+        @feature_name = feature_element.name
+      end
+
+      # After a feature gets run.
+      #
+      # @param [Cucumber::Ast::FeatureElement] feature_element
+      #
+      def after_feature_element(feature_element)
+        if @rerun
+          @file_names << feature_element.location.to_s
+          @rerun = false
+        end
+      end
+
+      # Gets called when a step is done.
+      #
+      # @param [String] keyword the keyword
+      # @param [Cucumber::StepMatch] step_match the step match
+      # @param [Symbol] status the status of the step
+      # @param [Integer] source_indent the source indentation
+      # @param [Cucumber::Ast::Background] background the feature background
+      # @param [String] file name and line number describing where the step is used
+      #
+      def step_name(_keyword, step_match, status, _source_indent, _background, _location)
+        if [:failed, :pending, :undefined].index(status)
+          @rerun = true
+          step_name = step_match.format_args(lambda { |param| "*#{ param }*" })
+
+          ::Guard::Notifier.notify step_name, title: @feature_name, image: icon_for(status)
+        end
+      end
+
+      private
+
+      # Notify the user with a system notification about the
+      # result of the feature tests.
+      #
+      def notify_summary
+        icon, messages = nil, []
+
+        [:failed, :skipped, :undefined, :pending, :passed].reverse.each do |status|
+          if step_mother.steps(status).any?
+            step_icon = icon_for(status)
+            icon = step_icon if step_icon
+            messages << dump_count(step_mother.steps(status).length, "step", status.to_s)
+          end
+        end
+
+        ::Guard::Notifier.notify messages.reverse.join(", "), title: "Cucumber Results", image: icon
+      end
+
+      # Writes the `rerun.txt` file containing all failed features.
+      #
+      def write_rerun_features
+        File.open("rerun.txt", "w") do |f|
+          f.puts @file_names.join(" ")
+        end
+      end
+
+      # Gives the icon name to use for the status.
+      #
+      # @param [Symbol] status the cucumber status
+      # @return [Symbol] the Guard notification symbol
+      #
+      def icon_for(status)
+        case status
+          when :passed
+            :success
+          when :pending, :undefined, :skipped
+            :pending
+          when :failed
+            :failed
+          else
+            nil
+        end
+      end
+    end
+  end
+end

data/lib/guard/cucumber/runner.rb

@@ -1,31 +1,41 @@
 module Guard
   class Cucumber
-
     # The Cucumber runner handles the execution of the cucumber binary.
     #
     module Runner
       class << self
-
         # Run the supplied features.
         #
         # @param [Array<String>] paths the feature files or directories
         # @param [Hash] options the options for the execution
-        # @option options [Array<String>] :feature_sets a list of non-standard feature directory/ies
+        # @option options [Array<String>] :feature_sets a list of non-standard
+        # feature directory/ies
         # @option options [Boolean] :bundler use bundler or not
-        # @option options [Array<String>] :rvm a list of rvm version to use for the test
+        # @option options [Array<String>] :rvm a list of rvm version to use for
+        # the test
         # @option options [Boolean] :notification show notifications
-        # @option options [String] :command_prefix allows adding an additional prefix to the cucumber command. Ideal for running xvfb-run for terminal only cucumber tests.
+        # @option options [String] :command_prefix allows adding an additional
+        # prefix to the cucumber command. Ideal for running xvfb-run for
+        # terminal only cucumber tests.
         # @return [Boolean] the status of the execution
         #
-        def run(paths, options = { })
+        def run(paths, options = {})
           return false if paths.empty?
 
-          message = options[:message] || (paths == ['features'] ? "Running all Cucumber features: #{ cucumber_command(paths, options) }" : "Running Cucumber features: #{ cucumber_command(paths, options) }")
-          paths   = options[:focus_on] ? Focuser.focus(paths, options[:focus_on]) : paths
+          cmd = cucumber_command(paths, options)
+
+          msg1 = "Running all Cucumber features: #{cmd}"
+          msg2 = "Running Cucumber features: #{cmd}"
+          msg = (paths == ["features"] ? msg1 : msg2)
 
-          UI.info message, :reset => true
+          message = options[:message] || msg
 
-          system(cucumber_command(paths, options))
+          paths = Focuser.focus(paths, options[:focus_on]) if options[:focus_on]
+          cmd = cucumber_command(paths, options)
+
+          UI.info message, reset: true
+
+          system(cmd)
         end
 
         private
@@ -35,28 +45,30 @@ module Guard
         # @param [Array<String>] paths the feature files or directories
         # @param [Hash] options the options for the execution
         # @option options [Boolean] :bundler use bundler or not
-        # @option options [Array<String>] :rvm a list of rvm version to use for the test
+        # @option options [Array<String>] :rvm a list of rvm version to use for
+        # the test
         # @option options [Boolean] :notification show notifications
-        # @option options [String] :command_prefix allows adding an additional prefix to the cucumber command. Ideal for running xvfb-run for terminal only cucumber tests.
+        # @option options [String] :command_prefix allows adding an additional
+        # prefix to the cucumber command. Ideal for running xvfb-run for
+        # terminal only cucumber tests.
         # @return [String] the Cucumber command
         #
         def cucumber_command(paths, options)
           cmd = []
           cmd << options[:command_prefix] if options[:command_prefix]
-          cmd << "rvm #{ options[:rvm].join(',') } exec" if options[:rvm].is_a?(Array)
-          cmd << 'bundle exec' if bundler? && options[:bundler] != false
+          if options[:rvm].is_a?(Array)
+            cmd << "rvm #{ options[:rvm].join(",") } exec"
+          end
+
+          cmd << "bundle exec" if bundler? && options[:bundler] != false
           cmd << cucumber_exec(options)
           cmd << options[:cli] if options[:cli]
 
           if options[:notification] != false
-            notification_formatter_path = File.expand_path(File.join(File.dirname(__FILE__), 'notification_formatter.rb'))
-            cmd << "--require #{ notification_formatter_path }"
-            cmd << '--format Guard::Cucumber::NotificationFormatter'
-            cmd << "--out #{ null_device }"
-            cmd << (options[:feature_sets] || ['features']).map {|path| "--require #{ path }"}.join(' ')
+            _add_notification(cmd, options)
           end
 
-          (cmd + paths).join(' ')
+          (cmd + paths).join(" ")
         end
 
         # Simple test if binstubs prefix should be used.
@@ -64,10 +76,11 @@ module Guard
         # @return [String] Cucumber executable
         #
         def cucumber_exec(options = {})
-            options[:binstubs] == true ? 'bin/cucumber' : 'cucumber'
+          options[:binstubs] == true ? "bin/cucumber" : "cucumber"
         end
 
-        # Simple test if bundler should be used. it just checks for the `Gemfile`.
+        # Simple test if bundler should be used. it just checks for the
+        # `Gemfile`.
         #
         # @return [Boolean] bundler exists
         #
@@ -80,9 +93,23 @@ module Guard
         # @return [String] the name of the null device
         #
         def null_device
-          RUBY_PLATFORM.index('mswin') ? 'NUL' : '/dev/null'
+          RUBY_PLATFORM.index("mswin") ? "NUL" : "/dev/null"
         end
 
+        private
+
+        def _add_notification(cmd, options)
+          this_dir = File.dirname(__FILE__)
+          formatter_path = File.join(this_dir, "notification_formatter.rb")
+          notification_formatter_path = File.expand_path(formatter_path)
+
+          cmd << "--require #{ notification_formatter_path }"
+          cmd << "--format Guard::Cucumber::NotificationFormatter"
+          cmd << "--out #{ null_device }"
+          cmd << (options[:feature_sets] || ["features"]).map do |path|
+            "--require #{ path }"
+          end.join(" ")
+        end
       end
     end
   end