middleman-core 3.4.1 → 4.0.0.alpha.2

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

@@ -1,105 +1,81 @@
+require 'middleman-core/sitemap/resource'
+
 module Middleman
   module Sitemap
     module Extensions
-      module RequestEndpoints
-        # Setup extension
-        class << self
-          # Once registered
-          def registered(app)
-            # Include methods
-            app.send :include, InstanceMethods
-          end
-
-          alias_method :included, :registered
-        end
-
-        module InstanceMethods
-          def endpoint_manager
-            @_endpoint_manager ||= EndpointManager.new(self)
-          end
-
-          def endpoint(*args, &block)
-            endpoint_manager.create_endpoint(*args, &block)
-          end
-        end
-
+      class RequestEndpoints < Extension
         # Manages the list of proxy configurations and manipulates the sitemap
         # to include new resources based on those configurations
-        class EndpointManager
-          def initialize(app)
-            @app = app
-            @endpoints = {}
-          end
-
-          # Setup a proxy from a path to a target
-          # @param [String] path
-          # @param [Hash] opts The :path value gives a request path if it
-          # differs from the output path
-          def create_endpoint(path, opts={}, &block)
-            endpoint = {
-              request_path: path
-            }
+        def initialize(app, config={}, &block)
+          super
 
-            if block_given?
-              endpoint[:output] = block
-            else
-              endpoint[:request_path] = opts[:path] if opts.key?(:path)
-            end
-
-            @endpoints[path] = endpoint
-
-            @app.sitemap.rebuild_resource_list!(:added_endpoint)
-          end
+          @app.add_to_config_context(:endpoint, &method(:create_endpoint))
 
-          # Update the main sitemap resource list
-          # @return [void]
-          def manipulate_resource_list(resources)
-            resources + @endpoints.map do |path, config|
-              r = EndpointResource.new(
-                @app.sitemap,
-                path,
-                config[:request_path]
-              )
-              r.output = config[:output] if config.key?(:output)
-              r
-            end
-          end
+          @endpoints = {}
         end
 
-        class EndpointResource < ::Middleman::Sitemap::Resource
-          attr_accessor :output
+        # Setup a proxy from a path to a target
+        # @param [String] path
+        # @param [Hash] opts The :path value gives a request path if it
+        # differs from the output path
+        Contract String, Or[({ path: String }), Proc] => Any
+        def create_endpoint(path, opts={}, &block)
+          endpoint = {
+            request_path: path
+          }
+
+          if block_given?
+            endpoint[:output] = block
+          else
+            endpoint[:request_path] = opts[:path] if opts.key?(:path)
+          end
 
-          def initialize(store, path, source_file)
-            @request_path = ::Middleman::Util.normalize_path(source_file)
+          @endpoints[path] = endpoint
 
-            super(store, path)
-          end
+          @app.sitemap.rebuild_resource_list!(:added_endpoint)
+        end
 
-          def template?
-            true
+        # Update the main sitemap resource list
+        # @return Array<Middleman::Sitemap::Resource>
+        Contract ResourceList => ResourceList
+        def manipulate_resource_list(resources)
+          resources + @endpoints.map do |path, config|
+            r = EndpointResource.new(
+              @app.sitemap,
+              path,
+              config[:request_path]
+            )
+            r.output = config[:output] if config.key?(:output)
+            r
           end
+        end
+      end
 
-          def render(*)
-            return output.call if output
-          end
+      class EndpointResource < ::Middleman::Sitemap::Resource
+        Contract None => Maybe[Proc]
+        attr_accessor :output
 
-          attr_reader :request_path
+        def initialize(store, path, request_path)
+          super(store, path)
+          @request_path = ::Middleman::Util.normalize_path(request_path)
+        end
 
-          def binary?
-            false
-          end
+        Contract None => String
+        attr_reader :request_path
 
-          def raw_data
-            {}
-          end
+        Contract None => Bool
+        def template?
+          true
+        end
 
-          def ignored?
-            false
-          end
+        Contract Args[Any] => String
+        def render(*)
+          return output.call if output
+        end
 
-          def metadata
-            @local_metadata.dup
-          end
+        Contract None => Bool
+        def ignored?
+          false
         end
       end
     end

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

@@ -7,15 +7,13 @@ module Middleman
         def parent
           parts = path.split('/')
           tail = parts.pop
-          is_index = (tail == app.index_file)
+          is_index = (tail == @app.config[:index_file])
 
-          if parts.empty?
-            return is_index ? nil : store.find_resource_by_path(app.index_file)
-          end
+          return nil if is_index && parts.length < 1
 
           test_expr = parts.join('\\/')
-          # A makeshift for eponymous reverse-lookup
-          found = store.resources.find do |candidate|
+          # eponymous reverse-lookup
+          found = @store.resources.find do |candidate|
             candidate.path =~ %r{^#{test_expr}(?:\.[a-zA-Z0-9]+|\/)$}
           end
 
@@ -23,7 +21,7 @@ module Middleman
             found
           else
             parts.pop if is_index
-            store.find_resource_by_destination_path("#{parts.join('/')}/#{app.index_file}")
+            @store.find_resource_by_destination_path("#{parts.join('/')}/#{@app.config[:index_file]}")
           end
         end
 
@@ -36,11 +34,11 @@ module Middleman
             base_path = eponymous_directory_path
             prefix    = %r{^#{base_path.sub("/", "\\/")}}
           else
-            base_path = path.sub("#{app.index_file}", '')
+            base_path = path.sub("#{@app.config[:index_file]}", '')
             prefix    = %r{^#{base_path.sub("/", "\\/")}}
           end
 
-          store.resources.select do |sub_resource|
+          @store.resources.select do |sub_resource|
             if sub_resource.path == path || sub_resource.path !~ prefix
               false
             else
@@ -49,7 +47,7 @@ module Middleman
               if parts.length == 1
                 true
               elsif parts.length == 2
-                parts.last == app.index_file
+                parts.last == @app.config[:index_file]
               else
                 false
               end
@@ -64,22 +62,23 @@ module Middleman
           parent.children.reject { |p| p == self }
         end
 
-        # Whether this resource either a directory index, or has the same name as an existing directory in the source
+        # Whether this resource is either a directory index, or has the same name as an existing directory in the source
         # @return [Boolean]
         def directory_index?
-          path.include?(app.index_file) || path =~ /\/$/ || eponymous_directory?
+          path.include?(@app.config[:index_file]) || path =~ /\/$/ || eponymous_directory?
         end
 
         # Whether the resource has the same name as a directory in the source
         # (e.g., if the resource is named 'gallery.html' and a path exists named 'gallery/', this would return true)
         # @return [Boolean]
         def eponymous_directory?
-          if !path.end_with?("/#{app.index_file}") && destination_path.end_with?("/#{app.index_file}")
+          if !path.end_with?("/#{@app.config[:index_file]}") && destination_path.end_with?("/#{@app.config[:index_file]}")
             return true
           end
 
-          full_path = File.join(app.source_dir, eponymous_directory_path)
-          File.exist?(full_path) && File.directory?(full_path)
+          @app.files.by_type(:source).watchers.any? do |source|
+            (source.directory + Pathname(eponymous_directory_path)).directory?
+          end
         end
 
         # The path for this resource if it were a directory, and not a file

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

@@ -1,150 +1,178 @@
+require 'rack/mime'
 require 'middleman-core/sitemap/extensions/traversal'
-require 'middleman-core/sitemap/extensions/content_type'
+require 'middleman-core/file_renderer'
+require 'middleman-core/template_renderer'
+require 'middleman-core/contracts'
 
 module Middleman
   # Sitemap namespace
   module Sitemap
     # Sitemap Resource class
     class Resource
+      include Contracts
       include Middleman::Sitemap::Extensions::Traversal
-      include Middleman::Sitemap::Extensions::ContentType
-
-      # @return [Middleman::Application]
-      attr_reader :app
-      delegate :logger, :instrument, to: :app
-
-      # @return [Middleman::Sitemap::Store]
-      attr_reader :store
 
       # The source path of this resource (relative to the source directory,
       # without template extensions)
       # @return [String]
       attr_reader :path
 
-      # The output path for this resource
+      # The output path in the build directory for this resource
       # @return [String]
       attr_accessor :destination_path
 
-      # Set the on-disk source file for this resource
+      # The on-disk source file for this resource, if there is one
       # @return [String]
-      # attr_reader :source_file
+      Contract None => Maybe[IsA['Middleman::SourceFile']]
+      attr_reader :source_file
 
-      def source_file
-        @source_file || get_source_file
-      end
+      # The path to use when requesting this resource. Normally it's
+      # the same as {#destination_path} but it can be overridden in subclasses.
+      # @return [String]
+      alias_method :request_path, :destination_path
+
+      METADATA_HASH = ({ options: Maybe[Hash], locals: Maybe[Hash], page: Maybe[Hash] })
+
+      # The metadata for this resource
+      # @return [Hash]
+      Contract None => METADATA_HASH
+      attr_reader :metadata
 
       # Initialize resource with parent store and URL
       # @param [Middleman::Sitemap::Store] store
       # @param [String] path
       # @param [String] source_file
+      Contract IsA['Middleman::Sitemap::Store'], String, Maybe[IsA['Middleman::SourceFile']] => Any
       def initialize(store, path, source_file=nil)
         @store       = store
         @app         = @store.app
-        @path        = path
+        @path        = path.gsub(' ', '%20') # handle spaces in filenames
         @source_file = source_file
         @destination_path = @path
 
-        @local_metadata = { options: {}, locals: {}, page: {}, blocks: [] }
+        # Options are generally rendering/sitemap options
+        # Locals are local variables for rendering this resource's template
+        # Page are data that is exposed through this resource's data member.
+        # Note: It is named 'page' for backwards compatibility with older MM.
+        @metadata = { options: {}, locals: {}, page: {} }
       end
 
       # Whether this resource has a template file
       # @return [Boolean]
+      Contract None => Bool
       def template?
         return false if source_file.nil?
-        !::Tilt[source_file].nil?
+        !::Tilt[source_file[:full_path].to_s].nil?
       end
 
-      # Get the metadata for both the current source_file and the current path
-      # @return [Hash]
-      def metadata
-        result = store.metadata_for_path(path).dup
-
-        file_meta = store.metadata_for_file(source_file).dup
-        result[:blocks] += file_meta.delete(:blocks) if file_meta.key?(:blocks)
-        result.deep_merge!(file_meta)
+      # Merge in new metadata specific to this resource.
+      # @param [Hash] meta A metadata block with keys :options, :locals, :page.
+      #   Options are generally rendering/sitemap options
+      #   Locals are local variables for rendering this resource's template
+      #   Page are data that is exposed through this resource's data member.
+      #   Note: It is named 'page' for backwards compatibility with older MM.
+      Contract METADATA_HASH => METADATA_HASH
+      def add_metadata(meta={})
+        @metadata.deep_merge!(meta)
+      end
 
-        local_meta = @local_metadata.dup
-        result[:blocks] += local_meta.delete(:blocks) if local_meta.key?(:blocks)
-        result.deep_merge!(local_meta)
+      # Data about this resource, populated from frontmatter or extensions.
+      # @return [HashWithIndifferentAccess]
+      Contract None => IsA['Middleman::Util::HashWithIndifferentAccess']
+      def data
+        # TODO: Should this really be a HashWithIndifferentAccess?
+        ::Middleman::Util.recursively_enhance(metadata[:page])
+      end
 
-        result[:blocks] = result[:blocks].flatten.compact
-        result
+      # Options about how this resource is rendered, such as its :layout,
+      # :renderer_options, and whether or not to use :directory_indexes.
+      # @return [Hash]
+      Contract None => Hash
+      def options
+        metadata[:options]
       end
 
-      # Merge in new metadata specific to this resource.
-      # @param [Hash] metadata A metadata block like provides_metadata_for_path takes
-      def add_metadata(metadata={}, &block)
-        metadata = metadata.dup
-        @local_metadata[:blocks] += metadata.delete(:blocks) if metadata.key?(:blocks)
-        @local_metadata.deep_merge!(metadata)
-        @local_metadata[:blocks] += [block] if block_given?
+      # Local variable mappings that are used when rendering the template for this resource.
+      # @return [Hash]
+      Contract None => Hash
+      def locals
+        metadata[:locals]
       end
 
       # Extension of the path (i.e. '.js')
       # @return [String]
+      Contract None => String
       def ext
         File.extname(path)
       end
 
-      def request_path
-        destination_path
-      end
-
       # Render this resource
       # @return [String]
-      def render(opts={}, locs={}, &block)
-        return app.template_data_for_file(source_file) unless template?
-
-        relative_source = Pathname(source_file).relative_path_from(Pathname(app.root))
+      Contract Hash, Hash => String
+      def render(opts={}, locs={})
+        return ::Middleman::FileRenderer.new(@app, source_file[:full_path].to_s).template_data_for_file unless template?
 
-        instrument 'render.resource', path: relative_source, destination_path: destination_path  do
-          md   = metadata.dup
+        ::Middleman::Util.instrument 'render.resource', path: source_file[:full_path].to_s, destination_path: destination_path do
+          md   = metadata
           opts = md[:options].deep_merge(opts)
-
-          # Pass "renderer_options" hash from frontmatter along to renderer
-          if md[:page]['renderer_options']
-            opts[:renderer_options] = {}
-            md[:page]['renderer_options'].each do |k, v|
-              opts[:renderer_options][k.to_sym] = v
-            end
-          end
-
           locs = md[:locals].deep_merge(locs)
-
-          # Forward remaining data to helpers
-          app.data.store('page', md[:page]) if md.key?(:page)
-
-          blocks = Array(md[:blocks]).dup
-          blocks << block if block_given?
-
-          app.current_path ||= destination_path
+          locs[:current_path] ||= destination_path
 
           # Certain output file types don't use layouts
           unless opts.key?(:layout)
             opts[:layout] = false if %w(.js .json .css .txt).include?(ext)
           end
 
-          app.render_template(source_file, locs, opts, blocks)
+          renderer = ::Middleman::TemplateRenderer.new(@app, source_file[:full_path].to_s)
+          renderer.render(locs, opts)
         end
       end
 
       # A path without the directory index - so foo/index.html becomes
       # just foo. Best for linking.
       # @return [String]
+      Contract None => String
       def url
         url_path = destination_path
-        if app.strip_index_file
-          url_path = url_path.sub(/(^|\/)#{Regexp.escape(app.index_file)}$/,
-                                  app.trailing_slash ? '/' : '')
+        if @app.config[:strip_index_file]
+          url_path = url_path.sub(/(^|\/)#{Regexp.escape(@app.config[:index_file])}$/,
+                                  @app.config[:trailing_slash] ? '/' : '')
         end
-        File.join(app.respond_to?(:http_prefix) ? app.http_prefix : '/', url_path)
+        File.join(@app.config[:http_prefix], url_path)
       end
 
       # Whether the source file is binary.
       #
       # @return [Boolean]
+      Contract None => Bool
       def binary?
-        ::Middleman::Util.binary?(source_file)
+        !source_file.nil? && ::Middleman::Util.binary?(source_file[:full_path].to_s)
+      end
+
+      # Ignore a resource directly, without going through the whole
+      # ignore filter stuff.
+      # @return [void]
+      Contract None => Any
+      def ignore!
+        @ignored = true
+      end
+
+      # Whether the Resource is ignored
+      # @return [Boolean]
+      Contract None => Bool
+      def ignored?
+        return true if @ignored
+        # 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)
+      end
+
+      # The preferred MIME content type for this resource based on extension or metadata
+      # @return [String] MIME type for this resource
+      Contract None => Maybe[String]
+      def content_type
+        options[:content_type] || ::Rack::Mime.mime_type(ext, nil)
       end
     end
   end