middleman-core 3.3.12 → 4.4.2

data/lib/middleman-core/sources.rb

@@ -0,0 +1,376 @@
+require 'hamster'
+require 'middleman-core/contracts'
+
+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)
+    end
+
+    def normalized_relative_path
+      @normalized_relative_path ||= ::Middleman::Util.normalize_path relative_path.to_s
+    end
+  end
+
+  # Sources handle multiple on-disk collections of files which make up
+  # a Middleman project. They are separated by `type` which can then be
+  # queried. For example, the `source` type represents all content that
+  # the sitemap uses to build a project. The `data` type represents YAML
+  # data. The `locales` type represents localization YAML, and so on.
+  class Sources
+    extend Forwardable
+    include Contracts
+
+    # Types which could cause output to change.
+    OUTPUT_TYPES = [:source, :locales, :data].freeze
+
+    # Types which require a reload to eval ruby
+    CODE_TYPES = [:reload].freeze
+
+    Matcher = Or[Regexp, RespondTo[:call]]
+
+    # A reference to the current app.
+    Contract IsA['Middleman::Application']
+    attr_reader :app
+
+    # Duck-typed definition of a valid source watcher
+    HANDLER = RespondTo[:on_change]
+
+    # Config
+    Contract Hash
+    attr_reader :options
+
+    # Reference to the global logger.
+    def_delegator :@app, :logger
+
+    cattr_accessor :file_cache
+
+    # Built-in types
+    # :source, :data, :locales, :reload
+
+    # Create a new collection of sources.
+    #
+    # @param [Middleman::Application] app The parent app.
+    # @param [Hash] options Global options.
+    # @param [Array] watchers Default watchers.
+    Contract IsA['Middleman::Application'], Maybe[Hash], Maybe[Array] => Any
+    def initialize(app, _options={}, watchers=[])
+      @app = app
+      @watchers = watchers
+      @sorted_watchers = @watchers.dup.freeze
+
+      ::Middleman::Sources.file_cache = {}
+
+      # Set of procs wanting to be notified of changes
+      @on_change_callbacks = ::Hamster::Vector.empty
+
+      # Global ignores
+      @ignores = ::Hamster::Hash.empty
+
+      # Whether we're "running", which means we're in a stable
+      # watch state after all initialization and config.
+      @running = false
+
+      @update_count = 0
+      @last_update_count = -1
+
+      # When the app is about to shut down, stop our watchers.
+      @app.before_shutdown(&method(:stop!))
+    end
+
+    # Add a proc to ignore paths with either a regex or block.
+    #
+    # @param [Symbol] name A name for the ignore.
+    # @param [Symbol] type The type of content to apply the ignore to.
+    # @param [Regexp] regex Ignore by path regex.
+    # @param [Proc] block Ignore by block evaluation.
+    # @return [void]
+    Contract Symbol, Symbol, Or[Regexp, Proc] => Any
+    def ignore(name, type, regex=nil, &block)
+      @ignores = @ignores.put(name, type: type,
+                                    validator: (block_given? ? block : regex))
+
+      bump_count
+      poll_once! if @running
+    end
+
+    # Whether this path is ignored.
+    #
+    # @param [Middleman::SourceFile] file The file to check.
+    # @return [Boolean]
+    Contract SourceFile => Bool
+    def globally_ignored?(file)
+      @ignores.values.any? do |descriptor|
+        ((descriptor[:type] == :all) || file[:types].include?(descriptor[:type])) &&
+          matches?(descriptor[:validator], file)
+      end
+    end
+
+    # Connect a new watcher. Can either be a type with options, which will
+    # create a `SourceWatcher` or you can pass in an instantiated class which
+    # responds to #changed and #deleted
+    #
+    # @param [Symbol, #changed, #deleted] type_or_handler The handler.
+    # @param [Hash] options The watcher options.
+    # @return [#changed, #deleted]
+    Contract Or[Symbol, HANDLER], Maybe[Hash] => HANDLER
+    def watch(type_or_handler, options={})
+      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
+
+      @watchers << handler
+
+      # The index trick is used so that the sort is stable - watchers with the same priority
+      # will always be ordered in the same order as they were registered.
+      n = 0
+      @sorted_watchers = @watchers.sort_by do |w|
+        priority = w.options.fetch(:priority, 50)
+        n += 1
+        [priority, n]
+      end.reverse.freeze
+
+      handler.on_change(&method(:did_change))
+
+      if @running
+        handler.poll_once!
+        handler.listen!
+      end
+
+      handler
+    end
+
+    # A list of registered watchers
+    Contract ArrayOf[HANDLER]
+    def watchers
+      @sorted_watchers
+    end
+
+    # Disconnect a specific watcher.
+    #
+    # @param [SourceWatcher] watcher The watcher to remove.
+    # @return [void]
+    Contract RespondTo[:on_change] => Any
+    def unwatch(watcher)
+      @watchers.delete(watcher)
+
+      watcher.unwatch
+
+      bump_count
+    end
+
+    # Filter the collection of watchers by a type.
+    #
+    # @param [Symbol] type The watcher type.
+    # @return [Middleman::Sources]
+    Contract Symbol => ::Middleman::Sources
+    def by_type(type)
+      self.class.new @app, nil, watchers.select { |d| d.type == type }
+    end
+
+    # Get all files for this collection of watchers.
+    #
+    # @return [Array<Middleman::SourceFile>]
+    Contract ArrayOf[SourceFile]
+    def files
+      watchers.flat_map(&:files).uniq { |f| f[:relative_path] }
+    end
+
+    # Find a file given a type and path.
+    #
+    # @param [Symbol,Array<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)
+
+      watchers
+        .lazy
+        .select { |d| array_of_types.include?(d.type) }
+        .map { |d| d.find(path, glob) }
+        .reject(&:nil?)
+        .first
+    end
+
+    # Check if a file for a given type exists.
+    #
+    # @param [Symbol,Array<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) }
+    end
+
+    # Check if a file for a given type exists.
+    #
+    # @param [Symbol,Array<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) }
+    end
+
+    # Manually check for new files
+    #
+    # @return [void]
+    Contract ArrayOf[Pathname]
+    def find_new_files!
+      return [] unless @update_count != @last_update_count
+
+      @last_update_count = @update_count
+      watchers.reduce([]) { |sum, w| sum + w.find_new_files! }
+    end
+
+    # Manually poll all watchers for new content.
+    #
+    # @return [void]
+    Contract ArrayOf[Pathname]
+    def poll_once!
+      return [] unless @update_count != @last_update_count
+
+      @last_update_count = @update_count
+      watchers.reduce([]) { |sum, w| sum + w.poll_once! }
+    end
+
+    # Start up all listeners.
+    #
+    # @return [void]
+    Contract Any
+    def start!
+      watchers.each(&:listen!)
+      @running = true
+    end
+
+    # Stop the watchers.
+    #
+    # @return [void]
+    Contract Any
+    def stop!
+      watchers.each(&:stop_listener!)
+      @running = false
+    end
+
+    # A callback requires a type and the proc to execute.
+    CallbackDescriptor = Struct.new :type, :proc
+
+    # Add callback to be run on file change or deletion
+    #
+    # @param [Symbol,Array<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)
+      Array(types).each do |type|
+        @on_change_callbacks = @on_change_callbacks.push(CallbackDescriptor.new(type, block))
+      end
+    end
+
+    # Backwards compatible change handler.
+    #
+    # @param [nil,Regexp] matcher A Regexp to match the change path against
+    Contract Maybe[Matcher] => Any
+    def changed(matcher=nil, &_block)
+      on_change OUTPUT_TYPES do |updated, _removed|
+        updated
+          .select { |f| matcher.nil? ? true : matches?(matcher, f) }
+          .each { |f| yield f[:relative_path] }
+      end
+    end
+
+    # Backwards compatible delete handler.
+    #
+    # @param [nil,Regexp] matcher A Regexp to match the change path against
+    Contract Maybe[Matcher] => Any
+    def deleted(matcher=nil, &_block)
+      on_change OUTPUT_TYPES do |_updated, removed|
+        removed
+          .select { |f| matcher.nil? ? true : matches?(matcher, f) }
+          .each { |f| yield f[:relative_path] }
+      end
+    end
+
+    # Backwards compatible ignored check.
+    #
+    # @param [Pathname,String] path The path to check.
+    Contract Or[Pathname, String] => Bool
+    def ignored?(path)
+      descriptor = find(OUTPUT_TYPES, path)
+      !descriptor || globally_ignored?(descriptor)
+    end
+
+    protected
+
+    # Whether a validator matches a file.
+    #
+    # @param [Regexp, #call] validator The match validator.
+    # @param [Middleman::SourceFile] file The file to check.
+    # @return [Boolean]
+    Contract Matcher, SourceFile => Bool
+    def matches?(validator, file)
+      path = file[:relative_path]
+      if validator.is_a? Regexp
+        !!(path.to_s =~ validator)
+      else
+        !!validator.call(path, @app)
+      end
+    end
+
+    # Increment the internal counter for changes.
+    #
+    # @return [void]
+    Contract Any
+    def bump_count
+      @update_count += 1
+    end
+
+    # Notify callbacks that a file changed
+    #
+    # @param [Middleman::SourceFile] file The file that changed
+    # @return [void]
+    Contract ArrayOf[SourceFile], ArrayOf[SourceFile], HANDLER => Any
+    def did_change(updated_files, removed_files, watcher)
+      valid_updated = updated_files.select do |file|
+        watcher_for_path(file[:types], file[:relative_path].to_s) == watcher
+      end
+
+      valid_removed = removed_files.select do |file|
+        watcher_for_path(file[:types], file[:relative_path].to_s).nil?
+      end
+
+      return if valid_updated.empty? && valid_removed.empty?
+
+      bump_count
+      run_callbacks(@on_change_callbacks, valid_updated, valid_removed)
+    end
+
+    # Notify callbacks for a file given a set of callbacks
+    #
+    # @param [Set] callback_descriptors The registered callbacks.
+    # @param [Array<Middleman::SourceFile>] files The files that were changed.
+    # @return [void]
+    Contract VectorOf[CallbackDescriptor], ArrayOf[SourceFile], ArrayOf[SourceFile] => Any
+    def run_callbacks(callback_descriptors, updated_files, removed_files)
+      callback_descriptors.each do |callback|
+        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]) }
+
+          callback[:proc].call(valid_updated, valid_removed) unless valid_updated.empty? && valid_removed.empty?
+        end
+      end
+    end
+  end
+end
+
+# And, require the actual default implementation for a watcher.
+require 'middleman-core/sources/source_watcher'

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

@@ -4,42 +4,15 @@ Before do
   @modification_times = Hash.new
 end
 
-Given /^app "([^\"]*)" is using config "([^\"]*)"$/ do |path, config_name|
-  target = File.join(PROJECT_ROOT_PATH, 'fixtures', path)
-  config_path = File.join(current_dir, "config-#{config_name}.rb")
-  config_dest = File.join(current_dir, '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
-end
-
-Given /^a fixture app "([^\"]*)"$/ do |path|
-  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(current_dir) == path
-
-  step %Q{a directory named "#{path}"}
-
-  target_path = File.join(PROJECT_ROOT_PATH, 'fixtures', path)
-  FileUtils.cp_r(target_path, current_dir)
-
-  step %Q{I cd to "#{path}"}
-end
-
 Given /^a built app at "([^\"]*)"$/ do |path|
   step %Q{a fixture app "#{path}"}
-  step %Q{I run `middleman build`}
+  step %Q{I run `middleman build --verbose`}
 end
 
 Given /^was successfully built$/ do
-  step %Q{a directory named "build" should exist}
+  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}
 end
 
 Given /^a successfully built app at "([^\"]*)"$/ do |path|
@@ -56,22 +29,3 @@ Given /^a successfully built app at "([^\"]*)" with flags "([^\"]*)"$/ do |path,
   step %Q{a built app at "#{path}" with flags "#{flags}"}
   step %Q{was successfully built}
 end
-
-Given /^a modification time for a file named "([^\"]*)"$/ do |file|
-  target = File.join(current_dir, file)
-  @modification_times[target] = File.mtime(target)
-end
-
-Then /^the file "([^\"]*)" should not have been updated$/ do |file|
-  target = File.join(current_dir, file)
-  File.mtime(target).should == @modification_times[target]
-end
-
-# Provide this Aruba overload in case we're matching something with quotes in it
-Then /^the file "([^"]*)" should contain '([^']*)'$/ do |file, partial_content|
-  check_file_content(file, Regexp.new(Regexp.escape(partial_content)), true)
-end
-
-And /the file "(.*)" should be gzipped/ do |file|
-  expect(File.binread(File.join(current_dir, file), 2)).to eq(['1F8B'].pack('H*'))
-end

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

@@ -0,0 +1,84 @@
+When /^I stop (?:middleman|all commands) if the output( of the last command)? contains:$/ do |last_command, expected|
+  begin
+    Timeout.timeout(exit_timeout) do
+      loop do
+        fail "You need to start middleman interactively first." unless @interactive
+
+        if unescape(@interactive.output) =~ Regexp.new(unescape(expected))
+          only_processes.each { |p| p.terminate }
+          break
+        end
+
+        sleep 0.1
+      end
+    end
+  rescue ChildProcess::TimeoutError, TimeoutError
+    @interactive.terminate
+  ensure
+    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(cmd, 120)
+end
+
+Given /I have a local hosts file with:/ do |string|
+  step 'I set the environment variables to:', table(
+    %(
+      | variable | value  |
+      | MM_HOSTSRC  | .hosts |
+    )
+  )
+
+  step 'a file named ".hosts" with:', string
+end
+
+Given /I start a dns server with:/ do |string|
+  @dns_server.terminate if defined? @dns_server
+
+  port = 5300
+  db_file = 'dns.db'
+
+  step 'I set the environment variables to:', table(
+    %(
+       | variable  | value            |
+       | MM_DNSRC  | 127.0.0.1:#{port}|
+    )
+  )
+
+  set_env 'PATH', File.expand_path(File.join(current_dir, 'bin')) + ':' + ENV['PATH']
+  write_file db_file, string
+
+  @dns_server = run("dns_server.rb #{db_file} #{port}", 120)
+end
+
+Given /I start a mdns server with:/ do |string|
+  @mdns_server.terminate if defined? @mdns_server
+
+  port = 5301
+  db_file = 'mdns.db'
+
+  step 'I set the environment variables to:', table(
+    %(
+       | variable  | value             |
+       | MM_MDNSRC  | 127.0.0.1:#{port}|
+    )
+  )
+
+  set_env 'PATH', File.expand_path(File.join(current_dir, 'bin')) + ':' + ENV['PATH']
+  write_file db_file, string
+
+  @mdns_server = run("dns_server.rb #{db_file} #{port}", 120)
+end
+
+Given /I start a mdns server for the local hostname/ do
+  step %(I start a mdns server with:), "#{Socket.gethostname}: 127.0.0.1"
+end
+
+# Make sure each and every process is really dead
+After do
+  only_processes.each { |p| p.terminate }
+end

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

@@ -1,17 +1,60 @@
+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')
+  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
+end
+
+Given /^a fixture app "([^\"]*)"$/ do |path|
+  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(".")) == path
+
+  step %Q{a directory named "#{path}"}
+
+  target_path = File.join(PROJECT_ROOT_PATH, 'fixtures', path)
+  FileUtils.cp_r(target_path, expand_path("."))
+
+  step %Q{I cd to "#{path}"}
+end
+
 Then /^the file "([^\"]*)" has the contents$/ do |path, contents|
   write_file(path, contents)
-  step %Q{the file "#{path}" did change}
+
+  @server_inst.files.poll_once!
 end
 
 Then /^the file "([^\"]*)" is removed$/ do |path|
-  step %Q{I remove the file "#{path}"}
-  step %Q{the file "#{path}" did delete}
+  FileUtils.rm(expand_path(path))
+
+  @server_inst.files.poll_once!
+end
+
+Given /^a modification time for a file named "([^\"]*)"$/ do |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)
+  expect(File.mtime(target)).to eq(@modification_times[target])
 end
 
-Then /^the file "([^\"]*)" did change$/ do |path|
-  @server_inst.files.did_change(path)
+# Provide this Aruba overload in case we're matching something with quotes in it
+Then /^the file "([^"]*)" should contain '([^']*)'$/ do |file, partial_content|
+  expect(file).to have_file_content(Regexp.new(Regexp.escape(partial_content)), true)
 end
 
-Then /^the file "([^\"]*)" did delete$/ do |path|
-  @server_inst.files.did_delete(path)
+And /the file "(.*)" should be gzipped/ do |file|
+  expect(File.binread(File.join(expand_path("."), file), 2)).to eq(['1F8B'].pack('H*'))
 end