middleman-core 3.4.1 → 4.0.0.alpha.2

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

@@ -0,0 +1,27 @@
+# The Cache Buster extension
+class Middleman::Extensions::CacheBuster < ::Middleman::Extension
+  option :exts, %w(.css .png .jpg .jpeg .webp .svg .svgz .js .gif), 'List of extensions that get cache busters strings appended to them.'
+  option :sources, %w(.htm .html .php .css .js), 'List of extensions that are searched for bustable assets.'
+  option :ignore, [], 'Regexes of filenames to skip adding query strings to'
+
+  def initialize(app, options_hash={}, &block)
+    super
+
+    require 'middleman-core/middleware/inline_url_rewriter'
+  end
+
+  def after_configuration
+    app.use ::Middleman::Middleware::InlineURLRewriter,
+            id: :cache_buster,
+            url_extensions: options.exts,
+            source_extensions: options.sources,
+            ignore: options.ignore,
+            middleman_app: app,
+            proc: method(:rewrite_url)
+  end
+
+  Contract String, Or[String, Pathname], Any => String
+  def rewrite_url(asset_path, _dirpath, _request_path)
+    asset_path + '?' + Time.now.strftime('%s')
+  end
+end

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

@@ -1,9 +1,14 @@
 # Directory Indexes extension
 class Middleman::Extensions::DirectoryIndexes < ::Middleman::Extension
+  # This should run after most other sitemap manipulators so that it
+  # gets a chance to modify any new resources that get added.
+  self.resource_list_manipulator_priority = 100
+
   # Update the main sitemap resource list
-  # @return [void]
+  # @return Array<Middleman::Sitemap::Resource>
+  Contract ResourceList => ResourceList
   def manipulate_resource_list(resources)
-    index_file = app.index_file
+    index_file = app.config[:index_file]
     new_index_path = "/#{index_file}"
 
     resources.each do |resource|
@@ -12,11 +17,8 @@ class Middleman::Extensions::DirectoryIndexes < ::Middleman::Extension
               resource.destination_path.end_with?(new_index_path) ||
               File.extname(index_file) != resource.ext
 
-      # Check if frontmatter turns directory_index off
-      next if resource.raw_data[:directory_index] == false
-
-      # Check if file metadata (options set by "page" in config.rb) turns directory_index off
-      next if resource.metadata[:options][:directory_index] == false
+      # Check if file metadata (options set by "page" in config.rb or frontmatter) turns directory_index off
+      next if resource.options[:directory_index] == false
 
       resource.destination_path = resource.destination_path.chomp(File.extname(index_file)) + new_index_path
     end

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

@@ -0,0 +1,37 @@
+class Middleman::Extensions::ExternalPipeline < ::Middleman::Extension
+  self.supports_multiple_instances = true
+
+  option :name, nil, 'The name of the pipeline', required: true
+  option :command, nil, 'The command to initialize', required: true
+  option :source, nil, 'Path to merge into sitemap', required: true
+  option :latency, 0.25, 'Latency between refreshes of source'
+
+  def initialize(app, config={}, &block)
+    super
+
+    require 'thread'
+
+    app.files.watch :source,
+                    path: File.expand_path(options[:source], app.root),
+                    latency: options[:latency]
+  end
+
+  def after_configuration
+    if app.build?
+      logger.info "== Executing: `#{options[:command]}`"
+      watch_command!
+    else
+      logger.debug "== Executing: `#{options[:command]}`"
+      ::Thread.new { watch_command! }
+    end
+  end
+
+  def watch_command!
+    ::IO.popen(options[:command], 'r') do |pipe|
+      while buf = pipe.gets
+        without_newline = buf.sub(/\n$/, '')
+        logger.info "== External: #{without_newline}" if without_newline.length > 0
+      end
+    end
+  end
+end

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

@@ -13,6 +13,10 @@ class Middleman::Extensions::Gzip < ::Middleman::Extension
   option :exts, %w(.js .css .html .htm), 'File extensions to Gzip when building.'
   option :ignore, [], 'Patterns to avoid gzipping'
 
+  class NumberHelpers
+    include ::Padrino::Helpers::NumberHelpers
+  end
+
   def initialize(app, options_hash={})
     super
 
@@ -24,7 +28,7 @@ class Middleman::Extensions::Gzip < ::Middleman::Extension
 
   def after_build(builder)
     num_threads = 4
-    paths = ::Middleman::Util.all_files_under(app.build_dir)
+    paths = ::Middleman::Util.all_files_under(app.config[:build_dir])
     total_savings = 0
 
     # Fill a queue with inputs
@@ -59,13 +63,14 @@ class Middleman::Extensions::Gzip < ::Middleman::Extension
 
       total_savings += (old_size - new_size)
       size_change_word = (old_size - new_size) > 0 ? 'smaller' : 'larger'
-      builder.say_status :gzip, "#{output_filename} (#{app.number_to_human_size((old_size - new_size).abs)} #{size_change_word})"
+      builder.trigger :gzip, "#{output_filename} (#{NumberHelpers.new.number_to_human_size((old_size - new_size).abs)} #{size_change_word})"
     end
 
-    builder.say_status :gzip, "Total gzip savings: #{app.number_to_human_size(total_savings)}", :blue
+    builder.trigger :gzip, "Total gzip savings: #{NumberHelpers.new.number_to_human_size(total_savings)}"
     I18n.locale = old_locale
   end
 
+  Contract String => [Maybe[String], Maybe[Num], Maybe[Num]]
   def gzip_file(path)
     input_file = File.open(path, 'rb').read
     output_filename = path + '.gz'
@@ -100,7 +105,9 @@ class Middleman::Extensions::Gzip < ::Middleman::Extension
   # Whether a path should be gzipped
   # @param [Pathname] path A destination path
   # @return [Boolean]
+  Contract Pathname => Bool
   def should_gzip?(path)
+    path = path.sub app.config[:build_dir] + '/', ''
     options.exts.include?(path.extname) && options.ignore.none? { |ignore| Middleman::Util.path_match(ignore, path.to_s) }
   end
 end

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

@@ -152,8 +152,8 @@ class Middleman::Extensions::Lorem < ::Middleman::Extension
         color            = options[:color]
 
         if options[:random_color]
-          background_color = hex.sample(6).join
-          color = hex.sample(6).join
+          background_color = hex.shuffle[0...6].join
+          color = hex.shuffle[0...6].join
         end
 
         src << "/#{background_color.sub(/^#/, '')}" if background_color

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

@@ -0,0 +1,86 @@
+require 'middleman-core/contracts'
+
+# Minify CSS Extension
+class Middleman::Extensions::MinifyCss < ::Middleman::Extension
+  option :inline, false, 'Whether to minify CSS inline within HTML files'
+  option :ignore, [], 'Patterns to avoid minifying'
+  option :compressor, proc {
+    require 'sass'
+    SassCompressor
+  }, 'Set the CSS compressor to use.'
+
+  def after_configuration
+    # Setup Rack middleware to minify CSS
+    app.use Rack, compressor: options[:compressor],
+                  ignore: Array(options[:ignore]) + [/\.min\./],
+                  inline: options[:inline]
+  end
+
+  class SassCompressor
+    def self.compress(style, options={})
+      root_node = ::Sass::SCSS::CssParser.new(style, 'middleman-css-input', 1).parse
+      root_node.options = options.merge(style: :compressed)
+      root_node.render.strip
+    end
+  end
+
+  # Rack middleware to look for CSS and compress it
+  class Rack
+    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
+    end
+
+    # Rack interface
+    # @param [Rack::Environmemt] env
+    # @return [Array]
+    def call(env)
+      status, headers, response = @app.call(env)
+
+      if inline_html_content?(env['PATH_INFO'])
+        minified = ::Middleman::Util.extract_response_text(response)
+        minified.gsub!(INLINE_CSS_REGEX) do
+          $1 << @compressor.compress($2) << $3
+        end
+
+        headers['Content-Length'] = ::Rack::Utils.bytesize(minified).to_s
+        response = [minified]
+      elsif standalone_css_content?(env['PATH_INFO'])
+        minified_css = @compressor.compress(::Middleman::Util.extract_response_text(response))
+
+        headers['Content-Length'] = ::Rack::Utils.bytesize(minified_css).to_s
+        response = [minified_css]
+      end
+
+      [status, headers, response]
+    end
+
+    private
+
+    Contract String => Bool
+    def inline_html_content?(path)
+      (path.end_with?('.html') || path.end_with?('.php')) && @inline
+    end
+
+    Contract String => Bool
+    def standalone_css_content?(path)
+      path.end_with?('.css') && @ignore.none? { |ignore| Middleman::Util.path_match(ignore, path) }
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+require 'middleman-core/contracts'
+
+# 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.'
+
+  def after_configuration
+    # Setup Rack middleware to minify CSS
+    app.use Rack, compressor: options[:compressor],
+                  ignore: Array(options[:ignore]) + [/\.min\./],
+                  inline: options[:inline]
+  end
+
+  # Rack middleware to look for JS and compress it
+  class Rack
+    include Contracts
+
+    # 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
+    end
+
+    # Rack interface
+    # @param [Rack::Environmemt] env
+    # @return [Array]
+    def call(env)
+      status, headers, response = @app.call(env)
+
+      path = env['PATH_INFO']
+
+      begin
+        if @inline && (path.end_with?('.html') || path.end_with?('.php'))
+          uncompressed_source = ::Middleman::Util.extract_response_text(response)
+
+          minified = minify_inline_content(uncompressed_source)
+
+          headers['Content-Length'] = ::Rack::Utils.bytesize(minified).to_s
+          response = [minified]
+        elsif path.end_with?('.js') && @ignore.none? { |ignore| Middleman::Util.path_match(ignore, path) }
+          uncompressed_source = ::Middleman::Util.extract_response_text(response)
+          minified = @compressor.compress(uncompressed_source)
+
+          headers['Content-Length'] = ::Rack::Utils.bytesize(minified).to_s
+          response = [minified]
+        end
+      rescue ExecJS::ProgramError => e
+        warn "WARNING: Couldn't compress JavaScript in #{path}: #{e.message}"
+      end
+
+      [status, headers, response]
+    end
+
+    private
+
+    Contract String => String
+    def minify_inline_content(uncompressed_source)
+      uncompressed_source.gsub(/(<script[^>]*>\s*(?:\/\/(?:(?:<!--)|(?:<!\[CDATA\[))\n)?)(.*?)((?:(?:\n\s*)?\/\/(?:(?:-->)|(?:\]\]>)))?\s*<\/script>)/m) do |match|
+        first = $1
+        javascript = $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 =~ /<script>/ || first.include?('text/javascript')
+          minified_js = @compressor.compress(javascript)
+
+          first << minified_js << last
+        else
+          match
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# Relative Assets extension
+class Middleman::Extensions::RelativeAssets < ::Middleman::Extension
+  option :exts, %w(.css .png .jpg .jpeg .webp .svg .svgz .js .gif .ttf .otf .woff), 'List of extensions that get cache busters strings appended to them.'
+  option :sources, %w(.htm .html .css), 'List of extensions that are searched for relative assets.'
+  option :ignore, [], 'Regexes of filenames to skip adding query strings to'
+
+  def initialize(app, options_hash={}, &block)
+    super
+
+    require 'middleman-core/middleware/inline_url_rewriter'
+  end
+
+  def after_configuration
+    app.use ::Middleman::Middleware::InlineURLRewriter,
+            id: :asset_hash,
+            url_extensions: options.exts,
+            source_extensions: options.sources,
+            ignore: options.ignore,
+            middleman_app: app,
+            proc: method(:rewrite_url)
+  end
+
+  Contract String, Or[String, Pathname], Any => Maybe[String]
+  def rewrite_url(asset_path, dirpath, request_path)
+    relative_path = Pathname.new(asset_path).relative?
+
+    full_asset_path = if relative_path
+      dirpath.join(asset_path).to_s
+    else
+      asset_path
+    end
+
+    return unless !full_asset_path.include?('//') && !asset_path.start_with?('data:')
+
+    current_dir = Pathname(request_path).dirname
+    Pathname(full_asset_path).relative_path_from(current_dir).to_s
+  end
+end

data/lib/middleman-core/file_renderer.rb

@@ -0,0 +1,139 @@
+require 'tilt'
+require 'active_support/core_ext/string/output_safety'
+require 'active_support/core_ext/module/delegation'
+require 'middleman-core/contracts'
+
+::Tilt.mappings.delete('html') # WTF, Tilt?
+::Tilt.mappings.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, 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 = opts.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
+      @app.class.callbacks_for_hook(:before_render).each do |callback|
+        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 }
+      end
+
+      # Render using Tilt
+      content = template.render(context, locs, &block)
+
+      # Allow hooks to manipulate the result after render
+      @app.class.callbacks_for_hook(:after_render).each do |callback|
+        # Uber::Options::Value doesn't respond to call
+        newcontent = if callback.respond_to?(:call)
+          callback.call(content, path, locs, template_class)
+        elsif callback.respond_to?(:evaluate)
+          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 ''
+      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 None => String
+    def template_data_for_file
+      if @app.extensions[:front_matter]
+        @app.extensions[:front_matter].template_data_for_file(@path) || ''
+      else
+        file = @app.files.find(:source, @path)
+        file.read if file
+      end
+    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 = ::Tilt[ext]
+        ::Tilt.mappings.each do |mapping_ext, engines|
+          next unless engines.include? extension_class
+          engine_options = @app.config[mapping_ext.to_sym] || {}
+          options.merge!(engine_options)
+        end
+
+        options
+      end
+    end
+  end
+end