middleman-core 4.5.0 → 5.0.0.rc.1

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

@@ -1,6 +1,6 @@
-require 'active_support/core_ext/object/try'
 require 'memoist'
 require 'middleman-core/contracts'
+require 'rack/mime'
 require 'sassc'
 
 # Minify CSS Extension
@@ -10,119 +10,81 @@ class Middleman::Extensions::MinifyCss < ::Middleman::Extension
   option :compressor, proc {
     SassCompressor
   }, 'Set the CSS compressor to use.'
-  option :content_types, %w(text/css), 'Content types of resources that contain CSS'
-  option :inline_content_types, %w(text/html text/php), 'Content types of resources that contain inline CSS'
+  option :content_types, %w[text/css], 'Content types of resources that contain CSS'
+  option :inline_content_types, %w[text/html text/php], 'Content types of resources that contain inline CSS'
 
-  def ready
-    # Setup Rack middleware to minify CSS
-    app.use Rack, compressor: options[:compressor],
-                  ignore: Array(options[:ignore]) + [/\.min\./],
-                  inline: options[:inline],
-                  content_types: options[:content_types],
-                  inline_content_types: options[:inline_content_types]
-  end
+  INLINE_CSS_REGEX = /(<style[^>]*>\s*(?:\/\*<!\[CDATA\[\*\/\n)?)(.*?)((?:(?:\n\s*)?\/\*\]\]>\*\/)?\s*<\/style>)/m.freeze
 
   class SassCompressor
     COMPRESSED_OPTIONS = { style: :compressed }.freeze
 
-    def self.compress(style, options={})
-      options = options.merge(COMPRESSED_OPTIONS)
+    def self.compress(style, options_hash = ::Middleman::EMPTY_HASH)
+      options = if options_hash == ::Middleman::EMPTY_HASH
+                  COMPRESSED_OPTIONS
+                else
+                  options_hash.merge(COMPRESSED_OPTIONS)
+                end
 
       ::SassC::Engine.new(style, options).render.strip
     end
   end
 
-  # Rack middleware to look for CSS and compress it
-  class Rack
-    extend Memoist
-    include Contracts
-    INLINE_CSS_REGEX = /(<style[^>]*>\s*(?:\/\*<!\[CDATA\[\*\/\n)?)(.*?)((?:(?:\n\s*)?\/\*\]\]>\*\/)?\s*<\/style>)/m
-
-    # Init
-    # @param [Class] app
-    # @param [Hash] options
-    Contract RespondTo[:call], {
-      ignore: ArrayOf[PATH_MATCHER],
-      inline: Bool,
-      compressor: Or[Proc, RespondTo[:to_proc], RespondTo[:compress]]
-    } => Any
-    def initialize(app, options={})
-      @app = app
-      @ignore = options.fetch(:ignore)
-      @inline = options.fetch(:inline)
-
-      @compressor = options.fetch(:compressor)
-      @compressor = @compressor.to_proc if @compressor.respond_to? :to_proc
-      @compressor = @compressor.call if @compressor.is_a? Proc
-      @content_types = options[:content_types]
-      @inline_content_types = options[:inline_content_types]
-    end
-
-    # Rack interface
-    # @param [Rack::Environmemt] env
-    # @return [Array]
-    def call(env)
-      status, headers, response = @app.call(env)
-
-      content_type = headers['Content-Type'].try(:slice, /^[^;]*/)
-      path = env['PATH_INFO']
+  def initialize(app, options_hash = ::Middleman::EMPTY_HASH, &block)
+    super
 
-      minified = if @inline && minifiable_inline?(content_type)
-        minify_inline(::Middleman::Util.extract_response_text(response))
-      elsif minifiable?(content_type) && !ignore?(path)
-        minify(::Middleman::Util.extract_response_text(response))
-      end
+    @ignore = Array(options.ignore) + [/\.min\./]
+    @compressor = options.compressor
+    @compressor = @compressor.to_proc if @compressor.respond_to? :to_proc
+    @compressor = @compressor.call if @compressor.is_a? Proc
+  end
 
-      if minified
-        headers['Content-Length'] = minified.bytesize.to_s
-        response = [minified]
+  Contract IsA['Middleman::Sitemap::ResourceListContainer'] => Any
+  def manipulate_resource_list_container!(resource_list)
+    resource_list.by_binary(false).each do |r|
+      type = r.content_type.try(:slice, /^[^;]*/)
+      if options[:inline] && minifiable_inline?(type)
+        r.add_filter method(:minify_inline)
+      elsif minifiable?(type) && !ignore?(r.destination_path)
+        r.add_filter method(:minify)
       end
-
-      [status, headers, response]
     end
+  end
 
-    private
-
-    # Whether the path should be ignored
-    # @param [String] path
-    # @return [Boolean]
-    def ignore?(path)
-      @ignore.any? { |ignore| ::Middleman::Util.path_match(ignore, path) }
-    end
-    memoize :ignore?
-
-    # Whether this type of content can be minified
-    # @param [String, nil] content_type
-    # @return [Boolean]
-    def minifiable?(content_type)
-      @content_types.include?(content_type)
-    end
-    memoize :minifiable?
+  # Whether the path should be ignored
+  Contract String => Bool
+  def ignore?(path)
+    @ignore.any? { |ignore| ::Middleman::Util.path_match(ignore, path) }
+  end
+  memoize :ignore?
 
-    # Whether this type of content contains inline content that can be minified
-    # @param [String, nil] content_type
-    # @return [Boolean]
-    def minifiable_inline?(content_type)
-      @inline_content_types.include?(content_type)
-    end
-    memoize :minifiable_inline?
+  # Whether this type of content can be minified
+  Contract Maybe[String] => Bool
+  def minifiable?(content_type)
+    options[:content_types].include?(content_type)
+  end
+  memoize :minifiable?
 
-    # Minify the content
-    # @param [String] content
-    # @return [String]
-    def minify(content)
-      @compressor.compress(content)
-    end
-    memoize :minify
+  # Whether this type of content contains inline content that can be minified
+  Contract Maybe[String] => Bool
+  def minifiable_inline?(content_type)
+    options[:inline_content_types].include?(content_type)
+  end
+  memoize :minifiable_inline?
 
-    # Detect and minify inline content
-    # @param [String] content
-    # @return [String]
-    def minify_inline(content)
-      content.gsub(INLINE_CSS_REGEX) do
-        $1 + minify($2) + $3
-      end
+  # Minify the content
+  Contract String => String
+  def minify(content)
+    @compressor.compress(content)
+  end
+  memoize :minify
+
+  # Detect and minify inline content
+  # @param [String] content
+  # @return [String]
+  def minify_inline(content)
+    content.gsub(INLINE_CSS_REGEX) do
+      Regexp.last_match(1) + minify(Regexp.last_match(2)) + Regexp.last_match(3)
     end
-    memoize :minify_inline
   end
+  memoize :minify_inline
 end

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

@@ -1,131 +1,87 @@
-require 'active_support/core_ext/object/try'
 require 'middleman-core/contracts'
 require 'memoist'
 
-# Minify Javascript Extension
-class Middleman::Extensions::MinifyJavascript < ::Middleman::Extension
+# Minify JavaScript Extension
+class Middleman::Extensions::MinifyJavaScript < ::Middleman::Extension
   option :inline, false, 'Whether to minify JS inline within HTML files'
   option :ignore, [], 'Patterns to avoid minifying'
   option :compressor, proc {
     require 'uglifier'
     ::Uglifier.new
   }, 'Set the JS compressor to use.'
-  option :content_types, %w(application/javascript), 'Content types of resources that contain JS'
-  option :inline_content_types, %w(text/html text/php), 'Content types of resources that contain inline JS'
+  option :content_types, %w[application/javascript], 'Content types of resources that contain JS'
+  option :inline_content_types, %w[text/html text/php], 'Content types of resources that contain inline JS'
 
-  def ready
-    # Setup Rack middleware to minify JS
-    app.use Rack, compressor: options[:compressor],
-                  ignore: Array(options[:ignore]) + [/\.min\./],
-                  inline: options[:inline],
-                  content_types: options[:content_types],
-                  inline_content_types: options[:inline_content_types]
-  end
-
-  # Rack middleware to look for JS and compress it
-  class Rack
-    extend Memoist
-    include Contracts
-    INLINE_JS_REGEX = /(<script[^>]*>\s*(?:\/\/(?:(?:<!--)|(?:<!\[CDATA\[))\n)?)(.*?)((?:(?:\n\s*)?\/\/(?:(?:-->)|(?:\]\]>)))?\s*<\/script>)/m
-
-    # Init
-    # @param [Class] app
-    # @param [Hash] options
-    Contract RespondTo[:call], {
-      ignore: ArrayOf[PATH_MATCHER],
-      inline: Bool,
-      compressor: Or[Proc, RespondTo[:to_proc], RespondTo[:compress]]
-    } => Any
-    def initialize(app, options={})
-      @app = app
-      @ignore = options.fetch(:ignore)
-      @inline = options.fetch(:inline)
-
-      @compressor = options.fetch(:compressor)
-      @compressor = @compressor.to_proc if @compressor.respond_to? :to_proc
-      @compressor = @compressor.call if @compressor.is_a? Proc
-      @content_types = options[:content_types]
-      @inline_content_types = options[:inline_content_types]
-    end
-
-    # Rack interface
-    # @param [Rack::Environmemt] env
-    # @return [Array]
-    def call(env)
-      status, headers, response = @app.call(env)
+  INLINE_JS_REGEX = /(<script[^>]*>\s*(?:\/\/(?:(?:<!--)|(?:<!\[CDATA\[))\n)?)(.*?)((?:(?:\n\s*)?\/\/(?:(?:-->)|(?:\]\]>)))?\s*<\/script>)/m.freeze
 
-      type = headers['Content-Type'].try(:slice, /^[^;]*/)
-      @path = env['PATH_INFO']
+  def initialize(app, options_hash = ::Middleman::EMPTY_HASH, &block)
+    super
 
-      minified = if @inline && minifiable_inline?(type)
-        minify_inline(::Middleman::Util.extract_response_text(response))
-      elsif minifiable?(type) && !ignore?(@path)
-        minify(::Middleman::Util.extract_response_text(response))
-      end
+    @ignore = Array(options[:ignore]) + [/\.min\./]
+    @compressor = options[:compressor]
+    @compressor = @compressor.to_proc if @compressor.respond_to? :to_proc
+    @compressor = @compressor.call if @compressor.is_a? Proc
+  end
 
-      if minified
-        headers['Content-Length'] = minified.bytesize.to_s
-        response = [minified]
+  Contract IsA['Middleman::Sitemap::ResourceListContainer'] => Any
+  def manipulate_resource_list_container!(resource_list)
+    resource_list.by_binary(false).each do |r|
+      type = r.content_type.try(:slice, /^[^;]*/)
+      if options[:inline] && minifiable_inline?(type)
+        r.add_filter method(:minify_inline)
+      elsif minifiable?(type) && !ignore?(r.destination_path)
+        r.add_filter method(:minify)
       end
-
-      [status, headers, response]
-    end
-
-    private
-
-    # Whether the path should be ignored
-    # @param [String] path
-    # @return [Boolean]
-    def ignore?(path)
-      @ignore.any? { |ignore| Middleman::Util.path_match(ignore, path) }
-    end
-    memoize :ignore?
-
-    # Whether this type of content can be minified
-    # @param [String, nil] content_type
-    # @return [Boolean]
-    def minifiable?(content_type)
-      @content_types.include?(content_type)
     end
-    memoize :minifiable?
-
-    # Whether this type of content contains inline content that can be minified
-    # @param [String, nil] content_type
-    # @return [Boolean]
-    def minifiable_inline?(content_type)
-      @inline_content_types.include?(content_type)
-    end
-    memoize :minifiable_inline?
+  end
 
-    # Minify the content
-    # @param [String] content
-    # @return [String]
-    def minify(content)
-      @compressor.compress(content)
-    rescue ExecJS::ProgramError => e
-      warn "WARNING: Couldn't compress JavaScript in #{@path}: #{e.message}"
-      content
-    end
-    memoize :minify
+  # Whether the path should be ignored
+  Contract String => Bool
+  def ignore?(path)
+    @ignore.any? { |ignore| ::Middleman::Util.path_match(ignore, path) }
+  end
+  memoize :ignore?
 
-    # Detect and minify inline content
-    # @param [String] content
-    # @return [String]
-    def minify_inline(content)
-      content.gsub(INLINE_JS_REGEX) do |match|
-        first = $1
-        inline_content = $2
-        last = $3
+  # Whether this type of content can be minified
+  Contract Maybe[String] => Bool
+  def minifiable?(content_type)
+    options[:content_types].include?(content_type)
+  end
+  memoize :minifiable?
 
-        # Only compress script tags that contain JavaScript (as opposed to
-        # something like jQuery templates, identified with a "text/html" type).
-        if !first.include?('type=') || first.include?('text/javascript')
-          first + minify(inline_content) + last
-        else
-          match
-        end
+  # Whether this type of content contains inline content that can be minified
+  Contract Maybe[String] => Bool
+  def minifiable_inline?(content_type)
+    options[:inline_content_types].include?(content_type)
+  end
+  memoize :minifiable_inline?
+
+  # Minify the content
+  Contract String => String
+  def minify(content)
+    @compressor.compress(content)
+  rescue ::ExecJS::ProgramError => e
+    warn "WARNING: Couldn't compress JavaScript in #{@path}: #{e.message}"
+    content
+  end
+  memoize :minify
+
+  # Detect and minify inline content
+  Contract String => String
+  def minify_inline(content)
+    content.gsub(INLINE_JS_REGEX) do |match|
+      first = Regexp.last_match(1)
+      inline_content = Regexp.last_match(2)
+      last = Regexp.last_match(3)
+
+      # Only compress script tags that contain JavaScript (as opposed to
+      # something like jQuery templates, identified with a "text/html" type).
+      if !first.include?('type=') || first.include?('text/javascript')
+        first + minify(inline_content) + last
+      else
+        match
       end
     end
-    memoize :minify_inline
   end
+  memoize :minify_inline
 end

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,28 +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 }
       # template = cache.fetch(:compiled_template, extension, options, body) do
       #   ::Tilt.new(path, 1, options) { body }
       # end
 
-      # Render using Tilt
-      # content = ::Middleman::Util.instrument 'render.tilt', path: path do
-      #   template.render(context, locs, &block)
-      # end
-      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 ''
@@ -104,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