middleman-core 3.3.12 → 4.4.2

data/lib/{middleman-more → middleman-core}/extensions/minify_javascript.rb

@@ -1,25 +1,21 @@
+require 'active_support/core_ext/object/try'
+require 'middleman-core/contracts'
+require 'memoist'
+
 # Minify Javascript Extension
 class Middleman::Extensions::MinifyJavascript < ::Middleman::Extension
-  option :compressor, nil, 'Set the JS compressor to use.'
   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'
 
-  def initialize(app, options_hash={}, &block)
-    super
-
-    app.config.define_setting :js_compressor, nil, 'Set the JS compressor to use. Deprecated in favor of the :compressor option when activating :minify_js'
-  end
-
-  def after_configuration
-    chosen_compressor = app.config[:js_compressor] || options[:compressor] || begin
-      require 'uglifier'
-      ::Uglifier.new
-    end
-
+  def ready
     # Setup Rack middleware to minify JS
-    app.use Rack, compressor: chosen_compressor,
+    app.use Rack, compressor: options[:compressor],
                   ignore: Array(options[:ignore]) + [/\.min\./],
                   inline: options[:inline],
                   content_types: options[:content_types],
@@ -28,16 +24,26 @@ class Middleman::Extensions::MinifyJavascript < ::Middleman::Extension
 
   # 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
-      @compressor = options[:compressor]
-      @ignore = options[:ignore]
-      @inline = options[:inline]
+      @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
@@ -49,16 +55,16 @@ class Middleman::Extensions::MinifyJavascript < ::Middleman::Extension
       status, headers, response = @app.call(env)
 
       type = headers['Content-Type'].try(:slice, /^[^;]*/)
-      path = env['PATH_INFO']
+      @path = env['PATH_INFO']
 
       minified = if @inline && minifiable_inline?(type)
         minify_inline(::Middleman::Util.extract_response_text(response))
-      elsif minifiable?(type) && !ignore?(path)
+      elsif minifiable?(type) && !ignore?(@path)
         minify(::Middleman::Util.extract_response_text(response))
       end
 
       if minified
-        headers['Content-Length'] = ::Rack::Utils.bytesize(minified).to_s
+        headers['Content-Length'] = minified.bytesize.to_s
         response = [minified]
       end
 
@@ -73,6 +79,7 @@ class Middleman::Extensions::MinifyJavascript < ::Middleman::Extension
     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
@@ -80,6 +87,7 @@ class Middleman::Extensions::MinifyJavascript < ::Middleman::Extension
     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
@@ -87,6 +95,7 @@ class Middleman::Extensions::MinifyJavascript < ::Middleman::Extension
     def minifiable_inline?(content_type)
       @inline_content_types.include?(content_type)
     end
+    memoize :minifiable_inline?
 
     # Minify the content
     # @param [String] content
@@ -94,25 +103,29 @@ class Middleman::Extensions::MinifyJavascript < ::Middleman::Extension
     def minify(content)
       @compressor.compress(content)
     rescue ExecJS::ProgramError => e
-      warn "WARNING: Couldn't compress JavaScript in #{path}: #{e.message}"
+      warn "WARNING: Couldn't compress JavaScript in #{@path}: #{e.message}"
       content
     end
+    memoize :minify
 
     # Detect and minify inline content
     # @param [String] content
     # @return [String]
     def minify_inline(content)
       content.gsub(INLINE_JS_REGEX) do |match|
-        first, inline_content, last = $1, $2, $3
+        first = $1
+        inline_content = $2
+        last = $3
 
         # Only compress script tags that contain JavaScript (as opposed to
         # something like jQuery templates, identified with a "text/html" type).
-        if first.include?('<script>') || first.include?('text/javascript')
+        if !first.include?('type=') || first.include?('text/javascript')
           first + minify(inline_content) + last
         else
           match
         end
       end
     end
+    memoize :minify_inline
   end
 end

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

@@ -0,0 +1,78 @@
+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 :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)
+    super
+
+    return if options[:helpers_only]
+
+    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)
+  end
+
+  def mark_as_relative(file_path, opts, current_resource)
+    result = opts.dup
+
+    valid_exts = options.sources
+
+    return result unless current_resource
+    return result unless valid_exts.include?(current_resource.ext)
+
+    rewrite_ignores = Array(options.rewrite_ignore || [])
+
+    path = current_resource.destination_path
+    return result if rewrite_ignores.any? do |i|
+      ::Middleman::Util.path_match(i, path) || ::Middleman::Util.path_match(i, "/#{path}")
+    end
+
+    return result if Array(options.ignore || []).any? do |r|
+      ::Middleman::Util.should_ignore?(r, file_path)
+    end
+
+    result[:relative] = true unless result.key?(:relative)
+
+    result
+  end
+
+  helpers do
+    def asset_url(path, prefix='', options={})
+      super(path, prefix, app.extensions[:relative_assets].mark_as_relative(super, options, current_resource))
+    end
+
+    def asset_path(kind, source, options={})
+      super(kind, source, app.extensions[:relative_assets].mark_as_relative(super, options, current_resource))
+    end
+  end
+
+  Contract String, Or[String, Pathname], Any => Maybe[String]
+  def rewrite_url(asset_path, dirpath, request_path)
+    uri = ::Middleman::Util.parse_uri(asset_path)
+
+    return if uri.path[0..0] != '/'
+
+    relative_path = uri.host.nil?
+
+    full_asset_path = if relative_path
+      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
+
+    result
+  end
+  memoize :rewrite_url
+end

data/lib/middleman-core/extensions.rb

@@ -1,98 +1,137 @@
+require 'middleman-core/extension'
+
 module Middleman
+  # The Extensions module is used to handle global registration and loading of Middleman Extensions.
+  #
+  # The application-facing extension API ({Middleman::CoreExtensions::Extensions#activate activate}, etc) is in {Middleman::CoreExtensions::Extensions} in
+  # `middleman-core/core_extensions/extensions.rb`.
   module Extensions
+    @registered = {}
+    @auto_activate = {
+      # Activate before the Sitemap is instantiated
+      before_sitemap: Set.new,
+
+      # Activate the extension before `config.rb` and the `:before_configuration` hook.
+      before_configuration: Set.new
+    }
+
+    AutoActivation = Struct.new(:name, :modes)
+
     class << self
-      def registered
-        @_registered ||= {}
-      end
+      # @api private
+      # A hash of all registered extensions. Registered extensions are not necessarily active - this
+      # is the set of all extensions that are known to Middleman.
+      # @return [Hash{Symbol => Class<Middleman::Extension>, Proc}] A directory of known extensions indexed by the name they were registered under. The value may be a Proc, which can be lazily called to return an extension class.
+      attr_reader :registered
 
       # Register a new extension. Choose a name which will be
-      # used to activate the extension in config.rb, like this:
+      # used to activate the extension in `config.rb`, like this:
       #
       #     activate :my_extension
       #
-      # Provide your extension module either as the namespace
-      # parameter, or return it from the block:
+      # Provide your extension class either as the second parameter:
+      #
+      #     Middleman::Extensions.register(:my_extension, MyExtension)
+      #
+      # Or better, return it from a block, which allows you to lazily require the implementation:
+      #
+      #     Middleman::Extensions.register :my_extension do
+      #       require 'my_extension'
+      #       MyExtension
+      #     end
       #
       # @param [Symbol] name The name of the extension
-      # @param [Module] namespace The extension module
+      # @param [Class<Middleman::Extension>] extension_class The extension class (Must inherit from {Middleman::Extension})
+      # @option options [Boolean] :auto_activate If this is set to a lifecycle event (:before_configuration or :before_sitemap), this extension will be automatically activated at that point.
+      #         This is intended for use with built-in Middleman extensions and should not be used by third-party extensions.
       # @yield Instead of passing a module in namespace, you can provide
-      #        a block which returns your extension module. This gives
+      #        a block which returns your extension class. This gives
       #        you the ability to require other files only when the
-      #        extension is activated.
-      def register(name, namespace=nil, &block)
-        # If we've already got a matching extension that passed the
-        # version check, bail out.
-        return if registered.key?(name.to_sym) &&
-                  !registered[name.to_sym].is_a?(String)
-
-        registered[name.to_sym] = if block_given?
+      #        extension is first activated.
+      # @return [void]
+      def register(name, extension_class=nil, options={}, &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)
+
+        # 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
+          extension_class = nil
+        end
+
+        registered[name] = if block_given?
           block
-        elsif namespace
-          namespace
+        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
+
+        return unless options[:auto_activate]
+
+        descriptor = AutoActivation.new(name, options[:modes] || :all)
+        @auto_activate[options[:auto_activate]] << descriptor
       end
 
+      # @api private
+      # Load an extension by name, lazily evaluating the block provided to {#register} if necessary.
+      # @param [Symbol] name The name of the extension
+      # @return [Class<Middleman::Extension>] A {Middleman::Extension} class implementing the extension
+      #
       def load(name)
-        name = name.to_sym
-        return nil unless registered.key?(name)
+        raise 'Extension name must be a symbol' unless name.is_a?(Symbol)
 
-        extension = registered[name]
-        if extension.is_a?(Proc)
-          extension = extension.call || nil
-          registered[name] = extension
+        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
 
-        extension
-      end
-    end
-  end
+        extension_class = registered[name]
+        if extension_class.is_a?(Proc)
+          extension_class = extension_class.call
+          registered[name] = extension_class
+        end
 
-  # Where to look in gems for extensions to auto-register
-  EXTENSION_FILE = File.join('lib', 'middleman_extension.rb') unless const_defined?(:EXTENSION_FILE)
+        unless extension_class.ancestors.include?(::Middleman::Extension)
+          raise "Tried to activate old-style extension: #{name}. They are no longer supported."
+        end
 
-  class << self
-    # Automatically load extensions from available RubyGems
-    # which contain the EXTENSION_FILE
-    #
-    # @private
-    def load_extensions_in_path
-      require 'rubygems'
+        # Set the extension's name to whatever it was registered as.
+        extension_class.ext_name = name
 
-      extensions = rubygems_latest_specs.select do |spec|
-        spec_has_file?(spec, EXTENSION_FILE)
+        extension_class
       end
 
-      extensions.each do |spec|
-        require spec.name
+      # @api private
+      # A flattened list of all extensions which are automatically activated
+      # @return [Array<Symbol>] A list of extension names which are automatically activated.
+      def auto_activated
+        @auto_activate.values.map(&:to_a).flatten.map(&:name)
       end
-    end
 
-    # Backwards compatible means of finding all the latest gemspecs
-    # available on the system
-    #
-    # @private
-    # @return [Array] Array of latest Gem::Specification
-    def rubygems_latest_specs
-      # If newer Rubygems
-      if ::Gem::Specification.respond_to? :latest_specs
-        ::Gem::Specification.latest_specs(true)
-      else
-        ::Gem.source_index.latest_specs
+      # @api private
+      # Load autoactivatable extensions for the given env.
+      # @param [Symbol] group The name of the auto_activation group.
+      # @param [Middleman::Application] app An instance of the app.
+      def auto_activate(group, app)
+        @auto_activate[group].each do |descriptor|
+          next unless descriptor[:modes] == :all || descriptor[:modes].include?(app.config[:mode])
+
+          app.extensions.activate descriptor[:name]
+        end
       end
-    end
 
-    # Where a given Gem::Specification has a specific file. Used
-    # to discover extensions.
-    #
-    # @private
-    # @param [Gem::Specification] spec
-    # @param [String] path Path to look for
-    # @return [Boolean] Whether the file exists
-    def spec_has_file?(spec, path)
-      full_path = File.join(spec.full_gem_path, path)
-      File.exist?(full_path)
+      def load_settings(app)
+        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
+          rescue LoadError
+          end
+        end
+      end
     end
   end
 end
-
-require 'middleman-core/extension'

data/lib/middleman-core/file_renderer.rb

@@ -0,0 +1,136 @@
+require 'tilt'
+require 'active_support/core_ext/string/output_safety'
+require 'active_support/core_ext/module/delegation'
+require 'middleman-core/contracts'
+
+::Tilt.default_mapping.lazy_map.delete('html')
+::Tilt.default_mapping.lazy_map.delete('csv')
+
+module Middleman
+  class FileRenderer
+    extend Forwardable
+    include Contracts
+
+    def self.cache
+      @_cache ||= ::Tilt::Cache.new
+    end
+
+    def_delegator :"self.class", :cache
+
+    def initialize(app, path)
+      @app = app
+      @path = path.to_s
+    end
+
+    # Render an on-disk file. Used for everything, including layouts.
+    #
+    # @param [Hash] locs
+    # @param [Hash] opts
+    # @param [Class] context
+    # @return [String]
+    Contract Hash, Hash, Any, Maybe[Proc] => String
+    def render(locs, opts, context, &block)
+      path = @path.dup
+
+      # Detect the remdering 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
+
+      # 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
+
+      # Merge per-extension options from config
+      extension = File.extname(path)
+      options = {}.merge!(opts).merge!(options_for_ext(extension))
+      options[:outvar] ||= '@_out_buf'
+      options[:context] = context
+      options.delete(:layout)
+
+      # 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)
+
+      # 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
+      end
+
+      output = ::ActiveSupport::SafeBuffer.new ''
+      output.safe_concat content
+      output
+    ensure
+      # Reset stored buffer
+      context.restore_buffer(buf_was)
+      context.current_engine = engine_was
+    end
+
+    # Get the template data from a path
+    # @param [String] path
+    # @return [String]
+    Contract String
+    def template_data_for_file
+      file = @app.files.find(:source, @path)
+
+      if @app.extensions[:front_matter] && (file && !file[:types].include?(:no_frontmatter))
+        result = @app.extensions[:front_matter].template_data_for_file(@path)
+        return result unless result.nil?
+      end
+
+      file ? file.read : ::File.read(@path)
+    end
+
+    protected
+
+    # Get a hash of configuration options for a given file extension, from
+    # config.rb
+    #
+    # @param [String] ext
+    # @return [Hash]
+    Contract String => Hash
+    def options_for_ext(ext)
+      # Read options for extension from config/Tilt or cache
+      cache.fetch(:options_for_ext, ext) do
+        options = {}
+
+        # Find all the engines which handle this extension in tilt. Look for
+        # config variables of that name and merge it
+        extension_class = ::Middleman::Util.tilt_class(ext)
+
+        ::Tilt.default_mapping.extensions_for(extension_class).each do |mapping_ext|
+          engine_options = @app.config[mapping_ext.to_sym] || {}
+          options.merge!(engine_options)
+        end
+
+        options
+      end
+    end
+  end
+end

data/lib/middleman-core/load_paths.rb

@@ -7,47 +7,43 @@ module Middleman
       @_is_setup ||= begin
 
         # Only look for config.rb if MM_ROOT isn't set
-        if !ENV['MM_ROOT'] && found_path = locate_root
+        if !ENV['MM_ROOT'] && (found_path = findup('config.rb'))
           ENV['MM_ROOT'] = found_path
         end
 
-        is_bundler_setup = false
-
         # If we've found the root, try to setup Bundler
-        if ENV['MM_ROOT']
-
-          root_gemfile = File.expand_path('Gemfile', ENV['MM_ROOT'])
-          ENV['BUNDLE_GEMFILE'] ||= root_gemfile
+        setup_bundler if ENV['MM_ROOT']
 
-          unless File.exist?(ENV['BUNDLE_GEMFILE'])
-            git_gemfile = Pathname.new(__FILE__).expand_path.parent.parent.parent + 'Gemfile'
-            ENV['BUNDLE_GEMFILE'] = git_gemfile.to_s
-          end
+        true
+      end
+    end
 
-          if File.exist?(ENV['BUNDLE_GEMFILE'])
-            is_bundler_setup = true
-            require 'bundler/setup'
-          end
-        end
+    private
 
-        # Automatically discover extensions in RubyGems
-        require 'middleman-core/extensions'
+    # 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
 
-        if is_bundler_setup
-          Bundler.require
-        else
-          ::Middleman.load_extensions_in_path
-        end
+      unless File.exist?(ENV['BUNDLE_GEMFILE'])
+        ENV['BUNDLE_GEMFILE'] = File.expand_path('../../../../Gemfile', __FILE__)
+      end
 
-        true
+      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
     end
 
-    # Recursive method to find config.rb
-    def locate_root(cwd=Pathname.new(Dir.pwd))
-      return cwd.to_s if (cwd + 'config.rb').exist?
+    # Recursive method to find a file in parent directories
+    def findup(filename, cwd=Dir.pwd)
+      cwd = Pathname(cwd)
+      return cwd.to_s if (cwd + filename).exist?
       return false if cwd.root?
-      locate_root(cwd.parent)
+      findup(filename, cwd.parent)
     end
   end
 end

data/lib/middleman-core/logger.rb

@@ -7,7 +7,7 @@ module Middleman
   # The Middleman Logger
   class Logger < ActiveSupport::Logger
     def self.singleton(*args)
-      if !@_logger || args.length > 0
+      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
@@ -39,8 +39,9 @@ module Middleman
     def call(message, *args)
       return if @instrumenting.is_a?(String) && @instrumenting != 'instrument' && !message.include?(@instrumenting)
 
-      evt = ActiveSupport::Notifications::Event.new(message, *args)
-      info "== Instrument (#{evt.name.sub(/.middleman$/, '')}): #{evt.duration}ms"
+      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
 end