middleman-core 3.0.14 → 3.1.0.beta.1

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

@@ -4,15 +4,6 @@ module Middleman
   module Renderers
 
     class RedcarpetTemplate < ::Tilt::RedcarpetTemplate::Redcarpet2
-
-      def initialize(*args, &block)
-        super
-        
-        if @options.has_key?(:context)
-          @context = @options[:context]
-        end
-      end
-
       # Overwrite built-in Tilt version.
       # Don't overload :renderer option with smartypants
       # Support renderer-level options
@@ -39,27 +30,31 @@ module Middleman
 
         renderer.new(render_options)
       end
-
-      def evaluate(context, locals, &block)
-        @context ||= context
-
-        if @engine.renderer.respond_to? :middleman_app=
-          @engine.renderer.middleman_app = @context
-        end
-        super
-      end
     end
 
     # Custom Redcarpet renderer that uses our helpers for images and links
     class MiddlemanRedcarpetHTML < ::Redcarpet::Render::HTML
-      attr_accessor :middleman_app
+      cattr_accessor :middleman_app
 
       def image(link, title, alt_text)
-        middleman_app.image_tag(link, :title => title, :alt => alt_text)
+        if middleman_app && middleman_app.respond_to?(:image_tag)
+          middleman_app.image_tag(link, :title => title, :alt => alt_text)
+        else
+          img = "<img src=\"#{link}\""
+          img << " title=\"#{title}\"" if title
+          img << " alt=\"#{alt_text}\"" if alt_text
+          img << ">"
+        end
       end
 
       def link(link, title, content)
-        middleman_app.link_to(content, link, :title => title)
+        if middleman_app && middleman_app.respond_to?(:link_to)
+          middleman_app.link_to(content, link, :title => title)
+        else
+          a = "<a href=\"#{link}\""
+          a << " title=\"#{title}\"" if title
+          a << ">#{content}</a>"
+        end
       end
     end
 

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

@@ -12,12 +12,11 @@ module Middleman
         # Once registered
         def registered(app)
           # Default sass options
-          app.set :sass, {}
+          app.config.define_setting :sass, {}, 'Sass engine options'
 
           # Location of SASS .sass-cache directory.
           # @return [String]
-          #   set :sass_cache_path, "/tmp/middleman-app-name/sass-cache"
-          app.set(:sass_cache_path) { File.join(app.root_path, '.sass-cache') } # runtime compile of path
+          app.config.define_setting :sass_cache_path, File.join(app.root_path, '.sass-cache'), 'Location of sass cache' # runtime compile of path
 
           app.before_configuration do
             template_extensions :scss => :css,
@@ -76,11 +75,11 @@ module Middleman
           more_opts = { :filename => eval_file, :line => line, :syntax => syntax }
           
           if @context.is_a?(::Middleman::Application) && file
-            location_of_sass_file = File.expand_path(@context.source, @context.root)
+            location_of_sass_file = @context.source_dir
           
             parts = basename.split('.')
             parts.pop
-            more_opts[:css_filename] = File.join(location_of_sass_file, @context.css_dir, parts.join("."))
+            more_opts[:css_filename] = File.join(location_of_sass_file, @context.config[:css_dir], parts.join("."))
           end
           
           options.merge(more_opts)

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

@@ -26,8 +26,11 @@ module Middleman
             context_hack = {
               :context => self
             }
+
+            slim_embedded = defined?(::Slim::Embedded) ? ::Slim::Embedded : ::Slim::EmbeddedEngine
+
             %w(sass scss markdown).each do |engine|
-              ::Slim::EmbeddedEngine.default_options[engine.to_sym] = context_hack
+              slim_embedded.default_options[engine.to_sym] = context_hack
             end
           end
         end

data/lib/middleman-core/sitemap.rb

@@ -20,10 +20,10 @@ module Middleman
         app.register Middleman::Sitemap::Extensions::Ignores
 
         # Set to automatically convert some characters into a directory
-        app.set :automatic_directory_matcher, nil
+        app.config.define_setting :automatic_directory_matcher, nil, 'Set to automatically convert some characters into a directory'
 
         # Setup callbacks which can exclude paths from the sitemap
-        app.set :ignored_sitemap_matchers, {
+        app.config.define_setting :ignored_sitemap_matchers, {
           # dotfiles and folders in the root
           :root_dotfiles => proc { |file| file.start_with?('.') },
 
@@ -38,7 +38,7 @@ module Middleman
           :layout => proc { |file|
             file.start_with?('source/layout.') || file.start_with?('source/layouts/')
           }
-        }
+        }, 'Callbacks that can exclude paths from the sitemap'
 
         # Include instance methods
         app.send :include, InstanceMethods

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

@@ -0,0 +1,16 @@
+require 'rack'
+
+module Middleman::Sitemap::Extensions
+  # Content type is implemented as a module so it can be overridden by other sitemap extensions
+  module ContentType
+    # The preferred MIME content type for this resource
+    def content_type
+      # Allow explcitly setting content type from page/proxy options
+      meta_type = metadata[:options][:content_type]
+      return meta_type if meta_type
+
+      # Look up mime type based on extension
+      ::Rack::Mime.mime_type(ext, nil)
+    end
+  end
+end

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

@@ -45,7 +45,7 @@ module Middleman
           path = @sitemap.file_to_path(file)
           return false unless path
 
-          ignored = @app.ignored_sitemap_matchers.any? do |name, callback|
+          ignored = @app.config[:ignored_sitemap_matchers].any? do |name, callback|
             callback.call(file)
           end
 
@@ -85,7 +85,7 @@ module Middleman
             ::Middleman::Sitemap::Resource.new(
               @sitemap,
               @sitemap.file_to_path(file),
-              File.expand_path(file, @app.root)
+              File.join(@app.root, file)
             )
           end
         end

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

@@ -42,29 +42,39 @@ module Middleman
             @proxied_to
           end
 
-          # Whether this page has a template file
-          # @return [Boolean]
-          def template?
-            if proxy?
-              store.find_resource_by_path(proxied_to).template?
-            else
-              super
+          # The resource for the page this page is proxied to. Throws an exception
+          # if there is no resource.
+          # @return [Sitemap::Resource]
+          def proxied_to_resource
+            proxy_resource = store.find_resource_by_path(proxied_to)
+
+            unless proxy_resource
+              raise "Path #{path} proxies to unknown file #{proxied_to}:#{store.resources.map(&:path)}"
             end
+
+            if proxy_resource.proxy?
+              raise "You can't proxy #{path} to #{proxied_to} which is itself a proxy."
+            end
+
+            proxy_resource
           end
 
           def get_source_file
             if proxy?
-              proxy_resource = store.find_resource_by_path(proxied_to)
-
-              unless proxy_resource
-                raise "Path #{path} proxies to unknown file #{proxied_to}:#{store.resources.map(&:path)}"
-              end
+              proxied_to_resource.source_file
+            else
+              super
+            end
+          end
 
-              if proxy_resource.proxy?
-                raise "You can't proxy #{path} to #{proxied_to} which is itself a proxy."
-              end
+          def content_type
+            mime_type = super
+            return mime_type if mime_type
 
-              proxy_resource.source_file
+            if proxy?
+              proxied_to_resource.content_type
+            else
+              nil
             end
           end
         end

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

@@ -0,0 +1,148 @@
+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.has_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)
+          @model = model
+          @where = {}
+        end
+
+        def where(constraints_hash)
+          selector_hash = constraints_hash.reject { |key, value| !key.is_a? Selector }
+          symbol_hash = constraints_hash.reject { |key, value| key.is_a? Selector }
+          symbol_hash.each do |attribute, value|
+            selector = Selector.new(:attribute => attribute, :operator => 'equal')
+            selector_hash.update({ selector => value })
+          end
+          @where.merge! selector_hash
+          self
+        end
+
+        def order_by(field)
+          @order_by = field.is_a?(Symbol) ? {field => :asc} : field
+          self
+        end
+
+        def offset(number)
+          @offset = number
+          self
+        end
+
+        def limit(number)
+          @limit = number
+          self
+        end
+
+        def first
+          self.all.first
+        end
+
+        def last
+          self.all.last
+        end
+
+        def all
+          result = @model.select(:where => @where, :order_by => @order_by)
+          if @offset.present?
+            result = result.last([result.size - @offset, 0].max)
+          end
+          if @limit.present?
+            result = result.first(@limit)
+          end
+          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)
+      self.to_s <=> other.to_s
+    end
+  end
+end

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

@@ -1,4 +1,5 @@
 require "middleman-core/sitemap/extensions/traversal"
+require "middleman-core/sitemap/extensions/content_type"
 
 module Middleman
 
@@ -8,6 +9,7 @@ module Middleman
     # Sitemap Resource class
     class Resource
       include Middleman::Sitemap::Extensions::Traversal
+      include Middleman::Sitemap::Extensions::ContentType
 
       # @return [Middleman::Application]
       attr_reader :app
@@ -76,6 +78,7 @@ module Middleman
       # 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
         if metadata.has_key?(:blocks)
           @local_metadata[:blocks] << metadata.delete(:blocks)
         end
@@ -114,6 +117,15 @@ module Middleman
         instrument "render.resource", :path => relative_source  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
@@ -121,7 +133,7 @@ module Middleman
             app.data.store("page", md[:page])
           end
 
-          blocks = md[:blocks].dup rescue []
+          blocks = Array(md[:blocks]).dup
           blocks << block if block_given?
 
           app.current_path ||= self.destination_path
@@ -143,7 +155,7 @@ module Middleman
 
       # Whether the source file is binary.
       #
-      # @retrun [Boolean]
+      # @return [Boolean]
       def binary?
         ::Middleman::Util.binary?(source_file)
       end

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

@@ -1,6 +1,7 @@
 # Used for merging results of metadata callbacks
 require "active_support/core_ext/hash/deep_merge"
 require 'monitor'
+require "middleman-core/sitemap/queryable"
 
 module Middleman
 
@@ -18,6 +19,8 @@ module Middleman
       # @return [Middleman::Application]
       attr_accessor :app
 
+      include ::Middleman::Sitemap::Queryable::API
+
       # Initialize with parent app
       # @param [Middleman::Application] app
       def initialize(app)
@@ -110,7 +113,7 @@ module Middleman
         provides_metadata.inject(blank_metadata) do |result, (callback, matcher)|
           next result if matcher && !source_file.match(matcher)
 
-          metadata = callback.call(source_file)
+          metadata = callback.call(source_file).dup
 
           if metadata.has_key?(:blocks)
             result[:blocks] << metadata[:blocks]
@@ -123,8 +126,6 @@ module Middleman
 
       # Register a handler to provide metadata on a url path
       # @param [Regexp] matcher
-      # @param [Symbol] origin an indicator of where this metadata came from - only one
-      #                        block per [matcher, origin] pair may exist.
       # @return [Array<Array<Proc, Regexp>>]
       def provides_metadata_for_path(matcher=nil, &block)
         @_provides_metadata_for_path ||= []
@@ -151,7 +152,7 @@ module Middleman
             next result unless File.fnmatch("/" + Util.strip_leading_slash(matcher), "/#{request_path}")
           end
 
-          metadata = callback.call(request_path)
+          metadata = callback.call(request_path).dup
 
           result[:blocks] += Array(metadata.delete(:blocks))
 
@@ -163,7 +164,7 @@ module Middleman
       # @param [String] file
       # @return [String]
       def file_to_path(file)
-        file = File.expand_path(file, @app.root)
+        file = File.join(@app.root, file)
 
         prefix = @app.source_dir.sub(/\/$/, "") + "/"
         return false unless file.start_with?(prefix)
@@ -171,8 +172,8 @@ module Middleman
         path = file.sub(prefix, "")
 
         # Replace a file name containing automatic_directory_matcher with a folder
-        unless @app.automatic_directory_matcher.nil?
-          path = path.gsub(@app.automatic_directory_matcher, "/")
+        unless @app.config[:automatic_directory_matcher].nil?
+          path = path.gsub(@app.config[:automatic_directory_matcher], "/")
         end
 
         extensionless_path(path)