middleman-core 4.6.0 → 5.0.0.rc.1

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

@@ -1,24 +1,35 @@
-require 'addressable/uri'
-
 # Relative Assets extension
 class Middleman::Extensions::RelativeAssets < ::Middleman::Extension
   option :exts, nil, 'List of extensions that get converted to relative paths.'
-  option :sources, %w(.css .htm .html .xhtml), 'List of extensions that are searched for relative assets.'
+  option :sources, %w[.css .htm .html .xhtml], 'List of extensions that are searched for relative assets.'
   option :ignore, [], 'Regexes of filenames to skip converting to relative paths.'
   option :rewrite_ignore, [], 'Regexes of filenames to skip processing for path rewrites.'
   option :helpers_only, false, 'Allow only Ruby helpers to change paths.'
 
-  def initialize(app, options_hash={}, &block)
+  def initialize(app, options_hash = ::Middleman::EMPTY_HASH, &block)
     super
 
-    return if options[:helpers_only]
+    require 'set'
+    @set_of_exts = Set.new(options.exts || app.config[:asset_extensions])
+    @set_of_sources = Set.new options.sources
+  end
 
-    app.rewrite_inline_urls id: :relative_assets,
-                            url_extensions: options.exts || app.config[:asset_extensions],
-                            source_extensions: options.sources,
-                            ignore: options.ignore,
-                            rewrite_ignore: options.rewrite_ignore,
-                            proc: method(:rewrite_url)
+  Contract IsA['Middleman::Sitemap::ResourceListContainer'] => Any
+  def manipulate_resource_list_container!(resource_list)
+    return if options.helpers_only
+
+    resource_list.by_extensions(@set_of_sources).each do |r|
+      next if Array(options.rewrite_ignore || []).any? do |i|
+        ::Middleman::Util.path_match(i, "/#{r.destination_path}")
+      end
+
+      r.add_filter ::Middleman::InlineURLRewriter.new(:relative_assets,
+                                                      app,
+                                                      r,
+                                                      url_extensions: @set_of_exts,
+                                                      ignore: options.ignore,
+                                                      proc: method(:rewrite_url))
+    end
   end
 
   def mark_as_relative(file_path, opts, current_resource)
@@ -46,12 +57,12 @@ class Middleman::Extensions::RelativeAssets < ::Middleman::Extension
   end
 
   helpers do
-    def asset_url(path, prefix='', options={})
-      super(path, prefix, app.extensions[:relative_assets].mark_as_relative(super, options, current_resource))
+    def asset_url(path, prefix = '', options_hash = ::Middleman::EMPTY_HASH)
+      super(path, prefix, app.extensions[:relative_assets].mark_as_relative(super, options_hash, current_resource))
     end
 
-    def asset_path(kind, source, options={})
-      super(kind, source, app.extensions[:relative_assets].mark_as_relative(super, options, current_resource))
+    def asset_path(kind, source, options_hash = ::Middleman::EMPTY_HASH)
+      super(kind, source, app.extensions[:relative_assets].mark_as_relative(super, options_hash, current_resource))
     end
   end
 
@@ -64,10 +75,10 @@ class Middleman::Extensions::RelativeAssets < ::Middleman::Extension
     relative_path = uri.host.nil?
 
     full_asset_path = if relative_path
-      dirpath.join(asset_path).to_s
-    else
-      asset_path
-    end
+                        dirpath.join(asset_path).to_s
+                      else
+                        asset_path
+                      end
 
     current_dir = Pathname(request_path).dirname
     result = Pathname(full_asset_path).relative_path_from(current_dir).to_s

data/lib/middleman-core/extensions.rb

@@ -1,4 +1,5 @@
 require 'middleman-core/extension'
+require 'middleman-core/util/empty_hash'
 
 module Middleman
   # The Extensions module is used to handle global registration and loading of Middleman Extensions.
@@ -49,11 +50,14 @@ module Middleman
       #        you the ability to require other files only when the
       #        extension is first activated.
       # @return [void]
-      def register(name, extension_class=nil, options={}, &block)
+      def register(name, extension_class = nil, options_hash = ::Middleman::EMPTY_HASH, &block)
         raise 'Extension name must be a symbol' unless name.is_a?(Symbol)
+
         # If we've already got an extension registered under this name, bail out
         # raise "There is a already an extension registered with the name '#{name}'" if registered.key?(name)
 
+        options = options_hash.dup
+
         # If the extension is defined with a block, grab options out of the "extension_class" parameter.
         if extension_class && block_given? && options.empty? && extension_class.is_a?(Hash)
           options = extension_class
@@ -61,12 +65,12 @@ module Middleman
         end
 
         registered[name] = if block_given?
-          block
-        elsif extension_class && extension_class.ancestors.include?(::Middleman::Extension)
-          extension_class
-        else
-          raise 'You must provide a Middleman::Extension or a block that returns a Middleman::Extension'
-        end
+                             block
+                           elsif extension_class && extension_class.ancestors && extension_class.ancestors.include?(::Middleman::Extension)
+                             extension_class
+                           else
+                             raise 'You must provide a Middleman::Extension or a block that returns a Middleman::Extension'
+                           end
 
         return unless options[:auto_activate]
 
@@ -82,9 +86,7 @@ module Middleman
       def load(name)
         raise 'Extension name must be a symbol' unless name.is_a?(Symbol)
 
-        unless registered.key?(name)
-          raise "Unknown Extension: #{name}. Check the name and make sure you have referenced the extension's gem in your Gemfile."
-        end
+        raise "Unknown Extension: #{name}. Check the name and make sure you have referenced the extension's gem in your Gemfile." unless registered.key?(name)
 
         extension_class = registered[name]
         if extension_class.is_a?(Proc)
@@ -92,9 +94,7 @@ module Middleman
           registered[name] = extension_class
         end
 
-        unless extension_class.ancestors.include?(::Middleman::Extension)
-          raise "Tried to activate old-style extension: #{name}. They are no longer supported."
-        end
+        raise "Tried to activate old-style extension: #{name}. They are no longer supported." unless extension_class.ancestors.include?(::Middleman::Extension)
 
         # Set the extension's name to whatever it was registered as.
         extension_class.ext_name = name
@@ -125,9 +125,7 @@ module Middleman
         registered.each do |name, _|
           begin
             ext = load(name)
-            unless ext.global_config.all_settings.empty?
-              app.config.load_settings(ext.global_config.all_settings)
-            end
+            app.config.load_settings(ext.global_config.all_settings) unless ext.global_config.all_settings.empty?
           rescue LoadError
           end
         end

data/lib/middleman-core/file_renderer.rb

@@ -1,7 +1,7 @@
 require 'tilt'
-require 'active_support/core_ext/string/output_safety'
-require 'active_support/core_ext/module/delegation'
+require 'hamster'
 require 'middleman-core/contracts'
+require 'middleman-core/dependencies/vertices/vertex'
 
 ::Tilt.default_mapping.lazy_map.delete('html')
 ::Tilt.default_mapping.lazy_map.delete('csv')
@@ -15,11 +15,15 @@ module Middleman
       @_cache ||= ::Tilt::Cache.new
     end
 
+    Contract ImmutableSetOf[::Middleman::Dependencies::Vertex]
+    attr_reader :vertices
+
     def_delegator :"self.class", :cache
 
     def initialize(app, path)
       @app = app
       @path = path.to_s
+      @vertices = ::Hamster::Set.empty
     end
 
     # Render an on-disk file. Used for everything, including layouts.
@@ -32,22 +36,23 @@ module Middleman
     def render(locs, opts, context, &block)
       path = @path.dup
 
-      # Detect the remdering engine from the extension
+      # Detect the rendering engine from the extension
       extension = File.extname(path)
       engine = extension[1..-1].to_sym
 
       # Store last engine for later (could be inside nested renders)
-      context.current_engine, engine_was = engine, context.current_engine
+      engine_was = context.current_engine
+      context.current_engine = engine
 
       # Save current buffer for later
       buf_was = context.save_buffer
 
       # Read from disk or cache the contents of the file
       body = if opts[:template_body]
-        opts.delete(:template_body)
-      else
-        template_data_for_file
-      end
+               opts.delete(:template_body)
+             else
+               template_data_for_file
+             end
 
       # Merge per-extension options from config
       extension = File.extname(path)
@@ -59,22 +64,19 @@ module Middleman
       # Overwrite with frontmatter options
       options = options.deep_merge(options[:renderer_options]) if options[:renderer_options]
 
-      template_class = ::Middleman::Util.tilt_class(path)
-
-      # Allow hooks to manipulate the template before render
-      body = @app.callbacks_for(:before_render).reduce(body) do |sum, callback|
-        callback.call(sum, path, locs, template_class) || sum
-      end
-
       # Read compiled template from disk or cache
-      template = ::Tilt.new(path, 1, options) { body.dup }
+      template = ::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
-      content = template.render(context, locs, &block)
+      @vertices = ::Hamster::Set.empty
 
-      # Allow hooks to manipulate the result after render
-      content = @app.callbacks_for(:after_render).reduce(content) do |sum, callback|
-        callback.call(sum, path, locs, template_class) || sum
+      # Render using Tilt
+      content = ::Middleman::Util.instrument 'render.tilt', path: path do
+        template.render(context, locs, &block).tap do
+          @vertices = template.vertices if template.respond_to?(:vertices)
+        end
       end
 
       output = ::ActiveSupport::SafeBuffer.new ''
@@ -98,7 +100,7 @@ module Middleman
         return result unless result.nil?
       end
 
-      file ? file.read : ::File.read(@path)
+      file ? file.read : ::Middleman::Util.read_file(@path)
     end
 
     protected

data/lib/middleman-core/filter.rb

@@ -0,0 +1,56 @@
+require 'hamster'
+require 'middleman-core/contracts'
+require 'middleman-core/dependencies/vertices/vertex'
+
+module Middleman
+  class Filter
+    include Contracts
+    include Comparable
+
+    Contract Symbol
+    attr_reader :filter_name
+
+    Contract Maybe[Symbol]
+    attr_reader :after_filter
+
+    def <=>(other)
+      shift = if other.after_filter.nil?
+                0
+              elsif filter_name == other.after_filter
+                1
+              else
+                -1
+              end
+
+      [0, object_id] <=> [shift, other.object_id]
+    end
+
+    Contract Symbol, Hash => Any
+    def initialize(filter_name, options_hash = ::Middleman::EMPTY_HASH)
+      @filter_name = filter_name
+
+      @options = options_hash
+      @after_filter = @options.fetch(:after_filter, nil)
+    end
+
+    Contract String => [String, ImmutableSetOf[::Middleman::Dependencies::Vertex]]
+    def execute_filter(_body)
+      raise NotImplementedError
+    end
+  end
+
+  class ProcFilter < Filter
+    Contract Symbol, RespondTo[:call], Hash => Any
+    def initialize(filter_name, callable, options_hash = ::Middleman::EMPTY_HASH)
+      super(filter_name, options_hash)
+
+      @callable = callable
+    end
+
+    Contract String => [String, ImmutableSetOf[::Middleman::Dependencies::Vertex]]
+    def execute_filter(body)
+      result = @callable.call(body)
+      result.is_a?(Array) ? result : [result, ::Hamster::Set.empty]
+    end
+  end
+end

data/lib/middleman-core/inline_url_filter.rb

@@ -0,0 +1,76 @@
+require 'hamster'
+require 'middleman-core/util'
+require 'middleman-core/filter'
+require 'middleman-core/contracts'
+require 'middleman-core/dependencies/vertices/vertex'
+require 'middleman-core/dependencies/vertices/file_vertex'
+
+module Middleman
+  class InlineURLRewriter < Filter
+    include Contracts
+
+    Contract Symbol, IsA['::Middleman::Application'], IsA['::Middleman::Sitemap::Resource'], Hash => Any
+    def initialize(filter_name, app, resource, options_hash = ::Middleman::EMPTY_HASH)
+      super(filter_name, options_hash)
+
+      @app = app
+      @resource = resource
+    end
+
+    Contract String, Pathname => Maybe[IsA['::Middleman::Sitemap::Resource']]
+    def target_resource(asset_path, dirpath)
+      uri = ::Middleman::Util.parse_uri(asset_path)
+      relative_path = !uri.path.start_with?('/')
+
+      full_asset_path = if relative_path
+                          dirpath.join(asset_path).to_s
+                        else
+                          asset_path
+                        end
+
+      @app.sitemap.by_destination_path(full_asset_path) || @app.sitemap.by_path(full_asset_path)
+    end
+
+    Contract String => [String, ImmutableSetOf[::Middleman::Dependencies::Vertex]]
+    def execute_filter(body)
+      path = "/#{@resource.destination_path}"
+      dirpath = ::Pathname.new(File.dirname(path))
+
+      ::Middleman::Util.instrument 'inline_url_filter', path: path do
+        vertices = ::Hamster::Set.empty
+
+        new_content = ::Middleman::Util.rewrite_paths(body, path, @options.fetch(:url_extensions), @app) do |asset_path|
+          uri = ::Middleman::Util.parse_uri(asset_path)
+
+          relative_path = uri.host.nil?
+          full_asset_path = if relative_path
+                              dirpath.join(asset_path).to_s
+                            else
+                              asset_path
+                            end
+
+          exts = @options.fetch(:url_extensions)
+          next unless exts.include?(::File.extname(asset_path))
+
+          next if @options.fetch(:ignore).any? { |r| ::Middleman::Util.should_ignore?(r, full_asset_path) }
+
+          result = @options.fetch(:proc).call(asset_path, dirpath, path)
+
+          if result
+            if @options.fetch(:create_dependencies, false)
+              vertices <<= ::Middleman::Dependencies::FileVertex.from_resource(
+                target_resource(asset_path, dirpath)
+              )
+            end
+
+            asset_path = result
+          end
+
+          asset_path
+        end
+
+        [new_content, vertices]
+      end
+    end
+  end
+end

data/lib/middleman-core/load_paths.rb

@@ -5,7 +5,6 @@ module Middleman
   class << self
     def setup_load_paths
       @_is_setup ||= begin
-
         # Only look for config.rb if MM_ROOT isn't set
         if !ENV['MM_ROOT'] && (found_path = findup('config.rb'))
           ENV['MM_ROOT'] = found_path
@@ -22,27 +21,27 @@ module Middleman
 
     # Set BUNDLE_GEMFILE and run Bundler setup. Raises an exception if there is no Gemfile
     def setup_bundler
-      if found_gemfile_root = findup('Gemfile', ENV['MM_ROOT'])
-        ENV['BUNDLE_GEMFILE'] ||= File.join(found_gemfile_root, 'Gemfile')
-      end
+      found_gemfile_root = findup('Gemfile', ENV['MM_ROOT'])
 
-      unless File.exist?(ENV['BUNDLE_GEMFILE'])
-        ENV['BUNDLE_GEMFILE'] = File.expand_path('../../../../Gemfile', __FILE__)
-      end
+      ENV['BUNDLE_GEMFILE'] ||= File.join(found_gemfile_root, 'Gemfile') if found_gemfile_root
 
-      if File.exist?(ENV['BUNDLE_GEMFILE'])
-        require 'bundler/setup'
-        Bundler.require
-      else
-        raise "Couldn't find your Gemfile. Middleman projects require a Gemfile for specifying dependencies."
-      end
+      ENV['BUNDLE_GEMFILE'] = File.expand_path('../../../Gemfile', __dir__) unless File.exist?(ENV['BUNDLE_GEMFILE'])
+
+      raise "Couldn't find your Gemfile. Middleman projects require a Gemfile for specifying dependencies." unless File.exist?(ENV['BUNDLE_GEMFILE'])
+
+      require 'bundler/setup'
+      Bundler.require(
+        :default,
+        (ENV['MM_ENV'] || ENV['RACK_ENV'] || 'development').to_sym
+      )
     end
 
     # Recursive method to find a file in parent directories
-    def findup(filename, cwd=Dir.pwd)
+    def findup(filename, cwd = Dir.pwd)
       cwd = Pathname(cwd)
       return cwd.to_s if (cwd + filename).exist?
       return false if cwd.root?
+
       findup(filename, cwd.parent)
     end
   end

data/lib/middleman-core/logger.rb

@@ -1,31 +1,23 @@
 # Use the Ruby/Rails logger
-require 'active_support/notifications'
-require 'active_support/logger'
-require 'thread'
-
 module Middleman
   # The Middleman Logger
-  class Logger < ActiveSupport::Logger
+  class Logger < ::ActiveSupport::Logger
     def self.singleton(*args)
-      if !@_logger || !args || !args.empty?
-        if args.length == 1 && (args.first.is_a?(::String) || args.first.respond_to?(:write))
-          args = [0, false, args.first]
-        end
+      if !@_logger || !args.empty?
+        args = [0, false, args.first] if args.length == 1 && (args.first.is_a?(::String) || args.first.respond_to?(:write))
         @_logger = new(*args)
       end
 
       @_logger
     end
 
-    def initialize(log_level=1, is_instrumenting=false, target=$stdout)
+    def initialize(log_level = 1, is_instrumenting = false, target = $stdout)
       super(target)
 
       self.level = log_level
       @instrumenting = is_instrumenting
 
-      if @instrumenting != false
-        ::ActiveSupport::Notifications.subscribe(/\.middleman$/, self)
-      end
+      ::ActiveSupport::Notifications.subscribe(/\.middleman$/, self) if @instrumenting != false
 
       @mutex = Mutex.new
     end
@@ -41,6 +33,7 @@ module Middleman
 
       evt = ::ActiveSupport::Notifications::Event.new(message, *args)
       return unless evt.duration > 30
+
       info "== Instrument (#{evt.name.sub(/.middleman$/, '')}): #{evt.duration}ms\n#{args.last}"
     end
   end

data/lib/middleman-core/meta_pages/sitemap_resource.rb

@@ -1,6 +1,4 @@
 require 'padrino-helpers'
-require 'padrino-helpers/output_helpers'
-require 'padrino-helpers/tag_helpers'
 
 module Middleman
   module MetaPages

data/lib/middleman-core/meta_pages/sitemap_tree.rb

@@ -59,7 +59,7 @@ module Middleman
 
         if path_parts.size == 1
           sitemap_class = SitemapResource
-          # Allow special sitemap resources to use custom metadata view calsses
+          # Allow special sitemap resources to use custom metadata view classes
           sitemap_class = resource.meta_pages_class if resource.respond_to? :meta_pages_class
 
           @children[first_part] = sitemap_class.new(resource)

data/lib/middleman-core/meta_pages.rb

@@ -46,7 +46,7 @@ module Middleman
 
       # Inspect the sitemap
       def sitemap(_)
-        resources = @middleman.sitemap.resources(true)
+        resources = @middleman.sitemap.with_ignored
 
         sitemap_tree = SitemapTree.new
 
@@ -93,7 +93,7 @@ module Middleman
       private
 
       # Render a template with the given name and locals
-      def template(template_name, locals={})
+      def template(template_name, locals = {})
         template_path = File.join(File.dirname(__FILE__), 'meta_pages', 'templates', template_name)
         content = Tilt.new(template_path).render(::Object.new, locals)
         response(content)

data/lib/middleman-core/preview_server/checks.rb

@@ -34,7 +34,11 @@ module Middleman
           return if resolver.ips_for(information.server_name).include? information.bind_address
 
           information.valid = false
-          information.reason = format('Server name "%s" does not resolve to bind address "%s"', information.server_name, information.bind_address)
+          information.reason = format(
+            'Server name "%<name>s" does not resolve to bind address "%<addr>s"',
+            name: information.server_name,
+            addr: information.bind_address
+          )
         end
       end
 
@@ -46,10 +50,14 @@ module Middleman
         # @param [Information] information
         #   The information to be validated
         def validate(information)
-          return if information.bind_address.blank? || information.local_network_interfaces.include?(information.bind_address.to_s) || %w(0.0.0.0 ::).any? { |b| information.bind_address == b } || IPAddr.new('127.0.0.0/8').include?(information.bind_address.to_s)
+          return if information.bind_address.blank? || information.local_network_interfaces.include?(information.bind_address.to_s) || %w[0.0.0.0 ::].any? { |b| information.bind_address == b } || IPAddr.new('127.0.0.0/8').include?(information.bind_address.to_s)
 
           information.valid = false
-          information.reason = format('Bind address "%s" is not available on your system. Please use one of %s', information.bind_address, information.local_network_interfaces.map { |i| %("#{i}") }.join(', '))
+          information.reason = format(
+            'Bind address "%<bad_addr>s" is not available on your system. Please use one of %<good_addrs>s',
+            bad_addr: information.bind_address,
+            good_addrs: information.local_network_interfaces.map { |i| %("#{i}") }.join(', ')
+          )
         end
       end
 
@@ -61,7 +69,10 @@ module Middleman
           return unless information.bind_address.blank?
 
           information.valid = false
-          information.reason = format('Server name "%s" does not resolve to an ip address', information.server_name)
+          information.reason = format(
+            'Server name "%<name>s" does not resolve to an ip address',
+            name: information.server_name
+          )
         end
       end