middleman-core 4.6.0 → 5.0.0.rc.1

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

@@ -6,15 +6,13 @@ class Middleman::Extensions::ExternalPipeline < ::Middleman::Extension
   option :source, nil, 'Path to merge into sitemap', required: true
   option :latency, 0.25, 'Latency between refreshes of source'
   option :disable_background_execution, false, "Don't run the command in a separate background thread"
-  option :ignore_exit_code, false, 'Ignore exit code for restart or stop of a command'
 
-  def initialize(app, config={}, &block)
+  def initialize(app, options_hash = ::Middleman::EMPTY_HASH, &block)
     super
 
     return if app.mode?(:config)
 
     require 'servolux'
-    require 'thread'
     require 'fileutils'
 
     source_path = File.expand_path(options[:source], app.root)
@@ -42,12 +40,12 @@ class Middleman::Extensions::ExternalPipeline < ::Middleman::Extension
   end
 
   def reload!
-    if @current_thread
-      logger.info "== Stopping: `#{options[:command]}`"
+    return unless @current_thread
 
-      @current_thread.stop
-      @current_thread = nil
-    end
+    logger.info "== Stopping: `#{options[:command]}`"
+
+    @current_thread.stop
+    @current_thread = nil
   end
 
   def watch_command!(async)
@@ -59,14 +57,17 @@ class Middleman::Extensions::ExternalPipeline < ::Middleman::Extension
     @current_thread.start
 
     watch_thread = Thread.new do
-      while buf = @current_thread.io.gets
+      buf = @current_thread.io.gets
+
+      while buf
         without_newline = buf.sub(/\n$/, '')
         logger.info "== External: #{without_newline}" unless without_newline.empty?
+        buf = @current_thread.io.gets
       end
 
       @current_thread.wait
 
-      if !options[:ignore_exit_code] && !@current_thread.exitstatus.nil? && @current_thread.exitstatus != 0
+      if !@current_thread.exitstatus.nil? && @current_thread.exitstatus != 0
         logger.error '== External: Command failed with non-zero exit status'
         exit(1)
       end
@@ -81,9 +82,12 @@ class Middleman::Extensions::ExternalPipeline < ::Middleman::Extension
   private
 
   def print_command(stdout)
-    while buf = stdout.gets
+    buf = stdout.gets
+
+    while buf
       without_newline = buf.sub(/\n$/, '')
       logger.info "== External: #{without_newline}" unless without_newline.empty?
+      buf = stdout.gets
     end
   end
 end

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

@@ -1,16 +1,16 @@
 # This extension Gzips assets and pages when building.
 # Gzipped assets and pages can be served directly by Apache or
 # Nginx with the proper configuration, and pre-zipping means that we
-# can use a more agressive compression level at no CPU cost per request.
+# can use a more aggressive compression level at no CPU cost per request.
 #
 # Use Nginx's gzip_static directive, or AddEncoding and mod_rewrite in Apache
 # to serve your Gzipped files whenever the normal (non-.gz) filename is requested.
 #
 # Pass the :exts options to customize which file extensions get zipped (defaults
-# to .css, .htm, .html, .js, and .xhtml
+# to .css, .htm, .html, .js, .mjs, and .xhtml
 #
 class Middleman::Extensions::Gzip < ::Middleman::Extension
-  option :exts, %w(.css .htm .html .js .svg .xhtml), 'File extensions to Gzip when building.'
+  option :exts, %w[.css .htm .html .js .mjs .svg .xhtml], 'File extensions to Gzip when building.'
   option :ignore, [], 'Patterns to avoid gzipping'
   option :overwrite, false, 'Overwrite original files instead of adding .gz extension.'
 
@@ -18,13 +18,15 @@ class Middleman::Extensions::Gzip < ::Middleman::Extension
     include ::Padrino::Helpers::NumberHelpers
   end
 
-  def initialize(app, options_hash={})
+  def initialize(app, options_hash = ::Middleman::EMPTY_HASH)
     super
 
     require 'zlib'
     require 'stringio'
     require 'find'
-    require 'thread'
+    require 'set'
+
+    @set_of_exts = Set.new options.exts
   end
 
   def after_build(builder)
@@ -43,8 +45,11 @@ class Middleman::Extensions::Gzip < ::Middleman::Extension
     out_queue = Queue.new
     num_threads.times.each do
       Thread.new do
-        while path = in_queue.pop
+        path = in_queue.pop
+
+        while path
           out_queue << gzip_file(path.to_s)
+          path = in_queue.pop
         end
       end
     end
@@ -63,7 +68,7 @@ class Middleman::Extensions::Gzip < ::Middleman::Extension
       next unless output_filename
 
       total_savings += (old_size - new_size)
-      size_change_word = (old_size - new_size) > 0 ? 'smaller' : 'larger'
+      size_change_word = (old_size - new_size).positive? ? 'smaller' : 'larger'
       builder.trigger :created, "#{output_filename} (#{NumberHelpers.new.number_to_human_size((old_size - new_size).abs)} #{size_change_word})"
     end
 
@@ -78,9 +83,7 @@ class Middleman::Extensions::Gzip < ::Middleman::Extension
     input_file_time = File.mtime(path)
 
     # Check if the right file's already there
-    if !options.overwrite && File.exist?(output_filename) && File.mtime(output_filename) == input_file_time
-      return [nil, nil, nil]
-    end
+    return [nil, nil, nil] if !options.overwrite && File.exist?(output_filename) && File.mtime(output_filename) == input_file_time
 
     File.open(output_filename, 'wb') do |f|
       gz = Zlib::GzipWriter.new(f, Zlib::BEST_COMPRESSION)
@@ -108,7 +111,9 @@ class Middleman::Extensions::Gzip < ::Middleman::Extension
   # @return [Boolean]
   Contract Pathname => Bool
   def should_gzip?(path)
+    return false unless @set_of_exts.include?(path.extname)
+
     path = path.sub app.config[:build_dir] + '/', ''
-    options.exts.include?(path.extname) && options.ignore.none? { |ignore| Middleman::Util.path_match(ignore, path.to_s) }
+    options.ignore.none? { |ignore| Middleman::Util.path_match(ignore, path.to_s) }
   end
 end

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

@@ -11,7 +11,8 @@ class Middleman::Extensions::Lorem < ::Middleman::Extension
     # @param [String] size
     # @param [Hash] options
     # @return [String]
-    def placekitten(size, options={})
+    def placekitten(size, options_hash = ::Middleman::EMPTY_HASH)
+      options = options_hash.dup
       options[:domain] = 'http://placekitten.com'
       lorem.image(size, options)
     end
@@ -44,7 +45,7 @@ class Middleman::Extensions::Lorem < ::Middleman::Extension
   module LoremObject
     class << self
       # Words for use in lorem text
-      WORDS = %w(alias consequatur aut perferendis sit voluptatem accusantium doloremque aperiam eaque ipsa quae ab illo inventore veritatis et quasi architecto beatae vitae dicta sunt explicabo aspernatur aut odit aut fugit sed quia consequuntur magni dolores eos qui ratione voluptatem sequi nesciunt neque dolorem ipsum quia dolor sit amet consectetur adipisci velit sed quia non numquam eius modi tempora incidunt ut labore et dolore magnam aliquam quaerat voluptatem ut enim ad minima veniam quis nostrum exercitationem ullam corporis nemo enim ipsam voluptatem quia voluptas sit suscipit laboriosam nisi ut aliquid ex ea commodi consequatur quis autem vel eum iure reprehenderit qui in ea voluptate velit esse quam nihil molestiae et iusto odio dignissimos ducimus qui blanditiis praesentium laudantium totam rem voluptatum deleniti atque corrupti quos dolores et quas molestias excepturi sint occaecati cupiditate non provident sed ut perspiciatis unde omnis iste natus error similique sunt in culpa qui officia deserunt mollitia animi id est laborum et dolorum fuga et harum quidem rerum facilis est et expedita distinctio nam libero tempore cum soluta nobis est eligendi optio cumque nihil impedit quo porro quisquam est qui minus id quod maxime placeat facere possimus omnis voluptas assumenda est omnis dolor repellendus temporibus autem quibusdam et aut consequatur vel illum qui dolorem eum fugiat quo voluptas nulla pariatur at vero eos et accusamus officiis debitis aut rerum necessitatibus saepe eveniet ut et voluptates repudiandae sint et molestiae non recusandae itaque earum rerum hic tenetur a sapiente delectus ut aut reiciendis voluptatibus maiores doloribus asperiores repellat).freeze
+      WORDS = %w[alias consequatur aut perferendis sit voluptatem accusantium doloremque aperiam eaque ipsa quae ab illo inventore veritatis et quasi architecto beatae vitae dicta sunt explicabo aspernatur aut odit aut fugit sed quia consequuntur magni dolores eos qui ratione voluptatem sequi nesciunt neque dolorem ipsum quia dolor sit amet consectetur adipisci velit sed quia non numquam eius modi tempora incidunt ut labore et dolore magnam aliquam quaerat voluptatem ut enim ad minima veniam quis nostrum exercitationem ullam corporis nemo enim ipsam voluptatem quia voluptas sit suscipit laboriosam nisi ut aliquid ex ea commodi consequatur quis autem vel eum iure reprehenderit qui in ea voluptate velit esse quam nihil molestiae et iusto odio dignissimos ducimus qui blanditiis praesentium laudantium totam rem voluptatum deleniti atque corrupti quos dolores et quas molestias excepturi sint occaecati cupiditate non provident sed ut perspiciatis unde omnis iste natus error similique sunt in culpa qui officia deserunt mollitia animi id est laborum et dolorum fuga et harum quidem rerum facilis est et expedita distinctio nam libero tempore cum soluta nobis est eligendi optio cumque nihil impedit quo porro quisquam est qui minus id quod maxime placeat facere possimus omnis voluptas assumenda est omnis dolor repellendus temporibus autem quibusdam et aut consequatur vel illum qui dolorem eum fugiat quo voluptas nulla pariatur at vero eos et accusamus officiis debitis aut rerum necessitatibus saepe eveniet ut et voluptates repudiandae sint et molestiae non recusandae itaque earum rerum hic tenetur a sapiente delectus ut aut reiciendis voluptatibus maiores doloribus asperiores repellat].freeze
 
       # Get one placeholder word
       # @return [String]
@@ -94,10 +95,10 @@ class Middleman::Extensions::Lorem < ::Middleman::Extension
       # Get a placeholder date
       # @param [String] fmt
       # @return [String]
-      def date(fmt='%a %b %d, %Y')
-        y = rand(20) + 1990
-        m = rand(12) + 1
-        d = rand(31) + 1
+      def date(fmt = '%a %b %d, %Y')
+        y = rand(1990..2009)
+        m = rand(1..12)
+        d = rand(1..31)
         Time.local(y, m, d).strftime(fmt)
       end
 
@@ -135,7 +136,7 @@ class Middleman::Extensions::Lorem < ::Middleman::Extension
       # @return [String]
       def email
         delimiters = ['_', '-', '']
-        domains = %w(gmail.com yahoo.com hotmail.com email.com live.com me.com mac.com aol.com fastmail.com mail.com)
+        domains = %w[gmail.com yahoo.com hotmail.com email.com live.com me.com mac.com aol.com fastmail.com mail.com]
         username = name.gsub(/[^\w]/, delimiters[rand(delimiters.size)])
         "#{username}@#{domains[rand(domains.size)]}".downcase
       end
@@ -144,14 +145,14 @@ class Middleman::Extensions::Lorem < ::Middleman::Extension
       # @param [String] size
       # @param [Hash] options
       # @return [String]
-      def image(size, options={})
-        domain           = options[:domain] || 'http://placehold.it'
+      def image(size, options_hash = ::Middleman::EMPTY_HASH)
+        domain           = options_hash[:domain] || 'http://placehold.it'
         src              = "#{domain}/#{size}"
-        hex              = %w(a b c d e f 0 1 2 3 4 5 6 7 8 9)
-        background_color = options[:background_color]
-        color            = options[:color]
+        hex              = %w[a b c d e f 0 1 2 3 4 5 6 7 8 9]
+        background_color = options_hash[:background_color]
+        color            = options_hash[:color]
 
-        if options[:random_color]
+        if options_hash[:random_color]
           background_color = hex.sample(6).join
           color = hex.sample(6).join
         end
@@ -159,7 +160,7 @@ class Middleman::Extensions::Lorem < ::Middleman::Extension
         src << "/#{background_color.sub(/^#/, '')}" if background_color
         src << '/ccc' if background_color.nil? && color
         src << "/#{color.sub(/^#/, '')}" if color
-        src << "&text=#{Rack::Utils.escape(options[:text])}" if options[:text]
+        src << "&text=#{Rack::Utils.escape(options_hash[:text])}" if options_hash[:text]
 
         src
       end

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(text/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