middleman-core 3.3.2 → 3.3.3

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

@@ -9,10 +9,8 @@ require 'active_support/json'
 
 # Extensions namespace
 module Middleman::CoreExtensions
-
   class FrontMatter < ::Middleman::Extension
-
-    YAML_ERRORS = [ StandardError ]
+    YAML_ERRORS = [StandardError]
 
     # https://github.com/tenderlove/psych/issues/23
     if defined?(Psych) && defined?(Psych::SyntaxError)
@@ -45,7 +43,7 @@ module Middleman::CoreExtensions
           data[opt] = fmdata[opt] unless fmdata[opt].nil?
         end
 
-        { :options => data, :page => ::Middleman::Util.recursively_enhance(fmdata).freeze }
+        { options: data, page: ::Middleman::Util.recursively_enhance(fmdata).freeze }
       end
     end
 
@@ -115,7 +113,8 @@ module Middleman::CoreExtensions
       @cache.delete(path)
     end
 
-  private
+    private
+
     # Parse YAML frontmatter out of a string
     # @param [String] content
     # @return [Array<Hash, String>]
@@ -147,7 +146,7 @@ module Middleman::CoreExtensions
         content = content.sub(json_regex, '')
 
         begin
-          json = ($1+$2).sub(';;;', '{').sub(';;;', '}')
+          json = ($1 + $2).sub(';;;', '{').sub(';;;', '}')
           data = ActiveSupport::JSON.decode(json).symbolize_keys
         rescue => e
           app.logger.error "JSON Exception parsing #{full_path}: #{e.message}"

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

@@ -1,19 +1,17 @@
 # Shutup Tilt Warnings
 # @private
 class Tilt::Template
-  def warn(*args)
-    # Kernel.warn(*args)
+  def warn(*)
   end
 end
 
 # Rendering extension
+# rubocop:disable UnderscorePrefixedVariableName
 module Middleman
   module CoreExtensions
     module Rendering
-
       # Setup extension
       class << self
-
         # Once registered
         def registered(app)
           # Include methods
@@ -93,7 +91,7 @@ module Middleman
 
           # Clean up missing Tilt exts
           app.after_configuration do
-            Tilt.mappings.each do |key, klasses|
+            Tilt.mappings.each do |key, _|
               begin
                 Tilt[".#{key}"]
               rescue LoadError, NameError
@@ -103,7 +101,7 @@ module Middleman
           end
         end
 
-        alias :included :registered
+        alias_method :included, :registered
       end
 
       # Custom error class for handling
@@ -112,7 +110,6 @@ module Middleman
 
       # Rendering instance methods
       module InstanceMethods
-
         # Add or overwrite a default template extension
         #
         # @param [Hash] extension_map
@@ -140,13 +137,14 @@ module Middleman
 
           # Use a dup of self as a context so that instance variables set within
           # the template don't persist for other templates.
-          context = self.dup
+          context = dup
           blocks.each do |block|
             context.instance_eval(&block)
           end
 
           # Store current locs/opts for later
-          @current_locs = locs, @current_opts = opts
+          @current_locs = locs
+          @current_opts = opts
 
           # Keep rendering template until we've used up all extensions. This
           # handles cases like `style.css.sass.erb`
@@ -184,7 +182,7 @@ module Middleman
         # @param [String, Symbol] data
         # @param [Hash] options
         # @return [String]
-        def render(engine, data, options={}, &block)
+        def render(_, data, options={}, &block)
           data = data.to_s
 
           locals = options[:locals]
@@ -198,13 +196,13 @@ module Middleman
             resolve_opts[:preferred_engine] = File.extname(resource.source_file)[1..-1].to_sym
 
             # Look for partials relative to the current path
-            relative_dir = File.join(current_dir.sub(%r{^#{Regexp.escape(self.source_dir)}/?}, ''), data)
+            relative_dir = File.join(current_dir.sub(%r{^#{Regexp.escape(source_dir)}/?}, ''), data)
 
             found_partial = resolve_template(relative_dir, resolve_opts)
           end
 
           # Look in the partials_dir for the partial with the current engine
-          if !found_partial
+          unless found_partial
             partials_path = File.join(config[:partials_dir], data)
             found_partial = resolve_template(partials_path, resolve_opts)
           end
@@ -222,9 +220,13 @@ module Middleman
         # @param [Hash] opts
         # @param [Class] context
         # @return [String]
-        def render_individual_file(path, locs = {}, opts = {}, context = self, &block)
+        def render_individual_file(path, locs={}, opts={}, context=self, &block)
           path = path.to_s
 
+          # Mutability is FUN!
+          # Try to work around: https://github.com/middleman/middleman/issues/501
+          locs = locs.dup
+
           # Detect the remdering engine from the extension
           extension = File.extname(path)
           engine = extension[1..-1].to_sym
@@ -254,13 +256,18 @@ module Middleman
           template_class = Tilt[path]
           # Allow hooks to manipulate the template before render
           self.class.callbacks_for_hook(:before_render).each do |callback|
-            newbody = callback.call(body, path, locs, template_class)
+            # Uber::Options::Value doesn't respond to call
+            newbody = if callback.respond_to?(:call)
+              callback.call(body, path, locs, template_class)
+            elsif callback.respond_to?(:evaluate)
+              callback.evaluate(self, body, path, locs, template_class)
+            end
             body = newbody if newbody # Allow the callback to return nil to skip it
           end
 
           # Read compiled template from disk or cache
           template = cache.fetch(:compiled_template, extension, options, body) do
-           ::Tilt.new(path, 1, options) { body }
+            ::Tilt.new(path, 1, options) { body }
           end
 
           # Render using Tilt
@@ -268,7 +275,13 @@ module Middleman
 
           # Allow hooks to manipulate the result after render
           self.class.callbacks_for_hook(:after_render).each do |callback|
-            content = callback.call(content, path, locs, template_class)
+            # Uber::Options::Value doesn't respond to call
+            newcontent = if callback.respond_to?(:call)
+              content = callback.call(content, path, locs, template_class)
+            elsif callback.respond_to?(:evaluate)
+              content = callback.evaluate(self, content, path, locs, template_class)
+            end
+            content = newcontent if newcontent # Allow the callback to return nil to skip it
           end
 
           output = ::ActiveSupport::SafeBuffer.new ''
@@ -317,7 +330,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] : config[:layout]
+          local_layout = opts.key?(:layout) ? opts[:layout] : config[:layout]
           return false unless local_layout
 
           # Look for engine-specific options
@@ -325,9 +338,9 @@ module Middleman
 
           # The engine for the layout can be set in options, engine_options or passed
           # into this method
-          layout_engine = if opts.has_key?(:layout_engine)
+          layout_engine = if opts.key?(:layout_engine)
             opts[:layout_engine]
-          elsif engine_options.has_key?(:layout_engine)
+          elsif engine_options.key?(:layout_engine)
             engine_options[:layout_engine]
           else
             engine
@@ -354,11 +367,8 @@ module Middleman
         # @param [Symbol] preferred_engine
         # @return [String]
         def locate_layout(name, preferred_engine=nil)
-          # Whether we've found the layout
-          layout_path = false
-
           resolve_opts = {}
-          resolve_opts[:preferred_engine] = preferred_engine if !preferred_engine.nil?
+          resolve_opts[:preferred_engine] = preferred_engine unless preferred_engine.nil?
 
           # Check layouts folder
           layout_path = resolve_template(File.join(config[:layouts_dir], name.to_s), resolve_opts)
@@ -377,13 +387,13 @@ module Middleman
           # Save current buffer for later
           @_out_buf, _buf_was = '', @_out_buf
 
-          layout_path = locate_layout(layout_name, self.current_engine)
+          layout_path = locate_layout(layout_name, current_engine)
 
           extension = File.extname(layout_path)
           engine = extension[1..-1].to_sym
 
           # Store last engine for later (could be inside nested renders)
-          self.current_engine, engine_was = engine, self.current_engine
+          self.current_engine, engine_was = engine, current_engine
 
           begin
             content = if block_given?
@@ -408,6 +418,7 @@ module Middleman
         end
 
         # The currently rendering engine
+        # rubocop:disable TrivialAccessors
         # @return [Symbol, nil]
         def current_engine=(v)
           @_current_engine = v
@@ -423,18 +434,17 @@ module Middleman
           request_path = request_path.to_s
           cache.fetch(:resolve_template, request_path, options) do
             relative_path = Util.strip_leading_slash(request_path)
-            on_disk_path  = File.expand_path(relative_path, self.source_dir)
+            on_disk_path  = File.expand_path(relative_path, source_dir)
 
             # By default, any engine will do
             preferred_engines = ['*']
 
             # If we're specifically looking for a preferred engine
-            if options.has_key?(:preferred_engine)
+            if options.key?(:preferred_engine)
               extension_class = ::Tilt[options[:preferred_engine]]
-              matched_exts = []
 
               # Get a list of extensions for a preferred engine
-              matched_exts = ::Tilt.mappings.select do |ext, engines|
+              matched_exts = ::Tilt.mappings.select do |_, engines|
                 engines.include? extension_class
               end.keys
 
@@ -464,7 +474,7 @@ module Middleman
             # If we found one, return it and the found engine
             if found_path
               found_path
-            elsif File.exists?(on_disk_path)
+            elsif File.exist?(on_disk_path)
               on_disk_path
             else
               false

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

@@ -8,15 +8,12 @@ require 'middleman-core/util'
 
 module Middleman
   module CoreExtensions
-
     # Base helper to manipulate asset paths
     module Request
-
       # Extension registered
       class << self
         # @private
         def registered(app)
-
           # CSSPIE HTC File
           ::Rack::Mime::MIME_TYPES['.htc'] = 'text/x-component'
 
@@ -32,7 +29,7 @@ module Middleman
           # Include instance methods
           app.send :include, InstanceMethods
         end
-        alias :included :registered
+        alias_method :included, :registered
       end
 
       module ClassMethods
@@ -60,9 +57,7 @@ module Middleman
         # @private
         # @param [Middleman::Application] inst
         # @return [void]
-        def inst=(inst)
-          @inst = inst
-        end
+        attr_writer :inst
 
         # Return built Rack app
         #
@@ -74,15 +69,15 @@ module Middleman
             app.use Rack::Lint
             app.use Rack::Head
 
-            Array(@middleware).each do |klass, options, block|
-              app.use(klass, *options, &block)
+            Array(@middleware).each do |klass, options, middleware_block|
+              app.use(klass, *options, &middleware_block)
             end
 
             inner_app = inst(&block)
             app.map('/') { run inner_app }
 
-            Array(@mappings).each do |path, block|
-              app.map(path, &block)
+            Array(@mappings).each do |path, map_block|
+              app.map(path, &map_block)
             end
 
             app
@@ -130,6 +125,7 @@ module Middleman
         # configuration can be included later without impacting
         # other classes and instances.
         #
+        # rubocop:disable ClassVars
         # @return [Class]
         def server(&block)
           @@servercounter ||= 0
@@ -169,20 +165,21 @@ module Middleman
         # @return [void]
         def current_path=(path)
           Thread.current[:current_path] = path
-          Thread.current[:legacy_request] = ::Thor::CoreExt::HashWithIndifferentAccess.new({
-            :path   => path,
-            :params => req ? ::Thor::CoreExt::HashWithIndifferentAccess.new(req.params) : {}
-          })
+          Thread.current[:legacy_request] = ::Thor::CoreExt::HashWithIndifferentAccess.new(
+                                                                                             path: path,
+                                                                                             params: req ? ::Thor::CoreExt::HashWithIndifferentAccess.new(req.params) : {}
+          )
         end
 
-        delegate :use, :to => :"self.class"
-        delegate :map, :to => :"self.class"
+        delegate :use, to: :"self.class"
+        delegate :map, to: :"self.class"
 
         # Rack request
         # @return [Rack::Request]
         def req
           Thread.current[:req]
         end
+
         def req=(value)
           Thread.current[:req] = value
         end
@@ -199,7 +196,7 @@ module Middleman
           self.req = req = ::Rack::Request.new(env)
           res = ::Rack::Response.new
 
-          logger.debug "== Request: #{env["PATH_INFO"]}"
+          logger.debug "== Request: #{env['PATH_INFO']}"
 
           # Catch :halt exceptions and use that response if given
           catch(:halt) do
@@ -277,7 +274,7 @@ module Middleman
         # @param [String] value Mime type
         # @return [void]
         def mime_type(type, value)
-          type = ".#{type}" unless type.to_s[0] == ?.
+          type = ".#{type}" unless type.to_s[0] == '.'
           ::Rack::Mime::MIME_TYPES[type] = value
         end
 

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

@@ -11,14 +11,14 @@ module Middleman
         #
         # @param [String, Symbol] layout_name
         # @return [void]
-        def with_layout(layout_name, &block)
-          old_layout = config[:layout]
+      def with_layout(layout_name, &block)
+        old_layout = config[:layout]
 
-          config[:layout] = layout_name
-          instance_exec(&block) if block_given?
-        ensure
-          config[:layout] = old_layout
-        end
+        config[:layout] = layout_name
+        instance_exec(&block) if block_given?
+      ensure
+        config[:layout] = old_layout
+      end
 
         # The page method allows the layout to be set on a specific path
         #
@@ -28,43 +28,44 @@ module Middleman
         # @param [String] url
         # @param [Hash] opts
         # @return [void]
-        def page(url, opts={}, &block)
-          blocks = Array(block)
-
-          # Default layout
-          opts[:layout] = config[:layout] if opts[:layout].nil?
+      def page(url, opts={}, &block)
+        blocks = Array(block)
 
-          # If the url is a regexp
-          if url.is_a?(Regexp) || url.include?('*')
+        # Default layout
+        opts[:layout] = config[:layout] if opts[:layout].nil?
 
-            # Use the metadata loop for matching against paths at runtime
-            sitemap.provides_metadata_for_path(url) do |_|
-              { :options => opts, :blocks => blocks }
-            end
+        # If the url is a regexp
+        if url.is_a?(Regexp) || url.include?('*')
 
-            return
+          # Use the metadata loop for matching against paths at runtime
+          sitemap.provides_metadata_for_path(url) do |_|
+            { options: opts, blocks: blocks }
           end
 
-          # Normalized path
-          url = '/' + Middleman::Util.normalize_path(url)
-          if url.end_with?('/') || File.directory?(File.join(source_dir, url))
-            url = File.join(url, config[:index_file])
-          end
+          return
+        end
 
-          # Setup proxy
-          if target = opts.delete(:proxy)
-            # TODO: deprecate proxy through page?
-            proxy(url, target, opts, &block) and return
-          elsif opts.delete(:ignore)
-            # TODO: deprecate ignore through page?
-            ignore(url)
-          end
+        # Normalized path
+        url = '/' + Middleman::Util.normalize_path(url)
+        if url.end_with?('/') || File.directory?(File.join(source_dir, url))
+          url = File.join(url, config[:index_file])
+        end
 
-          # Setup a metadata matcher for rendering those options
-          sitemap.provides_metadata_for_path(url) do |_|
-            { :options => opts, :blocks => blocks }
-          end
+        # Setup proxy
+        if target = opts.delete(:proxy)
+          # TODO: deprecate proxy through page?
+          proxy(url, target, opts, &block)
+          return
+        elsif opts.delete(:ignore)
+          # TODO: deprecate ignore through page?
+          ignore(url)
+        end
+
+        # Setup a metadata matcher for rendering those options
+        sitemap.provides_metadata_for_path(url) do |_|
+          { options: opts, blocks: blocks }
         end
+      end
     end
   end
 end