middleman-core-cj 3.3.4

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

@@ -0,0 +1,150 @@
+require 'active_support/core_ext/object/inclusion'
+
+module Middleman
+  module Sitemap
+    # Code adapted from https://github.com/ralph/document_mapper/
+    module Queryable
+      OPERATOR_MAPPING = {
+        'equal'   => :==,
+        'gt'      => :>,
+        'gte'     => :>=,
+        'in'      => :in?,
+        'include' => :include?,
+        'lt'      => :<,
+        'lte'     => :<=
+      }
+
+      VALID_OPERATORS = OPERATOR_MAPPING.keys
+
+      FileNotFoundError = Class.new StandardError
+      OperatorNotSupportedError = Class.new StandardError
+
+      module API
+        def select(options={})
+          documents = resources.select { |r| !r.raw_data.empty? }
+          options[:where].each do |selector, selector_value|
+            documents = documents.select do |document|
+              next unless document.raw_data.key? selector.attribute
+              document_value = document.raw_data[selector.attribute]
+              operator = OPERATOR_MAPPING[selector.operator]
+              document_value.send operator, selector_value
+            end
+          end
+
+          if options[:order_by].present?
+            order_attribute = options[:order_by].keys.first
+            asc_or_desc = options[:order_by].values.first
+            documents = documents.select do |document|
+              document.raw_data.include? order_attribute
+            end
+            documents = documents.sort_by do |document|
+              document.raw_data[order_attribute]
+            end
+            documents.reverse! if asc_or_desc == :desc
+          end
+
+          documents
+        end
+
+        def where(hash)
+          Query.new(self).where(hash)
+        end
+
+        def order_by(field)
+          Query.new(self).order_by(field)
+        end
+
+        def offset(number)
+          Query.new(self).offset(number)
+        end
+
+        def limit(number)
+          Query.new(self).limit(number)
+        end
+      end
+
+      class Query
+        def initialize(model, opts={})
+          @model = model
+          @where = opts[:where] || {}
+          @order_by = opts[:order_by]
+          @offset = opts[:offset]
+          @limit = opts[:limit]
+        end
+
+        def where(constraints_hash)
+          selector_hash = constraints_hash.reject { |key, _| !key.is_a? Selector }
+          symbol_hash = constraints_hash.reject { |key, _| key.is_a? Selector }
+          symbol_hash.each do |attribute, value|
+            selector = Selector.new(attribute: attribute, operator: 'equal')
+            selector_hash.update(selector => value)
+          end
+          Query.new @model, opts(where: @where.merge(selector_hash))
+        end
+
+        def opts(new_opts)
+          { where: {}.merge(@where),
+            order_by: @order_by,
+            offset: @offset,
+            limit: @limit
+          }.merge(new_opts)
+        end
+
+        def order_by(field)
+          Query.new @model, opts(order_by: field.is_a?(Symbol) ? { field => :asc } : field)
+        end
+
+        def offset(number)
+          Query.new @model, opts(offset: number)
+        end
+
+        def limit(number)
+          Query.new @model, opts(limit: number)
+        end
+
+        def first
+          all.first
+        end
+
+        def last
+          all.last
+        end
+
+        def all
+          result = @model.select(where: @where, order_by: @order_by)
+          result = result.last([result.size - @offset, 0].max) if @offset.present?
+          result = result.first(@limit) if @limit.present?
+          result
+        end
+      end
+
+      class Selector
+        attr_reader :attribute, :operator
+
+        def initialize(opts={})
+          unless VALID_OPERATORS.include? opts[:operator]
+            raise OperatorNotSupportedError
+          end
+          @attribute, @operator = opts[:attribute], opts[:operator]
+        end
+      end
+    end
+  end
+end
+
+# Add operators to symbol objects
+class Symbol
+  Middleman::Sitemap::Queryable::VALID_OPERATORS.each do |operator|
+    class_eval <<-OPERATORS
+      def #{operator}
+        Middleman::Sitemap::Queryable::Selector.new(:attribute => self, :operator => '#{operator}')
+      end
+    OPERATORS
+  end
+
+  unless method_defined?(:"<=>")
+    def <=>(other)
+      to_s <=> other.to_s
+    end
+  end
+end

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

@@ -0,0 +1,155 @@
+require 'middleman-core/sitemap/extensions/traversal'
+require 'middleman-core/sitemap/extensions/content_type'
+
+module Middleman
+  # Sitemap namespace
+  module Sitemap
+    # Sitemap Resource class
+    class Resource
+      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
+      # @return [String]
+      attr_accessor :destination_path
+
+      # Set the on-disk source file for this resource
+      # @return [String]
+      # attr_reader :source_file
+
+      def source_file
+        @source_file || get_source_file
+      end
+
+      # Initialize resource with parent store and URL
+      # @param [Middleman::Sitemap::Store] store
+      # @param [String] path
+      # @param [String] source_file
+      def initialize(store, path, source_file=nil)
+        @store       = store
+        @app         = @store.app
+        @path        = path.gsub(' ', '%20') # handle spaces in filenames
+        @source_file = source_file
+        @destination_path = @path
+
+        @local_metadata = { options: {}, locals: {}, page: {}, blocks: [] }
+      end
+
+      # Whether this resource has a template file
+      # @return [Boolean]
+      def template?
+        return false if source_file.nil?
+        !::Tilt[source_file].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)
+
+        local_meta = @local_metadata.dup
+        result[:blocks] += local_meta.delete(:blocks) if local_meta.key?(:blocks)
+        result.deep_merge!(local_meta)
+
+        result[:blocks] = result[:blocks].flatten.compact
+        result
+      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?
+      end
+
+      # The output/preview URL for this resource
+      # @return [String]
+      attr_accessor :destination_path
+
+      # Extension of the path (i.e. '.js')
+      # @return [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))
+
+        instrument 'render.resource', path: relative_source, destination_path: destination_path  do
+          md   = metadata.dup
+          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
+
+          # 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)
+        end
+      end
+
+      # A path without the directory index - so foo/index.html becomes
+      # just foo. Best for linking.
+      # @return [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 ? '/' : '')
+        end
+        File.join(app.respond_to?(:http_prefix) ? app.http_prefix : '/', url_path)
+      end
+
+      # Whether the source file is binary.
+      #
+      # @return [Boolean]
+      def binary?
+        ::Middleman::Util.binary?(source_file)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,279 @@
+# Used for merging results of metadata callbacks
+require 'active_support/core_ext/hash/deep_merge'
+require 'monitor'
+require 'middleman-core/sitemap/queryable'
+
+module Middleman
+  # Sitemap namespace
+  module Sitemap
+    # The Store class
+    #
+    # The Store manages a collection of Resource objects, which represent
+    # individual items in the sitemap. Resources are indexed by "source path",
+    # 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 ::Middleman::Sitemap::Queryable::API
+
+      # Initialize with parent app
+      # @param [Middleman::Application] app
+      def initialize(app)
+        @app = app
+        @resources = []
+        @_cached_metadata = {}
+        @resource_list_manipulators = []
+        @needs_sitemap_rebuild = true
+        @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)
+      end
+
+      # Register a klass which can manipulate the main site map 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
+      # @return [void]
+      def register_resource_list_manipulator(name, inst, *)
+        @resource_list_manipulators << [name, inst]
+        rebuild_resource_list!(:registered_new)
+      end
+
+      # Rebuild the list of resources from scratch, using registed manipulators
+      # rubocop:disable UnusedMethodArgument
+      # @return [void]
+      def rebuild_resource_list!(reason=nil)
+        @lock.synchronize do
+          @needs_sitemap_rebuild = true
+        end
+      end
+
+      # Find a resource given its original path
+      # @param [String] request_path The original path of a resource.
+      # @return [Middleman::Sitemap::Resource]
+      def find_resource_by_path(request_path)
+        @lock.synchronize do
+          request_path = ::Middleman::Util.normalize_path(request_path)
+          ensure_resource_list_updated!
+          @_lookup_by_path[request_path]
+        end
+      end
+
+      # Find a resource given its destination path
+      # @param [String] request_path The destination (output) path of a resource.
+      # @return [Middleman::Sitemap::Resource]
+      def find_resource_by_destination_path(request_path)
+        @lock.synchronize do
+          request_path = ::Middleman::Util.normalize_path(request_path)
+          ensure_resource_list_updated!
+          @_lookup_by_destination_path[request_path]
+        end
+      end
+
+      # Get the array of all resources
+      # @param [Boolean] include_ignored Whether to include ignored resources
+      # @return [Array<Middleman::Sitemap::Resource>]
+      def resources(include_ignored=false)
+        @lock.synchronize do
+          ensure_resource_list_updated!
+          if include_ignored
+            @resources
+          else
+            @resources_not_ignored ||= @resources.reject(&:ignored?)
+          end
+        end
+      end
+
+      # 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]
+      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, '')
+
+        # 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], '/')
+        end
+
+        extensionless_path(path)
+      end
+
+      # Get a path without templating extensions
+      # @param [String] file
+      # @return [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
+      end
+
+      # Actually update the resource list, assuming anything has called
+      # rebuild_resource_list! since the last time it was run. This is
+      # very expensive!
+      def ensure_resource_list_updated!
+        @lock.synchronize do
+          return unless @needs_sitemap_rebuild
+          @needs_sitemap_rebuild = false
+
+          @app.logger.debug '== Rebuilding resource list'
+
+          @resources = @resource_list_manipulators.reduce([]) do |result, (_, inst)|
+            newres = inst.manipulate_resource_list(result)
+
+            # Reset lookup cache
+            reset_lookup_cache!
+            newres.each do |resource|
+              @_lookup_by_path[resource.path] = resource
+              @_lookup_by_destination_path[resource.destination_path] = resource
+            end
+
+            newres
+          end
+
+          invalidate_resources_not_ignored_cache!
+        end
+      end
+
+      private
+
+      def reset_lookup_cache!
+        @lock.synchronize {
+          @_lookup_by_path = {}
+          @_lookup_by_destination_path = {}
+        }
+      end
+
+      # Removes the templating extensions, while keeping the others
+      # @param [String] path
+      # @return [String]
+      def remove_templating_extensions(path)
+        # Strip templating extensions as long as Tilt knows them
+        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]
+      def strip_away_locale(path)
+        if @app.respond_to? :langs
+          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
+        end
+
+        path
+      end
+    end
+  end
+end