middleman-core 4.6.0 → 5.0.0.rc.1

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,28 +1,28 @@
-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(aruba.config.exit_timeout) do
       loop do
-        fail "You need to start middleman interactively first." unless last_command_started
+        raise 'You need to start middleman interactively first.' unless @interactive
 
-        if unescape_text(last_command_started.output) =~ Regexp.new(unescape_text(expected))
-          all_commands.each { |p| p.terminate }
+        if sanitize_text(@interactive.output)&.match?(Regexp.new(sanitize_text(expected)))
+          all_commands.each(&:terminate)
           break
         end
 
         sleep 0.1
       end
     end
-  rescue ChildProcess::TimeoutError, Timeout::Error
-    last_command_started.terminate
+  rescue ChildProcess::TimeoutError, TimeoutError
+    @interactive.terminate
   ensure
-    aruba.announcer.announce :stdout, last_command_started.stdout
-    aruba.announcer.announce :stderr, last_command_started.stderr
+    announcer.stdout @interactive.stdout
+    announcer.stderr @interactive.stderr
   end
 end
 
 # Make it just a long running process
 Given /`(.*?)` is running in background/ do |cmd|
-  run_command(cmd, exit_timeout: 120)
+  run(cmd, 120)
 end
 
 Given /I have a local hosts file with:/ do |string|
@@ -49,10 +49,10 @@ Given /I start a dns server with:/ do |string|
     )
   )
 
-  set_environment_variable 'PATH', File.expand_path(File.join(aruba.current_directory, 'bin')) + ':' + ENV['PATH']
+  set_env 'PATH', File.expand_path(File.join(current_dir, 'bin')) + ':' + ENV['PATH']
   write_file db_file, string
 
-  @dns_server = run_command("dns_server.rb #{db_file} #{port}", exit_timeout: 120)
+  @dns_server = run("dns_server.rb #{db_file} #{port}", 120)
 end
 
 Given /I start a mdns server with:/ do |string|
@@ -68,10 +68,10 @@ Given /I start a mdns server with:/ do |string|
     )
   )
 
-  set_environment_variable 'PATH', File.expand_path(File.join(aruba.current_directory, 'bin')) + ':' + ENV['PATH']
+  set_env 'PATH', File.expand_path(File.join(current_dir, 'bin')) + ':' + ENV['PATH']
   write_file db_file, string
 
-  @mdns_server = run_command("dns_server.rb #{db_file} #{port}", exit_timeout: 120)
+  @mdns_server = run("dns_server.rb #{db_file} #{port}", 120)
 end
 
 Given /I start a mdns server for the local hostname/ do
@@ -80,5 +80,9 @@ end
 
 # Make sure each and every process is really dead
 After do
-  all_commands.each { |p| p.terminate }
+  all_commands.each(&:terminate)
+end
+
+Before '@ruby-2.1' do
+  skip_this_scenario if RUBY_VERSION < '2.1'
 end

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

@@ -1,16 +1,23 @@
 require 'fileutils'
 
-Given /^app "([^\"]*)" is using config "([^\"]*)"$/ do |path, config_name|
-  target = File.join(PROJECT_ROOT_PATH, 'fixtures', path)
-  config_path = File.join(expand_path("."), "config-#{config_name}.rb")
-  config_dest = File.join(expand_path("."), 'config.rb')
+Given /^app "([^\"]*)" is using config "([^\"]*)"$/ do |_path, config_name|
+  config_path = File.join(expand_path('.'), "config-#{config_name}.rb")
+  config_dest = File.join(expand_path('.'), 'config.rb')
   FileUtils.cp(config_path, config_dest)
 end
 
 Given /^an empty app$/ do
-  step %Q{a directory named "empty_app"}
-  step %Q{I cd to "empty_app"}
   ENV['MM_ROOT'] = nil
+
+  # This step can be reentered from several places but we don't want
+  # to keep re-copying and re-cd-ing into ever-deeper directories
+  next if File.basename(expand_path('.')) == 'empty_app'
+
+  step %(a directory named "empty_app")
+  step %(I cd to "empty_app")
+
+  cwd = File.expand_path(aruba.current_directory)
+  step %(I set the environment variable "MM_ROOT" to "#{cwd}")
 end
 
 Given /^a fixture app "([^\"]*)"$/ do |path|
@@ -18,14 +25,17 @@ Given /^a fixture app "([^\"]*)"$/ do |path|
 
   # This step can be reentered from several places but we don't want
   # to keep re-copying and re-cd-ing into ever-deeper directories
-  next if File.basename(expand_path(".")) == path
+  next if File.basename(expand_path('.')) == path
 
-  step %Q{a directory named "#{path}"}
+  step %(a directory named "#{path}")
 
   target_path = File.join(PROJECT_ROOT_PATH, 'fixtures', path)
-  FileUtils.cp_r(target_path, expand_path("."))
+  FileUtils.cp_r(target_path, expand_path('.'))
+
+  step %(I cd to "#{path}")
 
-  step %Q{I cd to "#{path}"}
+  cwd = File.expand_path(aruba.current_directory)
+  step %(I set the environment variable "MM_ROOT" to "#{cwd}")
 end
 
 Then /^the file "([^\"]*)" has the contents$/ do |path, contents|
@@ -35,18 +45,18 @@ Then /^the file "([^\"]*)" has the contents$/ do |path, contents|
 end
 
 Then /^the file "([^\"]*)" is removed$/ do |path|
-  FileUtils.rm(expand_path(path))
+  step %(I remove the file "#{path}")
 
   @server_inst.files.poll_once!
 end
 
 Given /^a modification time for a file named "([^\"]*)"$/ do |file|
-  target = File.join(expand_path("."), file)
+  target = File.join(expand_path('.'), file)
   @modification_times[target] = File.mtime(target)
 end
 
 Then /^the file "([^\"]*)" should not have been updated$/ do |file|
-  target = File.join(expand_path("."), file)
+  target = File.join(expand_path('.'), file)
   expect(File.mtime(target)).to eq(@modification_times[target])
 end
 
@@ -56,5 +66,5 @@ Then /^the file "([^"]*)" should contain '([^']*)'$/ do |file, partial_content|
 end
 
 And /the file "(.*)" should be gzipped/ do |file|
-  expect(File.binread(File.join(expand_path("."), file), 2)).to eq(['1F8B'].pack('H*'))
+  expect(File.binread(File.join(expand_path('.'), file), 2)).to eq(['1F8B'].pack('H*'))
 end

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

@@ -1,7 +1,6 @@
 require 'middleman-core/rack'
 require 'rspec/expectations'
 require 'capybara/cucumber'
-require 'addressable/uri'
 
 Given /^a clean server$/ do
   @initialize_commands = []
@@ -11,9 +10,7 @@ end
 Given /^"([^\"]*)" feature is "([^\"]*)"$/ do |feature, state|
   @activation_commands ||= []
 
-  if state == 'enabled'
-    @activation_commands << lambda { activate(feature.to_sym) }
-  end
+  @activation_commands << -> { activate(feature.to_sym) } if state == 'enabled'
 end
 
 Given /^"([^\"]*)" feature is "enabled" with "([^\"]*)"$/ do |feature, options_str|
@@ -21,7 +18,7 @@ Given /^"([^\"]*)" feature is "enabled" with "([^\"]*)"$/ do |feature, options_s
 
   options = eval("{#{options_str}}")
 
-  @activation_commands << lambda { activate(feature.to_sym, options) }
+  @activation_commands << -> { activate(feature.to_sym, options) }
 end
 
 Given /^"([^\"]*)" is set to "([^\"]*)"$/ do |variable, value|
@@ -32,13 +29,13 @@ Given /^"([^\"]*)" is set to "([^\"]*)"$/ do |variable, value|
 end
 
 Given /^the Server is running$/ do
-  root_dir = File.expand_path(expand_path("."))
+  root_dir = File.expand_path(expand_path('.'))
 
-  if File.exist?(File.join(root_dir, 'source'))
-    ENV['MM_SOURCE'] = 'source'
-  else
-    ENV['MM_SOURCE'] = ''
-  end
+  ENV['MM_SOURCE'] = if File.exist?(File.join(root_dir, 'source'))
+                       'source'
+                     else
+                       ''
+                     end
 
   ENV['MM_ROOT'] = root_dir
 
@@ -55,7 +52,7 @@ Given /^the Server is running$/ do
 
     app.after_configuration_eval do
       activation_commands.each do |p|
-        config_context.instance_exec(&p)
+        instance_exec(&p)
       end
     end
   end
@@ -64,20 +61,24 @@ Given /^the Server is running$/ do
 end
 
 Given /^the Server is running at "([^\"]*)"$/ do |app_path|
-  step %Q{a fixture app "#{app_path}"}
-  step %Q{the Server is running}
+  step %(a fixture app "#{app_path}")
+  step %(the Server is running)
+end
+
+When /^the Server is reloaded$/ do
+  step %(the Server is running)
 end
 
 Given /^a template named "([^\"]*)" with:$/ do |name, string|
-  step %Q{a file named "source/#{name}" with:}, string
+  step %(a file named "source/#{name}" with:), string
 end
 
 When /^I go to "([^\"]*)"$/ do |url|
-  visit(Addressable::URI.encode(url))
+  visit(URI.encode(url).to_s)
 end
 
 Then /^going to "([^\"]*)" should not raise an exception$/ do |url|
-  expect { visit(Addressable::URI.encode(url)) }.to_not raise_exception
+  expect { visit(URI.encode(url).to_s) }.to_not raise_exception
 end
 
 Then /^the content type should be "([^\"]*)"$/ do |expected|
@@ -121,5 +122,5 @@ Then /^the status code should be "([^\"]*)"$/ do |expected|
 end
 
 Then /^I should see "([^\"]*)" lines$/ do |lines|
-  expect(page.body.chomp.split($/).length).to eq lines.to_i
+  expect(page.body.chomp.split($INPUT_RECORD_SEPARATOR).length).to eq lines.to_i
 end

data/lib/middleman-core/step_definitions.rb

@@ -16,9 +16,6 @@ module ArubaMonkeypatch
 end
 World(ArubaMonkeypatch)
 
-# The Capybara monkey-patch that switches between RSpec::Matchers#all and Capybara::DSL#all
-World(Capybara::RSpecMatcherProxies)
-
 Before do
   @aruba_timeout_seconds = RUBY_PLATFORM == 'java' ? 120 : 60
 end