middleman-core 3.4.1 → 4.0.0.alpha.2

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

@@ -1,7 +1,38 @@
 # Used for merging results of metadata callbacks
 require 'active_support/core_ext/hash/deep_merge'
 require 'monitor'
-require 'middleman-core/sitemap/queryable'
+
+# Ignores
+Middleman::Extensions.register :sitemap_ignore, auto_activate: :before_configuration do
+  require 'middleman-core/sitemap/extensions/ignores'
+  Middleman::Sitemap::Extensions::Ignores
+end
+
+# Files on Disk
+Middleman::Extensions.register :sitemap_ondisk, auto_activate: :before_configuration do
+  require 'middleman-core/sitemap/extensions/on_disk'
+  Middleman::Sitemap::Extensions::OnDisk
+end
+
+# Endpoints
+Middleman::Extensions.register :sitemap_endpoint, auto_activate: :before_configuration do
+  require 'middleman-core/sitemap/extensions/request_endpoints'
+  Middleman::Sitemap::Extensions::RequestEndpoints
+end
+
+# Proxies
+Middleman::Extensions.register :sitemap_proxies, auto_activate: :before_configuration do
+  require 'middleman-core/sitemap/extensions/proxies'
+  Middleman::Sitemap::Extensions::Proxies
+end
+
+# Redirects
+Middleman::Extensions.register :sitemap_redirects, auto_activate: :before_configuration do
+  require 'middleman-core/sitemap/extensions/redirects'
+  Middleman::Sitemap::Extensions::Redirects
+end
+
+require 'middleman-core/contracts'
 
 module Middleman
   # Sitemap namespace
@@ -13,51 +44,51 @@ 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
-      # @return [Middleman::Application]
-      attr_accessor :app
+      include Contracts
 
-      include ::Middleman::Sitemap::Queryable::API
+      # @return [Middleman::Application]
+      attr_reader :app
 
       # Initialize with parent app
       # @param [Middleman::Application] app
       def initialize(app)
         @app = app
         @resources = []
-        @_cached_metadata = {}
+        # TODO: Should this be a set or hash?
         @resource_list_manipulators = []
         @needs_sitemap_rebuild = true
-        @lock = Monitor.new
 
+        @lock = Monitor.new
         reset_lookup_cache!
 
-        # Register classes which can manipulate the main site map list
-        register_resource_list_manipulator(:on_disk, Middleman::Sitemap::Extensions::OnDisk.new(self))
-
-        # Request Endpoints
-        register_resource_list_manipulator(:request_endpoints, @app.endpoint_manager)
-
-        # Proxies
-        register_resource_list_manipulator(:proxies, @app.proxy_manager)
-
-        # Redirects
-        register_resource_list_manipulator(:redirects, @app.redirect_manager)
+        @app.config_context.class.send :def_delegator, :app, :sitemap
       end
 
-      # Register a klass which can manipulate the main site map list. Best to register
-      # these in a before_configuration or after_configuration hook.
+      # Register an object which can transform the sitemap resource list. Best to register
+      # these in a `before_configuration` or `after_configuration` hook.
       #
       # @param [Symbol] name Name of the manipulator for debugging
-      # @param [Class, Module] inst Abstract namespace which can update the resource list
+      # @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.
       # @return [void]
-      def register_resource_list_manipulator(name, inst, *)
-        @resource_list_manipulators << [name, inst]
+      Contract Symbol, RespondTo['manipulate_resource_list'], Maybe[Num] => 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 << [name, manipulator, priority]
+        # The index trick is used so that the sort is stable - manipulators with the same priority
+        # will always be ordered in the same order as they were registered.
+        n = 0
+        @resource_list_manipulators = @resource_list_manipulators.sort_by do |m|
+          n += 1
+          [m[2], n]
+        end
         rebuild_resource_list!(:registered_new)
       end
 
-      # Rebuild the list of resources from scratch, using registered manipulators
-      # rubocop:disable UnusedMethodArgument
+      # Rebuild the list of resources from scratch, using registed manipulators
       # @return [void]
-      def rebuild_resource_list!(reason=nil)
+      def rebuild_resource_list!(_=nil)
         @lock.synchronize do
           @needs_sitemap_rebuild = true
         end
@@ -66,6 +97,7 @@ module Middleman
       # 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)
@@ -77,6 +109,7 @@ module Middleman
       # 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)
@@ -88,6 +121,7 @@ module Middleman
       # 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!
@@ -99,106 +133,34 @@ module Middleman
         end
       end
 
-      # Invalidate our cached view of resource that are not ignored. If your extension
+      # Invalidate our cached view of resource that are not ingnored. 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
 
-      # Register a handler to provide metadata on a file path
-      # @param [Regexp] matcher
-      # @return [Array<Array<Proc, Regexp>>]
-      def provides_metadata(matcher=nil, &block)
-        @_provides_metadata ||= []
-        @_provides_metadata << [block, matcher] if block_given?
-        @_provides_metadata
-      end
-
-      # Get the metadata for a specific file
-      # @param [String] source_file
-      # @return [Hash]
-      def metadata_for_file(source_file)
-        blank_metadata = { options: {}, locals: {}, page: {}, blocks: [] }
-
-        provides_metadata.reduce(blank_metadata) do |result, (callback, matcher)|
-          next result if matcher && !source_file.match(matcher)
-
-          metadata = callback.call(source_file).dup
-
-          if metadata.key?(:blocks)
-            result[:blocks] << metadata[:blocks]
-            metadata.delete(:blocks)
-          end
-
-          result.deep_merge(metadata)
-        end
-      end
-
-      # Register a handler to provide metadata on a url path
-      # @param [Regexp] matcher
-      # @return [Array<Array<Proc, Regexp>>]
-      def provides_metadata_for_path(matcher=nil, &block)
-        @_provides_metadata_for_path ||= []
-        if block_given?
-          @_provides_metadata_for_path << [block, matcher]
-          @_cached_metadata = {}
-        end
-        @_provides_metadata_for_path
-      end
-
-      # Get the metadata for a specific URL
-      # @param [String] request_path
-      # @return [Hash]
-      def metadata_for_path(request_path)
-        return @_cached_metadata[request_path] if @_cached_metadata[request_path]
-
-        blank_metadata = { options: {}, locals: {}, page: {}, blocks: [] }
-
-        @_cached_metadata[request_path] = provides_metadata_for_path.reduce(blank_metadata) do |result, (callback, matcher)|
-          case matcher
-          when Regexp
-            next result unless request_path =~ matcher
-          when String
-            next result unless File.fnmatch('/' + Util.strip_leading_slash(matcher), "/#{request_path}")
-          end
-
-          metadata = callback.call(request_path).dup
-
-          result[:blocks] += Array(metadata.delete(:blocks))
-
-          result.deep_merge(metadata)
-        end
-      end
-
       # Get the URL path for an on-disk file
       # @param [String] file
       # @return [String]
+      Contract IsA['Middleman::SourceFile'] => String
       def file_to_path(file)
-        file = File.expand_path(file, @app.root)
-
-        prefix = @app.source_dir.sub(/\/$/, '') + '/'
-        return false unless file.start_with?(prefix)
-
-        path = file.sub(prefix, '')
+        relative_path = file[:relative_path].to_s
 
         # Replace a file name containing automatic_directory_matcher with a folder
         unless @app.config[:automatic_directory_matcher].nil?
-          path = path.gsub(@app.config[:automatic_directory_matcher], '/')
+          relative_path = relative_path.gsub(@app.config[:automatic_directory_matcher], '/')
         end
 
-        extensionless_path(path)
+        extensionless_path(relative_path)
       end
 
       # Get a path without templating extensions
       # @param [String] file
       # @return [String]
+      Contract String => String
       def extensionless_path(file)
         path = file.dup
-        path = remove_templating_extensions(path)
-
-        # If there is no extension, look for one
-        path = find_extension(path, file) if File.extname(strip_away_locale(path)).empty?
-        path
+        remove_templating_extensions(path)
       end
 
       # Actually update the resource list, assuming anything has called
@@ -211,66 +173,51 @@ module Middleman
 
           @app.logger.debug '== Rebuilding resource list'
 
-          @resources = []
-
-          @resource_list_manipulators.each do |(_, inst)|
-            @resources = inst.manipulate_resource_list(@resources)
+          @resources = @resource_list_manipulators.reduce([]) do |result, (_, manipulator, _)|
+            newres = manipulator.manipulate_resource_list(result)
 
             # Reset lookup cache
             reset_lookup_cache!
-            
-            @resources.each do |resource|
+            newres.each do |resource|
               @_lookup_by_path[resource.path] = resource
               @_lookup_by_destination_path[resource.destination_path] = resource
             end
 
-            invalidate_resources_not_ignored_cache!
+            newres
           end
+
+          invalidate_resources_not_ignored_cache!
         end
       end
 
       private
 
       def reset_lookup_cache!
-        @lock.synchronize do
+        @lock.synchronize {
           @_lookup_by_path = {}
           @_lookup_by_destination_path = {}
-        end
+        }
       end
 
       # Removes the templating extensions, while keeping the others
       # @param [String] path
       # @return [String]
+      Contract String => String
       def remove_templating_extensions(path)
         # Strip templating extensions as long as Tilt knows them
-        path = path.sub(/#{::Regexp.escape(File.extname(path))}$/, '') while ::Tilt[path]
+        path = path.sub(File.extname(path), '') while ::Tilt[path]
         path
       end
 
       # Remove the locale token from the end of the path
       # @param [String] path
       # @return [String]
+      Contract String => String
       def strip_away_locale(path)
-        if @app.respond_to? :langs
+        if @app.extensions[:i18n]
           path_bits = path.split('.')
           lang = path_bits.last
-          return path_bits[0..-2].join('.') if @app.langs.include?(lang.to_sym)
-        end
-
-        path
-      end
-
-      # Finds an extension for path according to file's extension
-      # @param [String] path without extension
-      # @param [String] file path with original extensions
-      def find_extension(path, file)
-        input_ext = File.extname(file)
-
-        unless input_ext.empty?
-          input_ext = input_ext.split('.').last.to_sym
-          if @app.template_extensions.key?(input_ext)
-            path << ".#{@app.template_extensions[input_ext]}"
-          end
+          return path_bits[0..-2].join('.') if @app.extensions[:i18n].langs.include?(lang.to_sym)
         end
 
         path

data/lib/middleman-core/sources.rb

@@ -0,0 +1,310 @@
+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, :type
+
+  # 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
+
+    # A reference to the current app.
+    Contract None => IsA['Middleman::Application']
+    attr_reader :app
+
+    # Duck-typed definition of a valid source watcher
+    HANDLER = RespondTo[:changed]
+
+    # Config
+    Contract None => Hash
+    attr_reader :options
+
+    # Reference to the global logger.
+    def_delegator :@app, :logger
+
+    # 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
+
+      @options = options
+
+      # Set of procs wanting to be notified of changes
+      @on_change_callbacks = []
+
+      # Global ignores
+      @ignores = {}
+
+      # 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[name] = { type: type, validator: (block_given? ? block : regex) }
+
+      bump_count
+      find_new_files! 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[:type] == 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
+        SourceWatcher.new(self, type_or_handler, options.delete(: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.changed(&method(:did_change))
+
+      if @running
+        handler.poll_once!
+        handler.listen!
+      end
+
+      handler
+    end
+
+    # A list of registered watchers
+    Contract None => ArrayOf[HANDLER]
+    def watchers
+      @sorted_watchers
+    end
+
+    # Disconnect a specific watcher.
+    #
+    # @param [SourceWatcher] watcher The watcher to remove.
+    # @return [void]
+    Contract RespondTo[:changed] => 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, @options, watchers.select { |d| d.type == type }
+    end
+
+    # Get all files for this collection of watchers.
+    #
+    # @return [Array<Middleman::SourceFile>]
+    Contract None => ArrayOf[SourceFile]
+    def files
+      watchers.map(&:files).flatten.uniq { |f| f[:relative_path] }
+    end
+
+    # Find a file given a type and path.
+    #
+    # @param [Symbol] type The file "type".
+    # @param [String] path The file path.
+    # @param [Boolean] glob If the path contains wildcard or glob characters.
+    # @return [Middleman::SourceFile, nil]
+    Contract Symbol, String, Maybe[Bool] => Maybe[SourceFile]
+    def find(type, path, glob=false)
+      watchers
+          .select { |d| d.type == type }
+          .map { |d| d.find(path, glob) }
+          .compact
+          .first
+    end
+
+    # Check if a file for a given type exists.
+    #
+    # @param [Symbol] type The file "type".
+    # @param [String] path The file path relative to it's source root.
+    # @return [Boolean]
+    Contract Symbol, String => Bool
+    def exists?(type, path)
+      watchers
+          .select { |d| d.type == type }
+          .any? { |d| d.exists?(path) }
+    end
+
+    # Check if a file for a given type exists.
+    #
+    # @param [Symbol] type The file "type".
+    # @param [String] path The file path relative to it's source root.
+    # @return [Boolean]
+    Contract Symbol, String => Maybe[HANDLER]
+    def watcher_for_path(type, path)
+      watchers
+          .select { |d| d.type == type }
+          .find { |d| d.exists?(path) }
+    end
+
+    # Manually poll all watchers for new content.
+    #
+    # @return [void]
+    Contract None => Any
+    def find_new_files!
+      return unless @update_count != @last_update_count
+
+      @last_update_count = @update_count
+      watchers.each(&:poll_once!)
+    end
+
+    # Start up all listeners.
+    #
+    # @return [void]
+    Contract None => Any
+    def start!
+      watchers.each(&:listen!)
+      @running = true
+    end
+
+    # Stop the watchers.
+    #
+    # @return [void]
+    Contract None => 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
+    #
+    # @param [nil,Regexp] matcher A Regexp to match the change path against
+    # @return [Set<CallbackDescriptor>]
+    Contract Symbol, Proc => ArrayOf[CallbackDescriptor]
+    def changed(type, &block)
+      @on_change_callbacks << CallbackDescriptor.new(type, block)
+      @on_change_callbacks
+    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 Or[Regexp, RespondTo[:call]], SourceFile => Bool
+    def matches?(validator, file)
+      path = file[:relative_path]
+      if validator.is_a? Regexp
+        !!validator.match(path.to_s)
+      else
+        !!validator.call(path, @app)
+      end
+    end
+
+    # Increment the internal counter for changes.
+    #
+    # @return [void]
+    Contract None => 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[:type], file[:relative_path].to_s) == watcher
+      end
+
+      valid_removed = removed_files.select do |file|
+        watcher_for_path(file[:type], 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 ArrayOf[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| callback[:type] == f[:type] }
+          valid_removed = removed_files.select { |f| callback[:type] == f[:type] }
+
+          callback[:proc].call(valid_updated, valid_removed)
+        end
+      end
+    end
+  end
+end
+
+# And, require the actual default implementation for a watcher.
+require 'middleman-core/sources/source_watcher.rb'