RubyGems - middleman-core-with-external-sources-watch-fix - Versions diffs - 4.1.0 - Mend

middleman-core-with-external-sources-watch-fix 4.1.0

Files changed (1131) hide show

data/lib/middleman-core/sitemap/extensions/redirects.rb ADDED Viewed

@@ -0,0 +1,84 @@
+require 'middleman-core/sitemap/resource'
+require 'middleman-core/contracts'
+module Middleman
+  module Sitemap
+    module Extensions
+      # Manages the list of proxy configurations and manipulates the sitemap
+      # to include new resources based on those configurations
+      class Redirects < ConfigExtension
+        self.resource_list_manipulator_priority = 0
+        # Expose `redirect`
+        expose_to_config :redirect
+        RedirectDescriptor = Struct.new(:path, :to, :template) do
+          def execute_descriptor(app, resources)
+            r = RedirectResource.new(
+              app.sitemap,
+              path,
+              to
+            )
+            r.output = template if template
+            resources + [r]
+          end
+        end
+        # Setup a redirect from a path to a target
+        # @param [String] path
+        # @param [Hash] opts The :to value gives a target path
+        Contract String, { to: Or[String, ::Middleman::Sitemap::Resource] }, Maybe[Proc] => RedirectDescriptor
+        def redirect(path, opts={}, &block)
+          RedirectDescriptor.new(path, opts[:to], block_given? ? block : nil)
+        end
+      end
+      class RedirectResource < ::Middleman::Sitemap::Resource
+        Contract Maybe[Proc]
+        attr_accessor :output
+        def initialize(store, path, target)
+          @request_path = target
+          super(store, path)
+        end
+        Contract Bool
+        def template?
+          true
+        end
+        Contract Args[Any] => String
+        def render(*)
+          url = ::Middleman::Util.url_for(@store.app, @request_path,
+                                          relative: false,
+                                          find_resource: true
+                                         )
+          if output
+            output.call(path, url)
+          else
+            <<-END
+              <html>
+                <head>
+                  <link rel="canonical" href="#{url}" />
+                  <meta http-equiv=refresh content="0; url=#{url}" />
+                  <meta name="robots" content="noindex,follow" />
+                  <meta http-equiv="cache-control" content="no-cache" />
+                </head>
+                <body>
+                </body>
+              </html>
+            END
+          end
+        end
+        Contract Bool
+        def ignored?
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+require 'middleman-core/sitemap/resource'
+module Middleman
+  module Sitemap
+    module Extensions
+      class RequestEndpoints < ConfigExtension
+        self.resource_list_manipulator_priority = 0
+        # Expose `endpoint`
+        expose_to_config :endpoint
+        EndpointDescriptor = Struct.new(:path, :request_path, :block) do
+          def execute_descriptor(app, resources)
+            r = EndpointResource.new(
+              app.sitemap,
+              path,
+              request_path
+            )
+            r.output = block if block
+            resources + [r]
+          end
+        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
+        Contract String, Or[{ path: String }, Proc] => EndpointDescriptor
+        def endpoint(path, opts={}, &block)
+          if block_given?
+            EndpointDescriptor.new(path, path, block)
+          else
+            EndpointDescriptor.new(path, opts[:path] || path, nil)
+          end
+        end
+      end
+      class EndpointResource < ::Middleman::Sitemap::Resource
+        Contract Maybe[Proc]
+        attr_accessor :output
+        def initialize(store, path, request_path)
+          super(store, path)
+          @request_path = ::Middleman::Util.normalize_path(request_path)
+        end
+        Contract String
+        attr_reader :request_path
+        Contract Bool
+        def template?
+          true
+        end
+        Contract Args[Any] => String
+        def render(*)
+          return output.call if output
+        end
+        Contract Bool
+        def ignored?
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+module Middleman
+  module Sitemap
+    module Extensions
+      module Traversal
+        def traversal_root
+          root = if !@app.extensions[:i18n]
+            '/'
+          else
+            @app.extensions[:i18n].path_root(::I18n.locale)
+          end
+          root.sub(/^\//, '')
+        end
+        # This resource's parent resource
+        # @return [Middleman::Sitemap::Resource, nil]
+        def parent
+          root = path.sub(/^#{::Regexp.escape(traversal_root)}/, '')
+          parts = root.split('/')
+          tail = parts.pop
+          is_index = (tail == @app.config[:index_file])
+          if parts.empty?
+            return is_index ? nil : @store.find_resource_by_path(@app.config[:index_file])
+          end
+          test_expr = parts.join('\\/')
+          # eponymous reverse-lookup
+          found = @store.resources.find do |candidate|
+            candidate.path =~ %r{^#{test_expr}(?:\.[a-zA-Z0-9]+|\/)$}
+          end
+          if found
+            found
+          else
+            parts.pop if is_index
+            @store.find_resource_by_destination_path("#{parts.join('/')}/#{@app.config[:index_file]}")
+          end
+        end
+        # This resource's child resources
+        # @return [Array<Middleman::Sitemap::Resource>]
+        def children
+          return [] unless directory_index?
+          base_path = if eponymous_directory?
+            eponymous_directory_path
+          else
+            path.sub(@app.config[:index_file].to_s, '')
+          end
+          prefix = %r{^#{base_path.sub("/", "\\/")}}
+          @store.resources.select do |sub_resource|
+            if sub_resource.path == path || sub_resource.path !~ prefix
+              false
+            else
+              inner_path = sub_resource.path.sub(prefix, '')
+              parts = inner_path.split('/')
+              if parts.length == 1
+                true
+              elsif parts.length == 2
+                parts.last == @app.config[:index_file]
+              else
+                false
+              end
+            end
+          end
+        end
+        # This resource's sibling resources
+        # @return [Array<Middleman::Sitemap::Resource>]
+        def siblings
+          return [] unless parent
+          parent.children.reject { |p| p == self }
+        end
+        # 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.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.config[:index_file]}") && destination_path.end_with?("/#{@app.config[:index_file]}")
+            return true
+          end
+          @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
+        # (e.g., for 'gallery.html' this would return 'gallery/')
+        # @return [String]
+        def eponymous_directory_path
+          path.sub(ext, '/').sub(/\/$/, '') + '/'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,216 @@
+require 'rack/mime'
+require 'middleman-core/sitemap/extensions/traversal'
+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
+      # The source path of this resource (relative to the source directory,
+      # without template extensions)
+      # @return [String]
+      attr_reader :path
+      # The output path in the build directory for this resource
+      # @return [String]
+      attr_accessor :destination_path
+      # The on-disk source file for this resource, if there is one
+      # @return [String]
+      Contract Maybe[IsA['Middleman::SourceFile']]
+      attr_reader :file_descriptor
+      # 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 request_path destination_path
+      METADATA_HASH = { options: Maybe[Hash], locals: Maybe[Hash], page: Maybe[Hash] }.freeze
+      # The metadata for this resource
+      # @return [Hash]
+      Contract METADATA_HASH
+      attr_reader :metadata
+      attr_accessor :ignored
+      # Initialize resource with parent store and URL
+      # @param [Middleman::Sitemap::Store] store
+      # @param [String] path
+      # @param [String] source
+      Contract IsA['Middleman::Sitemap::Store'], String, Maybe[Or[IsA['Middleman::SourceFile'], String]] => Any
+      def initialize(store, path, source=nil)
+        @store       = store
+        @app         = @store.app
+        @path        = path
+        @ignored     = false
+        source = Pathname(source) if source && source.is_a?(String)
+        @file_descriptor = if source && source.is_a?(Pathname)
+          ::Middleman::SourceFile.new(source.relative_path_from(@app.source_dir), source, @app.source_dir, Set.new([:source]), 0)
+        else
+          source
+        end
+        @destination_path = @path
+        # 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: {} }
+        @page_data = nil
+      end
+      # Whether this resource has a template file
+      # @return [Boolean]
+      Contract Bool
+      def template?
+        return false if file_descriptor.nil?
+        !::Tilt[file_descriptor[:full_path].to_s].nil?
+      end
+      # Backwards compatible method for turning descriptor into a string.
+      # @return [String]
+      Contract String
+      def source_file
+        file_descriptor && file_descriptor[:full_path].to_s
+      end
+      # 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={})
+        @page_data = nil
+        @metadata.deep_merge!(meta)
+      end
+      # Data about this resource, populated from frontmatter or extensions.
+      # @return [Hash]
+      Contract RespondTo[:indifferent_access?]
+      def data
+        @page_data ||= ::Middleman::Util.recursively_enhance(metadata[:page])
+      end
+      # Options about how this resource is rendered, such as its :layout,
+      # :renderer_options, and whether or not to use :directory_indexes.
+      # @return [Hash]
+      Contract Hash
+      def options
+        metadata[:options]
+      end
+      # Local variable mappings that are used when rendering the template for this resource.
+      # @return [Hash]
+      Contract Hash
+      def locals
+        metadata[:locals]
+      end
+      # Extension of the path (i.e. '.js')
+      # @return [String]
+      Contract String
+      def ext
+        File.extname(path)
+      end
+      # Render this resource
+      # @return [String]
+      Contract Hash, Hash => String
+      def render(opts={}, locs={})
+        return ::Middleman::FileRenderer.new(@app, file_descriptor[:full_path].to_s).template_data_for_file unless template?
+        md   = metadata
+        opts = md[:options].deep_merge(opts)
+        locs = md[:locals].deep_merge(locs)
+        locs[:current_path] ||= destination_path
+        # Certain output file types don't use layouts
+        opts[:layout] = false if !opts.key?(:layout) && !@app.config.extensions_with_layout.include?(ext)
+        renderer = ::Middleman::TemplateRenderer.new(@app, file_descriptor[:full_path].to_s)
+        renderer.render(locs, opts)
+      end
+      # A path without the directory index - so foo/index.html becomes
+      # just foo. Best for linking.
+      # @return [String]
+      Contract String
+      def url
+        url_path = destination_path
+        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.config[:http_prefix], url_path)
+      end
+      # Whether the source file is binary.
+      #
+      # @return [Boolean]
+      Contract Bool
+      def binary?
+        !file_descriptor.nil? && (file_descriptor[:types].include?(:binary) || ::Middleman::Util.binary?(file_descriptor[:full_path].to_s))
+      end
+      # Ignore a resource directly, without going through the whole
+      # ignore filter stuff.
+      # @return [void]
+      Contract Any
+      def ignore!
+        @ignored = true
+      end
+      # Whether the Resource is ignored
+      # @return [Boolean]
+      Contract Bool
+      def ignored?
+        @ignored
+      end
+      # The preferred MIME content type for this resource based on extension or metadata
+      # @return [String] MIME type for this resource
+      Contract Maybe[String]
+      def content_type
+        options[:content_type] || ::Rack::Mime.mime_type(ext, nil)
+      end
+      def to_s
+        "#<#{self.class} path=#{@path}>"
+      end
+      alias 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