middleman-core 4.0.0.alpha.2 → 4.0.0.alpha.3

data/lib/middleman-core/renderers/sass.rb

@@ -87,7 +87,7 @@ module Middleman
           begin
             @engine.render
           rescue ::Sass::SyntaxError => e
-            ::Sass::SyntaxError.exception_to_css(e, full_exception: true)
+            ::Sass::SyntaxError.exception_to_css(e)
           end
         end
 

data/lib/middleman-core/renderers/slim.rb

@@ -24,7 +24,7 @@ module Middleman
         super
 
         # Setup Slim options to work with partials
-        ::Slim::Engine.set_default_options(
+        ::Slim::Engine.set_options(
           buffer: '@_out_buf',
           use_html_safe: true,
           generator: ::Temple::Generators::RailsOutputBuffer,
@@ -39,7 +39,7 @@ module Middleman
 
         ::Slim::Embedded::SassEngine.disable_option_validator!
         %w(sass scss markdown).each do |engine|
-          ::Slim::Embedded.default_options[engine.to_sym] = context_hack
+          ::Slim::Embedded.options[engine.to_sym] = context_hack
         end
       end
     end

data/lib/middleman-core/sitemap/extensions/on_disk.rb

@@ -24,7 +24,7 @@ module Middleman
 
         Contract None => Any
         def before_configuration
-          app.files.changed(:source, &method(:update_files))
+          app.files.on_change(:source, &method(:update_files))
         end
 
         def ignored?(file)

data/lib/middleman-core/sitemap/extensions/proxies.rb

@@ -1,4 +1,5 @@
 require 'middleman-core/sitemap/resource'
+require 'middleman-core/core_extensions/collections/step_context'
 
 module Middleman
   module Sitemap
@@ -13,6 +14,13 @@ module Middleman
           @app.define_singleton_method(:proxy, &method(:create_proxy))
 
           @proxy_configs = Set.new
+          @post_config = false
+        end
+
+        def after_configuration
+          @post_config = true
+
+          ::Middleman::CoreExtensions::Collections::StepContext.add_to_context(:proxy, &method(:create_anonymous_proxy))
         end
 
         # Setup a proxy from a path to a target
@@ -27,70 +35,48 @@ module Middleman
         Contract String, String, Maybe[Hash] => Any
         def create_proxy(path, target, opts={})
           options = opts.dup
-
           @app.ignore(target) if options.delete(:ignore)
 
-          metadata = {
-            options: options,
-            locals: options.delete(:locals) || {},
-            page: options.delete(:data) || {}
-          }
-
-          @proxy_configs << ProxyConfiguration.new(path: path, target: target, metadata: metadata)
-
+          @proxy_configs << create_anonymous_proxy(path, target, options)
           @app.sitemap.rebuild_resource_list!(:added_proxy)
         end
 
+        # Setup a proxy from a path to a target
+        # @param [String] path The new, proxied path to create
+        # @param [String] target The existing path that should be proxied to. This must be a real resource, not another proxy.
+        # @option opts [Boolean] ignore Ignore the target from the sitemap (so only the new, proxy resource ends up in the output)
+        # @option opts [Symbol, Boolean, String] layout The layout name to use (e.g. `:article`) or `false` to disable layout.
+        # @option opts [Boolean] directory_indexes Whether or not the `:directory_indexes` extension applies to these paths.
+        # @option opts [Hash] locals Local variables for the template. These will be available when the template renders.
+        # @option opts [Hash] data Extra metadata to add to the page. This is the same as frontmatter, though frontmatter will take precedence over metadata defined here. Available via {Resource#data}.
+        # @return [void]
+        def create_anonymous_proxy(path, target, options={})
+          ProxyDescriptor.new(
+            ::Middleman::Util.normalize_path(path),
+            ::Middleman::Util.normalize_path(target),
+            options
+          )
+        end
+
         # Update the main sitemap resource list
         # @return Array<Middleman::Sitemap::Resource>
         Contract ResourceList => ResourceList
         def manipulate_resource_list(resources)
-          resources + @proxy_configs.map do |config|
-            p = ProxyResource.new(
-              @app.sitemap,
-              config.path,
-              config.target
-            )
-
-            p.add_metadata(config.metadata)
-            p
-          end
+          resources + @proxy_configs.map { |c| c.to_resource(@app) }
         end
       end
 
-      # Configuration for a proxy instance
-      class ProxyConfiguration
-        # The path that this proxy will appear at in the sitemap
-        attr_reader :path
-        def path=(p)
-          @path = ::Middleman::Util.normalize_path(p)
-        end
-
-        # The existing sitemap path that this will proxy to
-        attr_reader :target
-        def target=(t)
-          @target = ::Middleman::Util.normalize_path(t)
-        end
-
-        # Additional metadata like locals to apply to the proxy
-        attr_accessor :metadata
-
-        # Create a new proxy configuration from hash options
-        def initialize(options={})
-          options.each do |key, value|
-            send "#{key}=", value
+      ProxyDescriptor = Struct.new(:path, :target, :metadata) do
+        def to_resource(app)
+          ProxyResource.new(app.sitemap, path, target).tap do |p|
+            md = metadata.dup
+            p.add_metadata(
+                             locals: md.delete(:locals) || {},
+                             page: md.delete(:data) || {},
+                             options: md
+                           )
           end
         end
-
-        # Two configurations are equal if they reference the same path
-        def eql?(other)
-          other.path == path
-        end
-
-        # Two configurations are equal if they reference the same path
-        def hash
-          path.hash
-        end
       end
     end
 

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

@@ -42,12 +42,22 @@ module Middleman
       # @param [Middleman::Sitemap::Store] store
       # @param [String] path
       # @param [String] source_file
-      Contract IsA['Middleman::Sitemap::Store'], String, Maybe[IsA['Middleman::SourceFile']] => Any
+      Contract IsA['Middleman::Sitemap::Store'], String, Maybe[Or[IsA['Middleman::SourceFile'], String]] => Any
       def initialize(store, path, source_file=nil)
         @store       = store
         @app         = @store.app
         @path        = path.gsub(' ', '%20') # handle spaces in filenames
-        @source_file = source_file
+
+        if source_file && source_file.is_a?(String)
+          source_file = Pathname(source_file)
+        end
+
+        if source_file && source_file.is_a?(Pathname)
+          @source_file = ::Middleman::SourceFile.new(source_file.relative_path_from(@app.source_dir), source_file, @app.source_dir, Set.new([:source]))
+        else
+          @source_file = source_file
+        end
+
         @destination_path = @path
 
         # Options are generally rendering/sitemap options
@@ -165,7 +175,11 @@ module Middleman
         # Ignore based on the source path (without template extensions)
         return true if @app.sitemap.ignored?(path)
         # This allows files to be ignored by their source file name (with template extensions)
-        !self.is_a?(ProxyResource) && @app.sitemap.ignored?(source_file[:relative_path].to_s)
+        if !self.is_a?(ProxyResource) && source_file && @app.sitemap.ignored?(source_file[:relative_path].to_s)
+          true
+        else
+          false
+        end
       end
 
       # The preferred MIME content type for this resource based on extension or metadata
@@ -174,6 +188,31 @@ module Middleman
       def content_type
         options[:content_type] || ::Rack::Mime.mime_type(ext, nil)
       end
+
+      def to_s
+        "#<Middleman::Sitemap::Resource path=#{@path}>"
+      end
+      alias_method :inspect, :to_s # Ruby 2.0 calls inspect for NoMethodError instead of to_s
+    end
+
+    class StringResource < Resource
+      def initialize(store, path, contents=nil, &block)
+        @request_path = path
+        @contents = block_given? ? block : contents
+        super(store, path)
+      end
+
+      def template?
+        true
+      end
+
+      def render(*)
+        @contents.respond_to?(:call) ? @contents.call : @contents
+      end
+
+      def binary?
+        false
+      end
     end
   end
 end

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

@@ -49,11 +49,15 @@ module Middleman
       # @return [Middleman::Application]
       attr_reader :app
 
+      attr_reader :update_count
+
       # Initialize with parent app
       # @param [Middleman::Application] app
       def initialize(app)
         @app = app
         @resources = []
+        @update_count = 0
+
         # TODO: Should this be a set or hash?
         @resource_list_manipulators = []
         @needs_sitemap_rebuild = true
@@ -187,6 +191,7 @@ module Middleman
           end
 
           invalidate_resources_not_ignored_cache!
+          @update_count += 1
         end
       end
 

data/lib/middleman-core/sources.rb

@@ -1,8 +1,9 @@
 require 'middleman-core/contracts'
+require 'backports/2.0.0/enumerable/lazy'
 
 module Middleman
   # The standard "record" that contains information about a file on disk.
-  SourceFile = Struct.new :relative_path, :full_path, :directory, :type
+  SourceFile = Struct.new :relative_path, :full_path, :directory, :types
 
   # Sources handle multiple on-disk collections of files which make up
   # a Middleman project. They are separated by `type` which can then be
@@ -18,7 +19,7 @@ module Middleman
     attr_reader :app
 
     # Duck-typed definition of a valid source watcher
-    HANDLER = RespondTo[:changed]
+    HANDLER = RespondTo[:on_change]
 
     # Config
     Contract None => Hash
@@ -82,8 +83,8 @@ module Middleman
     Contract SourceFile => Bool
     def globally_ignored?(file)
       @ignores.values.any? do |descriptor|
-        ((descriptor[:type] == :all) || (file[:type] == descriptor[:type])) &&
-        matches?(descriptor[:validator], file)
+        ((descriptor[:type] == :all) || file[:types].include?(descriptor[:type])) &&
+          matches?(descriptor[:validator], file)
       end
     end
 
@@ -113,7 +114,7 @@ module Middleman
         [priority, n]
       end.reverse.freeze
 
-      handler.changed(&method(:did_change))
+      handler.on_change(&method(:did_change))
 
       if @running
         handler.poll_once!
@@ -133,7 +134,7 @@ module Middleman
     #
     # @param [SourceWatcher] watcher The watcher to remove.
     # @return [void]
-    Contract RespondTo[:changed] => Any
+    Contract RespondTo[:on_change] => Any
     def unwatch(watcher)
       @watchers.delete(watcher)
 
@@ -156,7 +157,7 @@ module Middleman
     # @return [Array<Middleman::SourceFile>]
     Contract None => ArrayOf[SourceFile]
     def files
-      watchers.map(&:files).flatten.uniq { |f| f[:relative_path] }
+      watchers.flat_map(&:files).uniq { |f| f[:relative_path] }
     end
 
     # Find a file given a type and path.
@@ -168,10 +169,11 @@ module Middleman
     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
+        .lazy
+        .select { |d| d.type == type }
+        .map { |d| d.find(path, glob) }
+        .reject(&:nil?)
+        .first
     end
 
     # Check if a file for a given type exists.
@@ -182,8 +184,9 @@ module Middleman
     Contract Symbol, String => Bool
     def exists?(type, path)
       watchers
-          .select { |d| d.type == type }
-          .any? { |d| d.exists?(path) }
+        .lazy
+        .select { |d| d.type == type }
+        .any? { |d| d.exists?(path) }
     end
 
     # Check if a file for a given type exists.
@@ -191,11 +194,11 @@ module Middleman
     # @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)
+    Contract SetOf[Symbol], String => Maybe[HANDLER]
+    def watcher_for_path(types, path)
       watchers
-          .select { |d| d.type == type }
-          .find { |d| d.exists?(path) }
+        .select { |d| types.include?(d.type) }
+        .find { |d| d.exists?(path) }
     end
 
     # Manually poll all watchers for new content.
@@ -230,16 +233,53 @@ module Middleman
     # A callback requires a type and the proc to execute.
     CallbackDescriptor = Struct.new :type, :proc
 
-    # Add callback to be run on file change
+    # Add callback to be run on file change or deletion
     #
-    # @param [nil,Regexp] matcher A Regexp to match the change path against
+    # @param [Symbol] type The change type.
     # @return [Set<CallbackDescriptor>]
     Contract Symbol, Proc => ArrayOf[CallbackDescriptor]
-    def changed(type, &block)
+    def on_change(type, &block)
       @on_change_callbacks << CallbackDescriptor.new(type, block)
       @on_change_callbacks
     end
 
+    # Backwards compatible change handler.
+    #
+    # @param [nil,Regexp] matcher A Regexp to match the change path against
+    # Contract Maybe[Regexp] => Any
+    def changed(matcher=nil, &block)
+      on_change :source do |updated, _removed|
+        updated.select { |f|
+          matcher.nil? ? true : matches?(matcher, f)
+        }.each do |f|
+          block.call(f[:relative_path])
+        end
+      end
+    end
+
+    # Backwards compatible delete handler.
+    #
+    # @param [nil,Regexp] matcher A Regexp to match the change path against
+    # Contract Maybe[Regexp] => Any
+    def deleted(matcher=nil, &block)
+      on_change :source do |_updated, removed|
+        removed.select { |f|
+          matcher.nil? ? true : matches?(matcher, f)
+        }.each do |f|
+          block.call(f[:relative_path])
+        end
+      end
+    end
+
+    # Backwards compatible ignored check.
+    #
+    # @param [Pathname,String] path The path to check.
+    Contract Or[Pathname, String] => Bool
+    def ignored?(path)
+      descriptor = find(:source, path)
+      !descriptor || globally_ignored?(descriptor)
+    end
+
     protected
 
     # Whether a validator matches a file.
@@ -272,11 +312,11 @@ module Middleman
     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
+        watcher_for_path(file[:types], 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?
+        watcher_for_path(file[:types], file[:relative_path].to_s).nil?
       end
 
       return if valid_updated.empty? && valid_removed.empty?
@@ -296,8 +336,8 @@ module Middleman
         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] }
+          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)
         end

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

@@ -1,7 +1,7 @@
 # Watcher Library
 require 'listen'
-
 require 'middleman-core/contracts'
+require 'backports/2.0.0/enumerable/lazy'
 
 module Middleman
   # The default source watcher implementation. Watches a directory on disk
@@ -43,6 +43,7 @@ module Middleman
       @directory = Pathname(directory)
 
       @files = {}
+      @extensionless_files = {}
 
       @validator = options.fetch(:validator, proc { true })
       @ignored = options.fetch(:ignored, proc { false })
@@ -103,10 +104,8 @@ module Middleman
       return nil if p.absolute? && !p.to_s.start_with?(@directory.to_s)
 
       p = @directory + p if p.relative?
-
       if glob
-        found = @files.find { |_, v| v[:relative_path].fnmatch(path) }
-        found ? found.last : nil
+        @extensionless_files[p]
       else
         @files[p]
       end
@@ -173,7 +172,7 @@ module Middleman
     # @param [Proc] matcher A Regexp to match the change path against
     # @return [Set<Proc>]
     Contract Proc => SetOf[Proc]
-    def changed(&block)
+    def on_change(&block)
       @on_change_callbacks << block
       @on_change_callbacks
     end
@@ -211,25 +210,48 @@ module Middleman
     Contract ArrayOf[Pathname], ArrayOf[Pathname] => Any
     def update(updated_paths, removed_paths)
       valid_updates = updated_paths
-          .map(&method(:path_to_source_file))
-          .select(&method(:valid?))
-
-      valid_updates.each do |f|
-        @files[f[:full_path]] = f
-        logger.debug "== Change (#{f[:type]}): #{f[:relative_path]}"
-      end
+                      .lazy
+                      .map(&method(:path_to_source_file))
+                      .select(&method(:valid?))
+                      .to_a
+                      .each do |f|
+                        add_file_to_cache(f)
+                        logger.debug "== Change (#{f[:types].inspect}): #{f[:relative_path]}"
+                      end
 
       valid_removes = removed_paths
-          .select(&@files.method(:key?))
-          .map(&@files.method(:[]))
-          .select(&method(:valid?))
+                      .lazy
+                      .select(&@files.method(:key?))
+                      .map(&@files.method(:[]))
+                      .select(&method(:valid?))
+                      .to_a
+                      .each do |f|
+                        remove_file_from_cache(f)
+                        logger.debug "== Deletion (#{f[:types].inspect}): #{f[:relative_path]}"
+                      end
+
+      run_callbacks(
+        @on_change_callbacks,
+        valid_updates,
+        valid_removes
+      ) unless valid_updates.empty? && valid_removes.empty?
+    end
 
-      valid_removes.each do |f|
-        @files.delete(f[:full_path])
-        logger.debug "== Deletion (#{f[:type]}): #{f[:relative_path]}"
-      end
+    def add_file_to_cache(f)
+      @files[f[:full_path]] = f
+      @extensionless_files[strip_extensions(f[:full_path])] = f
+    end
 
-      run_callbacks(@on_change_callbacks, valid_updates, valid_removes) unless valid_updates.empty? && valid_removes.empty?
+    def remove_file_from_cache(f)
+      @files.delete(f[:full_path])
+      @extensionless_files.delete(strip_extensions(f[:full_path]))
+    end
+
+    def strip_extensions(p)
+      while ::Tilt[p.to_s] || p.extname === '.html'
+        p = p.sub_ext('')
+      end
+      Pathname(p.to_s + '.*')
     end
 
     # Check if this watcher should care about a file.
@@ -239,8 +261,8 @@ module Middleman
     Contract IsA['Middleman::SourceFile'] => Bool
     def valid?(file)
       @validator.call(file) &&
-      !globally_ignored?(file) &&
-      !@ignored.call(file)
+        !globally_ignored?(file) &&
+        !@ignored.call(file)
     end
 
     # Convert a path to a file resprentation.
@@ -249,8 +271,10 @@ module Middleman
     # @return [Middleman::SourceFile]
     Contract Pathname => IsA['Middleman::SourceFile']
     def path_to_source_file(path)
+      types = Set.new([@type])
+
       ::Middleman::SourceFile.new(
-        path.relative_path_from(@directory), path, @directory, @type)
+          path.relative_path_from(@directory), path, @directory, types)
     end
 
     # Notify callbacks for a file given an array of callbacks