middleman-core 4.5.1 → 5.0.0.rc.1

data/lib/middleman-core/sitemap/store.rb

@@ -1,9 +1,9 @@
 # Used for merging results of metadata callbacks
-require 'active_support/core_ext/hash/deep_merge'
 require 'monitor'
 require 'hamster'
-
 require 'middleman-core/extensions'
+require 'middleman-core/sitemap/resource'
+require 'middleman-core/sitemap/resource_list_container'
 
 # Files on Disk
 ::Middleman::Extensions.register :sitemap_ondisk, auto_activate: :before_configuration do
@@ -47,12 +47,10 @@ end
   ::Middleman::Sitemap::Extensions::Ignores
 end
 
-require 'middleman-core/contracts'
-
 module Middleman
   # Sitemap namespace
   module Sitemap
-    ManipulatorDescriptor = Struct.new :name, :manipulator, :priority, :custom_name
+    ManipulatorDescriptor = Struct.new :name, :manipulator, :priority
 
     # The Store class
     #
@@ -61,20 +59,30 @@ module Middleman
     # which is the path relative to the source directory, minus any template
     # extensions. All "path" parameters used in this class are source paths.
     class Store
+      extend Forwardable
       include Contracts
 
+      def_delegators :@resources, :by_extensions, :by_destination_path, :by_path, :by_binary, :by_page_id, :by_extension, :by_source_extension, :by_source_extensions, :with_ignored, :without_ignored
+
+      # Backwards compat to old API from MM v4.
+      alias find_resource_by_path by_path
+      alias find_resource_by_destination_path by_destination_path
+
       Contract IsA['Middleman::Application']
       attr_reader :app
 
       Contract Num
       attr_reader :update_count
 
+      Contract ::Middleman::Sitemap::ResourceListContainer
+      attr_reader :resources
+
       # Initialize with parent app
       # @param [Middleman::Application] app
       Contract IsA['Middleman::Application'] => Any
       def initialize(app)
         @app = app
-        @resources = []
+        @resources = ResourceListContainer.new
         @rebuild_reasons = [:first_run]
         @update_count = 0
 
@@ -82,15 +90,14 @@ module Middleman
         @needs_sitemap_rebuild = true
 
         @lock = Monitor.new
-        reset_lookup_cache!
 
         @app.config_context.class.send :def_delegator, :app, :sitemap
       end
 
-      Contract Symbol, RespondTo[:manipulate_resource_list], Maybe[Or[Num, ArrayOf[Num]]], Maybe[Symbol] => Any
-      def register_resource_list_manipulators(name, manipulator, priority=50, custom_name=nil)
+      Contract Symbol, Or[RespondTo[:manipulate_resource_list], RespondTo[:manipulate_resource_list_container!]], Maybe[Or[Num, ArrayOf[Num]]] => Any
+      def register_resource_list_manipulators(name, manipulator, priority = 50)
         Array(priority || 50).each do |p|
-          register_resource_list_manipulator(name, manipulator, p, custom_name)
+          register_resource_list_manipulator(name, manipulator, p)
         end
       end
 
@@ -100,14 +107,13 @@ module Middleman
       # @param [Symbol] name Name of the manipulator for debugging
       # @param [#manipulate_resource_list] manipulator Resource list manipulator
       # @param [Numeric] priority Sets the order of this resource list manipulator relative to the rest. By default this is 50, and manipulators run in the order they are registered, but if a priority is provided then this will run ahead of or behind other manipulators.
-      # @param [Symbol] custom_name The method name to execute.
       # @return [void]
-      Contract Symbol, RespondTo[:manipulate_resource_list], Maybe[Num, Bool], Maybe[Symbol] => Any
-      def register_resource_list_manipulator(name, manipulator, priority=50, custom_name=nil)
+      Contract Symbol, Or[RespondTo[:manipulate_resource_list], RespondTo[:manipulate_resource_list_container!]], Maybe[Num, Bool] => Any
+      def register_resource_list_manipulator(name, manipulator, priority = 50)
         # The third argument used to be a boolean - handle those who still pass one
         priority = 50 unless priority.is_a? Numeric
         @resource_list_manipulators = @resource_list_manipulators.push(
-          ManipulatorDescriptor.new(name, manipulator, priority, custom_name)
+          ManipulatorDescriptor.new(name, manipulator, priority)
         )
 
         # The index trick is used so that the sort is stable - manipulators with the same priority
@@ -121,7 +127,7 @@ module Middleman
         rebuild_resource_list!(:"registered_new_manipulator_#{name}")
       end
 
-      # Rebuild the list of resources from scratch, using registed manipulators
+      # Rebuild the list of resources from scratch, using registered manipulators
       # @return [void]
       Contract Symbol => Any
       def rebuild_resource_list!(name)
@@ -132,62 +138,6 @@ module Middleman
         end
       end
 
-      # Find a resource given its original path
-      # @param [String] request_path The original path of a resource.
-      # @return [Middleman::Sitemap::Resource]
-      Contract String => Maybe[IsA['Middleman::Sitemap::Resource']]
-      def find_resource_by_path(request_path)
-        @lock.synchronize do
-          request_path = ::Middleman::Util.normalize_path(request_path)
-          ensure_resource_list_updated!
-          @_lookup_by_path[request_path]
-        end
-      end
-
-      # Find a resource given its destination path
-      # @param [String] request_path The destination (output) path of a resource.
-      # @return [Middleman::Sitemap::Resource]
-      Contract String => Maybe[IsA['Middleman::Sitemap::Resource']]
-      def find_resource_by_destination_path(request_path)
-        @lock.synchronize do
-          request_path = ::Middleman::Util.normalize_path(request_path)
-          ensure_resource_list_updated!
-          @_lookup_by_destination_path[request_path]
-        end
-      end
-
-      # Find a resource given its page id
-      # @param [String] page_id The page id.
-      # @return [Middleman::Sitemap::Resource]
-      Contract Or[String, Symbol] => Maybe[IsA['Middleman::Sitemap::Resource']]
-      def find_resource_by_page_id(page_id)
-        @lock.synchronize do
-          ensure_resource_list_updated!
-          @_lookup_by_page_id[page_id.to_s.to_sym]
-        end
-      end
-
-      # Get the array of all resources
-      # @param [Boolean] include_ignored Whether to include ignored resources
-      # @return [Array<Middleman::Sitemap::Resource>]
-      Contract Bool => ResourceList
-      def resources(include_ignored=false)
-        @lock.synchronize do
-          ensure_resource_list_updated!
-          if include_ignored
-            @resources
-          else
-            @resources_not_ignored ||= @resources.reject(&:ignored?)
-          end
-        end
-      end
-
-      # Invalidate our cached view of resource that are not ignored. If your extension
-      # adds ways to ignore files, you should call this to make sure #resources works right.
-      def invalidate_resources_not_ignored_cache!
-        @resources_not_ignored = nil
-      end
-
       # Get the URL path for an on-disk file
       # @param [String] file
       # @return [String]
@@ -196,9 +146,7 @@ module Middleman
         relative_path = file.is_a?(Pathname) ? file.to_s : file[:relative_path].to_s
 
         # Replace a file name containing automatic_directory_matcher with a folder
-        unless @app.config[:automatic_directory_matcher].nil?
-          relative_path = relative_path.gsub(@app.config[:automatic_directory_matcher], '/')
-        end
+        relative_path = relative_path.gsub(@app.config[:automatic_directory_matcher], '/') unless @app.config[:automatic_directory_matcher].nil?
 
         extensionless_path(relative_path)
       end
@@ -226,33 +174,19 @@ module Middleman
 
             @app.logger.debug '== Rebuilding resource list'
 
-            @resources = []
+            @resources.reset!
 
             @resource_list_manipulators.each do |m|
               ::Middleman::Util.instrument 'sitemap.manipulator', name: m[:name] do
                 @app.logger.debug "== Running manipulator: #{m[:name]} (#{m[:priority]})"
-                @resources = m[:manipulator].send(m[:custom_name] || :manipulate_resource_list, @resources)
 
-                # Reset lookup cache
-                reset_lookup_cache!
-
-                # Rebuild cache
-                @resources.each do |resource|
-                  @_lookup_by_path[resource.path] = resource
+                if m[:manipulator].respond_to?(:manipulate_resource_list_container!)
+                  m[:manipulator].send(:manipulate_resource_list_container!, @resources)
+                elsif m[:manipulator].respond_to?(:manipulate_resource_list)
+                  m[:manipulator].send(:manipulate_resource_list, resources.to_a).tap do |result|
+                    @resources.reset!(result)
+                  end
                 end
-
-                @resources.each do |resource|
-                  @_lookup_by_destination_path[resource.destination_path] = resource
-                end
-
-                # NB: This needs to be done after the previous two steps,
-                # since some proxy resources are looked up by path in order to
-                # get their metadata and subsequently their page_id.
-                @resources.each do |resource|
-                  @_lookup_by_page_id[resource.page_id.to_s.to_sym] = resource
-                end
-
-                invalidate_resources_not_ignored_cache!
               end
             end
 
@@ -265,14 +199,6 @@ module Middleman
 
       private
 
-      def reset_lookup_cache!
-        @lock.synchronize do
-          @_lookup_by_path = {}
-          @_lookup_by_destination_path = {}
-          @_lookup_by_page_id = {}
-        end
-      end
-
       # Remove the locale token from the end of the path
       # @param [String] path
       # @return [String]

data/lib/middleman-core/sources/source_watcher.rb

@@ -15,7 +15,7 @@ module Listen
       #   return true unless only_patterns.any? { |pattern| path =~ pattern }
       # end
 
-      return !only_patterns.any? { |pattern| path =~ pattern } if only_patterns
+      return only_patterns.none? { |pattern| path =~ pattern } if only_patterns
 
       ignore_patterns.any? { |pattern| path =~ pattern }
     end
@@ -50,7 +50,7 @@ module Middleman
     # Reference to lower level listener
     attr_reader :listener
 
-    IGNORED_DIRECTORIES = Set.new(%w(.git node_modules .sass-cache vendor/bundle .bundle))
+    IGNORED_DIRECTORIES = Set.new(%w[.git node_modules .sass-cache vendor/bundle .bundle])
 
     # Construct a new SourceWatcher
     #
@@ -59,9 +59,9 @@ module Middleman
     # @param [String] directory The on-disk path to watch.
     # @param [Hash] options Configuration options.
     Contract IsA['Middleman::Sources'], Symbol, String, Hash => Any
-    def initialize(parent, type, directory, options={})
+    def initialize(parent, type, directory, options_hash = ::Middleman::EMPTY_HASH)
       @parent = parent
-      @options = options
+      @options = options_hash
 
       @type = type
       @directory = Pathname(directory)
@@ -69,11 +69,11 @@ module Middleman
       @files = {}
       @extensionless_files = {}
 
-      @frontmatter = options.fetch(:frontmatter, true)
-      @binary = options.fetch(:binary, false)
-      @validator = options.fetch(:validator, proc { true })
-      @ignored = options.fetch(:ignored, proc { false })
-      @only = Array(options.fetch(:only, []))
+      @frontmatter = @options.fetch(:frontmatter, true)
+      @binary = @options.fetch(:binary, false)
+      @validator = @options.fetch(:validator, proc { true })
+      @ignored = @options.fetch(:ignored, proc { false })
+      @only = Array(@options.fetch(:only, []))
 
       @disable_watcher = app.build?
       @force_polling = false
@@ -103,12 +103,12 @@ module Middleman
       poll_once!
     end
 
-    def update_config(options={})
+    def update_config(options_hash = ::Middleman::EMPTY_HASH)
       without_listener_running do
-        @disable_watcher = options.fetch(:disable_watcher, false)
-        @force_polling = options.fetch(:force_polling, false)
-        @latency = options.fetch(:latency, nil)
-        @wait_for_delay = options.fetch(:wait_for_delay, nil)
+        @disable_watcher = options_hash.fetch(:disable_watcher, false)
+        @force_polling = options_hash.fetch(:force_polling, false)
+        @latency = options_hash.fetch(:latency, nil)
+        @wait_for_delay = options_hash.fetch(:wait_for_delay, nil)
       end
     end
 
@@ -134,13 +134,19 @@ module Middleman
     # @param [Boolean] glob If the path contains wildcard characters.
     # @return [Middleman::SourceFile, nil]
     Contract Or[String, Pathname], Maybe[Bool] => Maybe[IsA['Middleman::SourceFile']]
-    def find(path, glob=false)
+    def find(path, glob = false)
       path = path.to_s.encode!('UTF-8', 'UTF-8-MAC') if RUBY_PLATFORM =~ /darwin/
 
       p = Pathname(path)
 
       return nil if p.absolute? && !p.to_s.start_with?(@directory.to_s)
 
+      destination_dir = @options[:destination_dir]
+      if !destination_dir.nil? && !destination_dir.empty? && p.to_s.start_with?(destination_dir)
+        path_without_destination_dir = p.to_s[destination_dir.to_s.length + 1..-1]
+        p = Pathname(path_without_destination_dir)
+      end
+
       p = @directory + p if p.relative?
 
       if glob
@@ -295,7 +301,7 @@ module Middleman
       [valid_updates, valid_removes]
     end
 
-    # Convert a path to a file resprentation.
+    # Convert a path to a file representation.
     #
     # @param [Pathname] path The path.
     # @return [Middleman::SourceFile]
@@ -357,16 +363,16 @@ module Middleman
     private
 
     def without_listener_running
-      listener_running = @listener && @listener.processing?
+      listener_running = @listener&.processing?
 
       stop_listener! if listener_running
 
       yield
 
-      if listener_running
-        poll_once!
-        listen!
-      end
+      return unless listener_running
+
+      poll_once!
+      listen!
     end
   end
 end

data/lib/middleman-core/sources.rb

@@ -1,12 +1,13 @@
 require 'hamster'
 require 'middleman-core/contracts'
+require 'set'
 
 module Middleman
   # The standard "record" that contains information about a file on disk.
   SourceFile = Struct.new(:relative_path, :full_path, :directory, :types, :version) do
     def read
       ::Middleman::Sources.file_cache[full_path] ||= {}
-      ::Middleman::Sources.file_cache[full_path][version] ||= ::File.read(full_path)
+      ::Middleman::Sources.file_cache[full_path][version] ||= ::Middleman::Util.read_file(full_path.to_s)
     end
 
     def normalized_relative_path
@@ -24,7 +25,7 @@ module Middleman
     include Contracts
 
     # Types which could cause output to change.
-    OUTPUT_TYPES = [:source, :locales, :data].freeze
+    OUTPUT_TYPES = %i[source locales data].freeze
 
     # Types which require a reload to eval ruby
     CODE_TYPES = [:reload].freeze
@@ -56,7 +57,7 @@ module Middleman
     # @param [Hash] options Global options.
     # @param [Array] watchers Default watchers.
     Contract IsA['Middleman::Application'], Maybe[Hash], Maybe[Array] => Any
-    def initialize(app, _options={}, watchers=[])
+    def initialize(app, _options_hash = ::Middleman::EMPTY_HASH, watchers = [])
       @app = app
       @watchers = watchers
       @sorted_watchers = @watchers.dup.freeze
@@ -88,7 +89,7 @@ module Middleman
     # @param [Proc] block Ignore by block evaluation.
     # @return [void]
     Contract Symbol, Symbol, Or[Regexp, Proc] => Any
-    def ignore(name, type, regex=nil, &block)
+    def ignore(name, type, regex = nil, &block)
       @ignores = @ignores.put(name, type: type,
                                     validator: (block_given? ? block : regex))
 
@@ -103,7 +104,7 @@ module Middleman
     Contract SourceFile => Bool
     def globally_ignored?(file)
       @ignores.values.any? do |descriptor|
-        ((descriptor[:type] == :all) || file[:types].include?(descriptor[:type])) &&
+        ((descriptor[:type] == :all) || includes_type?(file[:types], descriptor[:type])) &&
           matches?(descriptor[:validator], file)
       end
     end
@@ -116,13 +117,13 @@ module Middleman
     # @param [Hash] options The watcher options.
     # @return [#changed, #deleted]
     Contract Or[Symbol, HANDLER], Maybe[Hash] => HANDLER
-    def watch(type_or_handler, options={})
+    def watch(type_or_handler, options_hash = ::Middleman::EMPTY_HASH)
       handler = if type_or_handler.is_a? Symbol
-        path = File.expand_path(options.delete(:path), app.root)
-        SourceWatcher.new(self, type_or_handler, path, options)
-      else
-        type_or_handler
-      end
+                  path = File.expand_path(options_hash.delete(:path), app.root)
+                  SourceWatcher.new(self, type_or_handler, path, options_hash)
+                else
+                  type_or_handler
+                end
 
       @watchers << handler
 
@@ -183,40 +184,52 @@ module Middleman
 
     # Find a file given a type and path.
     #
-    # @param [Symbol,Array<Symbol>] types A list of file "type".
+    # @param [Symbol,Array<Symbol>,Set<Symbol>] types A list of file "type".
     # @param [String] path The file path.
     # @param [Boolean] glob If the path contains wildcard or glob characters.
     # @return [Middleman::SourceFile, nil]
     Contract Or[Symbol, ArrayOf[Symbol], SetOf[Symbol]], Or[Pathname, String], Maybe[Bool] => Maybe[SourceFile]
-    def find(types, path, glob=false)
-      array_of_types = Array(types)
-
+    def find(types, path, glob = false)
       watchers
         .lazy
-        .select { |d| array_of_types.include?(d.type) }
+        .select { |d| includes_type?(types, d.type) }
         .map { |d| d.find(path, glob) }
         .reject(&:nil?)
         .first
     end
 
+    # Check if a type is included in the types list.
+    #
+    # @param [Symbol,Array<Symbol>,Set<Symbol>] types The list of file "type".
+    # @param [Symbol] type The type we are looking for.
+    # @return [Boolean]
+    Contract Or[Symbol, ArrayOf[Symbol], SetOf[Symbol]], Symbol => Bool
+    def includes_type?(types, type)
+      if types.is_a? Symbol
+        types == type
+      else
+        types.include? type
+      end
+    end
+
     # Check if a file for a given type exists.
     #
-    # @param [Symbol,Array<Symbol>] types The list of file "type".
+    # @param [Symbol,Array<Symbol>,Set<Symbol>] types The list of file "type".
     # @param [String] path The file path relative to it's source root.
     # @return [Boolean]
     Contract Or[Symbol, ArrayOf[Symbol], SetOf[Symbol]], String => Bool
     def exists?(types, path)
-      watchers.any? { |d| Array(types).include?(d.type) && d.exists?(path) }
+      watchers.any? { |d| includes_type?(types, d.type) && d.exists?(path) }
     end
 
     # Check if a file for a given type exists.
     #
-    # @param [Symbol,Array<Symbol>] types The list of file "type".
+    # @param [Symbol,Array<Symbol>,Set<Symbol>] types The list of file "type".
     # @param [String] path The file path relative to it's source root.
     # @return [Boolean]
     Contract Or[Symbol, ArrayOf[Symbol], SetOf[Symbol]], String => Maybe[HANDLER]
     def watcher_for_path(types, path)
-      watchers.detect { |d| Array(types).include?(d.type) && d.exists?(path) }
+      watchers.detect { |d| includes_type?(types, d.type) && d.exists?(path) }
     end
 
     # Manually check for new files
@@ -264,7 +277,7 @@ module Middleman
 
     # Add callback to be run on file change or deletion
     #
-    # @param [Symbol,Array<Symbol>] types The change types to register the callback.
+    # @param [Symbol,Array<Symbol>,Set<Symbol>] types The change types to register the callback.
     # @return [void]
     Contract Or[Symbol, ArrayOf[Symbol], SetOf[Symbol]], Proc => Any
     def on_change(types, &block)
@@ -277,7 +290,7 @@ module Middleman
     #
     # @param [nil,Regexp] matcher A Regexp to match the change path against
     Contract Maybe[Matcher] => Any
-    def changed(matcher=nil, &_block)
+    def changed(matcher = nil, &_block)
       on_change OUTPUT_TYPES do |updated, _removed|
         updated
           .select { |f| matcher.nil? ? true : matches?(matcher, f) }
@@ -289,7 +302,7 @@ module Middleman
     #
     # @param [nil,Regexp] matcher A Regexp to match the change path against
     Contract Maybe[Matcher] => Any
-    def deleted(matcher=nil, &_block)
+    def deleted(matcher = nil, &_block)
       on_change OUTPUT_TYPES do |_updated, removed|
         removed
           .select { |f| matcher.nil? ? true : matches?(matcher, f) }
@@ -317,9 +330,9 @@ module Middleman
     def matches?(validator, file)
       path = file[:relative_path]
       if validator.is_a? Regexp
-        !!(path.to_s =~ validator)
+        !validator.match(path.to_s).nil?
       else
-        !!validator.call(path, @app)
+        validator.call(path, @app)
       end
     end
 
@@ -362,8 +375,8 @@ module Middleman
         if callback[:type] == :all
           callback[:proc].call(updated_files, removed_files)
         else
-          valid_updated = updated_files.select { |f| f[:types].include?(callback[:type]) }
-          valid_removed = removed_files.select { |f| f[:types].include?(callback[:type]) }
+          valid_updated = updated_files.select { |f| includes_type?(f[:types], callback[:type]) }
+          valid_removed = removed_files.select { |f| includes_type?(f[:types], callback[:type]) }
 
           callback[:proc].call(valid_updated, valid_removed) unless valid_updated.empty? && valid_removed.empty?
         end

data/lib/middleman-core/step_definitions/builder_steps.rb

@@ -1,31 +1,92 @@
 require 'fileutils'
 
 Before do
-  @modification_times = Hash.new
+  @modification_times = {}
 end
 
 Given /^a built app at "([^\"]*)"$/ do |path|
-  step %Q{a fixture app "#{path}"}
-  step %Q{I run `middleman build --verbose`}
+  step %(a fixture app "#{path}")
+  step %(I run `middleman build --verbose --no-parallel`)
+end
+
+Then /^build the app tracking dependencies$/ do
+  step %(I run `middleman build --track-dependencies --verbose`)
+  step %(was successfully built)
+end
+
+Then('build the app tracking dependencies with depth {string}') do |depth|
+  step %(I run `middleman build --track-dependencies --verbose --data-collection-depth=#{depth}`)
+  step %(was successfully built)
+end
+
+Then /^build app with only changed$/ do
+  step %(I run `middleman build --track-dependencies --only-changed --verbose`)
+  step %(was successfully built)
 end
 
 Given /^was successfully built$/ do
-  step %Q{the output should contain "Project built successfully."}
-  step %Q{the exit status should be 0}
-  step %Q{a directory named "build" should exist}
+  step %(the output should contain "Project built successfully.")
+  step %(the exit status should be 0)
+  step %(a directory named "build" should exist)
+end
+
+Given /^was not successfully built$/ do
+  step %(the output should not contain "Project built successfully.")
+  step %(the exit status should not be 0)
+  step %(a directory named "build" should not exist)
 end
 
 Given /^a successfully built app at "([^\"]*)"$/ do |path|
-  step %Q{a built app at "#{path}"}
-  step %Q{was successfully built}
+  step %(a built app at "#{path}")
+  step %(was successfully built)
 end
 
 Given /^a built app at "([^\"]*)" with flags "([^\"]*)"$/ do |path, flags|
-  step %Q{a fixture app "#{path}"}
-  step %Q{I run `middleman build #{flags}`}
+  step %(a fixture app "#{path}")
+
+  cwd = File.expand_path(aruba.current_directory)
+  step %(I set the environment variable "MM_ROOT" to "#{cwd}")
+
+  step %(I run `middleman build --no-parallel #{flags}`)
 end
 
 Given /^a successfully built app at "([^\"]*)" with flags "([^\"]*)"$/ do |path, flags|
-  step %Q{a built app at "#{path}" with flags "#{flags}"}
-  step %Q{was successfully built}
+  step %(a built app at "#{path}" with flags "#{flags}")
+  step %(was successfully built)
+end
+
+Given /^I run the interactive middleman console$/ do
+  cwd = File.expand_path(aruba.current_directory)
+  step %(I set the environment variable "MM_ROOT" to "#{cwd}")
+  step %(I run `middleman console` interactively)
+end
+
+Given /^I run the interactive middleman server$/ do
+  cwd = File.expand_path(aruba.current_directory)
+  step %(I set the environment variable "MM_ROOT" to "#{cwd}")
+  step %(I run `middleman server` interactively)
+end
+
+Then('there are {string} files which are {string}') do |num, str|
+  expect(last_command_started.output.scan(str).length).to be num.to_i
+end
+
+Then('there are {string} files which are created') do |num|
+  step %(there are "#{num}" files which are "      create  ")
+end
+
+Then('there are {string} files which are removed') do |num|
+  step %(there are "#{num}" files which are "      remove  ")
+end
+
+Then('there are {string} files which are updated') do |num|
+  step %(there are "#{num}" files which are "     updated  ")
+end
+
+Then('there are {string} files which are identical') do |num|
+  step %(there are "#{num}" files which are "   identical  ")
+end
+
+Then('there are {string} files which are skipped') do |num|
+  step %(there are "#{num}" files which are "     skipped  ")
 end

data/lib/middleman-core/step_definitions/commandline_steps.rb

@@ -1,11 +1,11 @@
-When /^I stop (?:middleman|all commands) if the output( of the last command)? contains:$/ do |last_command, expected|
+When /^I stop (?:middleman|all commands) if the output( of the last command)? contains:$/ do |_last_command, expected|
   begin
-    Timeout.timeout(exit_timeout) do
+    Timeout.timeout(aruba.config.exit_timeout) do
       loop do
-        fail "You need to start middleman interactively first." unless @interactive
+        raise 'You need to start middleman interactively first.' unless @interactive
 
-        if unescape(@interactive.output) =~ Regexp.new(unescape(expected))
-          only_processes.each { |p| p.terminate }
+        if sanitize_text(@interactive.output)&.match?(Regexp.new(sanitize_text(expected)))
+          all_commands.each(&:terminate)
           break
         end
 
@@ -80,5 +80,9 @@ end
 
 # Make sure each and every process is really dead
 After do
-  only_processes.each { |p| p.terminate }
+  all_commands.each(&:terminate)
+end
+
+Before '@ruby-2.1' do
+  skip_this_scenario if RUBY_VERSION < '2.1'
 end