middleman-core 3.0.14 → 3.1.0.beta.1

data/lib/middleman-core/core_extensions/extensions.rb

@@ -37,19 +37,13 @@ module Middleman
       class << self
         # @private
         def registered(app)
-          # Using for version parsing
-          require "rubygems"
-
           app.define_hook :after_configuration
           app.define_hook :before_configuration
           app.define_hook :build_config
           app.define_hook :development_config
 
-          if ENV["AUTOLOAD_SPROCKETS"]
-            app.set :autoload_sprockets, (ENV["AUTOLOAD_SPROCKETS"] == "true")
-          else
-            app.set :autoload_sprockets, true
-          end
+          app.config.define_setting :autoload_sprockets, true, 'Automatically load sprockets at startup?'
+          app.config[:autoload_sprockets] = (ENV["AUTOLOAD_SPROCKETS"] == "true") if ENV["AUTOLOAD_SPROCKETS"]
 
           app.extend ClassMethods
           app.send :include, InstanceMethods
@@ -68,29 +62,24 @@ module Middleman
           send("#{env}_config", &block)
         end
 
-        # Alias `extensions` to access registered extensions
-        #
-        # @return [Array<Module>]
-        def extensions
-          @extensions ||= []
-        end
-
         # Register a new extension
         #
         # @param [Module] extension Extension modules to register
         # @param [Hash] options Per-extension options hash
         # @return [void]
         def register(extension, options={}, &block)
-          @extensions ||= []
-          @extensions += [extension]
-
-          extend extension
-          if extension.respond_to?(:registered)
-            if extension.method(:registered).arity === 1
-              extension.registered(self, &block)
-            else
-              extension.registered(self, options, &block)
+          if extension.instance_of? Module
+            extend extension
+            if extension.respond_to?(:registered)
+              if extension.method(:registered).arity === 1
+                extension.registered(self, &block)
+              else
+                extension.registered(self, options, &block)
+              end
             end
+            extension
+          elsif extension.instance_of?(Class) && extension.ancestors.include?(::Middleman::Extension)
+            extension.new(self, options, &block)
           end
         end
       end
@@ -109,17 +98,24 @@ module Middleman
           ext_module = if ext.is_a?(Module)
             ext
           else
-            ::Middleman::Extensions.load(ext.to_sym)
+            ::Middleman::Extensions.load(ext)
           end
 
           if ext_module.nil?
             logger.error "== Unknown Extension: #{ext}"
           else
             logger.debug "== Activating: #{ext}"
-            self.class.register(ext_module, options, &block)
+            extensions[ext] = self.class.register(ext_module, options, &block)
           end
         end
 
+        # Access activated extensions
+        #
+        # @return [Hash<Symbol,Middleman::Extension|Module>]
+        def extensions
+          @extensions ||= {}
+        end
+
         # Load features before starting server
         def initialize
           super
@@ -130,14 +126,7 @@ module Middleman
           # Search the root of the project for required files
           $LOAD_PATH.unshift(root)
 
-          # Check for and evaluate local configuration
-          local_config = File.join(root, "config.rb")
-          if File.exists? local_config
-            logger.debug "== Reading:  Local config"
-            instance_eval File.read(local_config), local_config, 1
-          end
-
-          if autoload_sprockets
+          if config[:autoload_sprockets]
             begin
               require "middleman-sprockets"
               activate(:sprockets)
@@ -145,13 +134,20 @@ module Middleman
             end
           end
 
+          # Check for and evaluate local configuration
+          local_config = File.join(root, "config.rb")
+          if File.exists? local_config
+            logger.debug "== Reading:  Local config"
+            instance_eval File.read(local_config), local_config, 1
+          end
+
           run_hook :build_config if build?
           run_hook :development_config if development?
 
           run_hook :after_configuration
 
           logger.debug "Loaded extensions:"
-          self.class.extensions.each do |ext|
+          self.extensions.each do |ext,_|
             logger.debug "== Extension: #{ext}"
           end
         end

data/lib/middleman-core/core_extensions/external_helpers.rb

@@ -9,20 +9,20 @@ module Middleman
         # once registered
         def registered(app)
           # Setup a default helpers paths
-          app.set :helpers_dir, "helpers"
-          app.set :helpers_filename_glob, "**{,/*/**}/*.rb"
-          app.set :helpers_filename_to_module_name_proc, Proc.new { |filename|
+          app.config.define_setting :helpers_dir, "helpers", 'Directory to autoload helper modules from'
+          app.config.define_setting :helpers_filename_glob, "**.rb", 'Glob pattern for matching helper ruby files'
+          app.config.define_setting :helpers_filename_to_module_name_proc, Proc.new { |filename|
             basename = File.basename(filename, File.extname(filename))
             basename.camelcase
-          }
+          }, 'Proc implementing the conversion from helper filename to module name'
 
           # After config
           app.after_configuration do
-            helpers_path = File.expand_path(helpers_dir, root)
+            helpers_path = File.join(root, config[:helpers_dir])
             next unless File.exists?(helpers_path)
 
-            Dir[File.join(helpers_path, helpers_filename_glob)].each do |filename|
-              module_name = helpers_filename_to_module_name_proc.call(filename)
+            Dir[File.join(helpers_path, config[:helpers_filename_glob])].each do |filename|
+              module_name = config[:helpers_filename_to_module_name_proc].call(filename)
               next unless module_name
 
               require filename

data/lib/middleman-core/core_extensions/file_watcher.rb

@@ -29,7 +29,7 @@ module Middleman
 
           # Before parsing config, load the data/ directory
           app.before_configuration do
-            files.reload_path(data_dir)
+            files.reload_path(config[:data_dir])
           end
 
           # After config, load everything else

data/lib/middleman-core/core_extensions/front_matter.rb

@@ -1,3 +1,4 @@
+require "active_support/core_ext/hash/keys"
 require 'pathname'
 
 # Extensions namespace
@@ -27,20 +28,17 @@ module Middleman::CoreExtensions
         app.after_configuration do
           ::Middleman::Sitemap::Resource.send :include, ResourceInstanceMethods
 
-          sitemap.register_resource_list_manipulator(
-            :frontmatter,
-            frontmatter_manager
-          )
+          ignore %r{\.frontmatter$}
 
           sitemap.provides_metadata do |path|
             fmdata = frontmatter_manager.data(path).first || {}
 
             data = {}
-            %w(layout layout_engine).each do |opt|
-              data[opt.to_sym] = fmdata[opt] unless fmdata[opt].nil?
+            [:layout, :layout_engine].each do |opt|
+              data[opt] = fmdata[opt] unless fmdata[opt].nil?
             end
 
-            { :options => data, :page => fmdata }
+            { :options => data, :page => ::Middleman::Util.recursively_enhance(fmdata).freeze }
           end
         end
       end
@@ -58,16 +56,27 @@ module Middleman::CoreExtensions
 
       def data(path)
         p = normalize_path(path)
-        @cache[p] ||= frontmatter_and_content(p)
+        @cache[p] ||= begin
+          in_file = frontmatter_and_content(p)
+
+          external_file = frontmatter_and_content("#{p}.frontmatter")
+          
+          return in_file if external_file.nil?
+
+          [
+            external_file[0].deep_merge(in_file[0]),
+            in_file[1]
+          ]
+        end
       end
 
       def clear_data(file)
         # Copied from Sitemap::Store#file_to_path, but without
         # removing the file extension
-        file = File.expand_path(file, @app.root)
+        file = File.join(@app.root, file)
         prefix = @app.source_dir.sub(/\/$/, "") + "/"
         return unless file.include?(prefix)
-        path = file.sub(prefix, "")
+        path = file.sub(prefix, "").sub(/\.frontmatter$/, "")
 
         @cache.delete(path)
       end
@@ -88,12 +97,12 @@ module Middleman::CoreExtensions
           content = content.sub(yaml_regex, "")
 
           begin
-            data = YAML.load($1)
+            data = YAML.load($1) || {}
+            data = data.symbolize_keys
           rescue *YAML_ERRORS => e
             logger.error "YAML Exception: #{e.message}"
             return false
           end
-
         else
           return false
         end
@@ -111,7 +120,7 @@ module Middleman::CoreExtensions
 
           begin
             json = ($1+$2).sub(";;;", "{").sub(";;;", "}")
-            data = ActiveSupport::JSON.decode(json)
+            data = ActiveSupport::JSON.decode(json).symbolize_keys
           rescue => e
             logger.error "JSON Exception: #{e.message}"
             return false
@@ -135,6 +144,8 @@ module Middleman::CoreExtensions
         else
           path
         end
+
+        return nil unless File.exists?(full_path)
         
         data = {}
         content = nil
@@ -154,55 +165,51 @@ module Middleman::CoreExtensions
             elsif result = parse_json_front_matter(content)
               data, content = result
             end
-          rescue => e
+          rescue
             # Probably a binary file, move on
           end
         end
 
-        [::Middleman::Util.recursively_enhance(data).freeze, content]
+        [data, content]
       end
 
       def normalize_path(path)
         path.sub(%r{^#{@app.source_dir}\/}, "")
       end
-
-      # Update the main sitemap resource list
-      # @return [void]
-      def manipulate_resource_list(resources)
-        resources.each do |r|
-          if !r.proxy? && !r.data.nil? && r.data["ignored"] == true
-            r.frontmatter_ignored = true
-          end
-        end
-
-        resources
-      end
     end
 
     module ResourceInstanceMethods
 
-      def frontmatter_ignored?
-        @_frontmatter_ignored || false
-      end
-
-      def frontmatter_ignored=(v)
-        @_frontmatter_ignored = v
-      end
-
       def ignored?
-        if frontmatter_ignored?
+        if !proxy? && data["ignored"] == true
           true
         else
           super
         end
       end
 
+      # This page's frontmatter without being enhanced for access by either symbols or strings.
+      # Used internally
+      # @private
+      # @return [Hash]
+      def raw_data
+        app.frontmatter_manager.data(source_file).first
+      end
+
       # This page's frontmatter
       # @return [Hash]
       def data
-        app.frontmatter_manager.data(source_file).first
+        ::Middleman::Util.recursively_enhance(raw_data).freeze
       end
 
+      # Override Resource#content_type to take into account frontmatter
+      def content_type
+        # Allow setting content type in frontmatter too
+        fm_type = data[:content_type]
+        return fm_type if fm_type
+
+        super
+      end
     end
 
     module InstanceMethods
@@ -218,7 +225,6 @@ module Middleman::CoreExtensions
       def template_data_for_file(path)
         frontmatter_manager.data(path).last
       end
-
     end
   end
 end

data/lib/middleman-core/core_extensions/rendering.rb

@@ -23,6 +23,7 @@ module Middleman
           app.define_hook :after_render
 
           ::Tilt.mappings.delete('html') # WTF, Tilt?
+          ::Tilt.mappings.delete('csv')
 
           # Activate custom renderers
           require "middleman-core/renderers/erb"
@@ -86,9 +87,7 @@ module Middleman
             Tilt.mappings.each do |key, klasses|
               begin
                 Tilt[".#{key}"]
-              rescue LoadError
-                Tilt.mappings.delete(key)
-              rescue NameError
+              rescue LoadError, NameError
                 Tilt.mappings.delete(key)
               end
             end
@@ -128,6 +127,9 @@ module Middleman
 
           # Store last engine for later (could be inside nested renders)
           @current_engine, engine_was = engine, @current_engine
+          old_locale = ::I18n.locale
+
+          I18n.locale = opts[:lang] if opts[:lang]
 
           # Use a dup of self as a context so that instance variables set within
           # the template don't persist for other templates.
@@ -147,7 +149,7 @@ module Middleman
               opts[:template_body] = content if content
               content = render_individual_file(path, locs, opts, context)
               path = File.basename(path, File.extname(path))
-            rescue LocalJumpError => e
+            rescue LocalJumpError
               raise "Tried to render a layout (calls yield) at #{path} like it was a template. Non-default layouts need to be in #{source}/layouts."
             end
           end
@@ -165,6 +167,7 @@ module Middleman
         ensure
           # Pop all the saved variables from earlier as we may be returning to a
           # previous render (layouts, partials, nested layouts).
+          ::I18n.locale = old_locale
           @current_engine = engine_was
           @content_blocks = nil
           @current_locs = nil
@@ -192,27 +195,26 @@ module Middleman
             engine = File.extname(resource.source_file)[1..-1].to_sym
 
             # Look for partials relative to the current path
-            if current_dir != self.source_dir
-              relative_dir = File.join(current_dir.sub("#{self.source_dir}/", ""), data)
+            relative_dir = File.join(current_dir.sub(%r{^#{self.source_dir}/?}, ""), data)
 
-              # Try to use the current engine first
-              found_partial, found_engine = resolve_template(relative_dir, :preferred_engine => engine, :try_without_underscore => true)
+            # Try to use the current engine first
+            found_partial, found_engine = resolve_template(relative_dir, :preferred_engine => engine, :try_without_underscore => true)
 
-              # Fall back to any engine available
-              if !found_partial
-                found_partial, found_engine = resolve_template(relative_dir, :try_without_underscore => true)
-              end
+            # Fall back to any engine available
+            if !found_partial
+              found_partial, found_engine = resolve_template(relative_dir, :try_without_underscore => true)
             end
           end
 
-          # Look in the root for the partial with the current engine
+          # Look in the partials_dir for the partial with the current engine
+          partials_path = File.join(config[:partials_dir], data)
           if !found_partial && !engine.nil?
-            found_partial, found_engine = resolve_template(data, :preferred_engine => engine, :try_without_underscore => true)
+            found_partial, found_engine = resolve_template(partials_path, :preferred_engine => engine, :try_without_underscore => true)
           end
 
           # Look in the root with any engine
           if !found_partial
-            found_partial, found_engine = resolve_template(data, :try_without_underscore => true)
+            found_partial, found_engine = resolve_template(partials_path, :try_without_underscore => true)
           end
 
           # Render the partial if found, otherwide throw exception
@@ -245,8 +247,12 @@ module Middleman
 
           # Merge per-extension options from config
           extension = File.extname(path)
-          options = opts.merge(options_for_ext(extension))
+          options = opts.dup.merge(options_for_ext(extension))
           options[:outvar] ||= '@_out_buf'
+          options.delete(:layout)
+
+          # Overwrite with frontmatter options
+          options = options.deep_merge(options[:renderer_options]) if options[:renderer_options]
 
           template_class = Tilt[path]
           # Allow hooks to manipulate the template before render
@@ -256,8 +262,8 @@ module Middleman
           end
 
           # Read compiled template from disk or cache
-          template = cache.fetch(:compiled_template, options, body) do
-            ::Tilt.new(path, 1, options) { body }
+          template = cache.fetch(:compiled_template, extension, options, body) do
+           ::Tilt.new(path, 1, options) { body }
           end
 
           # Render using Tilt
@@ -294,9 +300,9 @@ module Middleman
             # Find all the engines which handle this extension in tilt. Look for
             # config variables of that name and merge it
             extension_class = ::Tilt[ext]
-            ::Tilt.mappings.each do |ext, engines|
+            ::Tilt.mappings.each do |mapping_ext, engines|
               next unless engines.include? extension_class
-              engine_options = respond_to?(ext.to_sym) ? send(ext.to_sym) : {}
+              engine_options = config[mapping_ext.to_sym] || {}
               options.merge!(engine_options)
             end
 
@@ -311,7 +317,7 @@ module Middleman
         # @return [String]
         def fetch_layout(engine, opts)
           # The layout name comes from either the system default or the options
-          local_layout = opts.has_key?(:layout) ? opts[:layout] : layout
+          local_layout = opts.has_key?(:layout) ? opts[:layout] : config[:layout]
           return false unless local_layout
 
           # Look for engine-specific options