middleman-core 3.3.12 → 4.4.2

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

@@ -0,0 +1,120 @@
+require 'middleman-core/util'
+require 'middleman-core/rack'
+
+class Middleman::Extensions::AssetHash < ::Middleman::Extension
+  option :sources, %w(.css .htm .html .js .php .xhtml), 'List of extensions that are searched for hashable assets.'
+  option :exts, nil, 'List of extensions that get asset hashes appended to them.'
+  option :ignore, [], 'Regexes of filenames to skip adding asset hashes to'
+  option :rewrite_ignore, [], 'Regexes of filenames to skip processing for path rewrites'
+  option :prefix, '', 'Prefix for hash'
+  option :rename_proc, proc { |path, basename, digest, extension, options|
+    "#{path}#{basename}-#{options.prefix}#{digest}#{extension}"
+  }, 'Accepts path parameters and returns path name'
+
+  def initialize(app, options_hash={}, &block)
+    super
+
+    require 'addressable/uri'
+    require 'digest/sha1'
+    require 'rack/mock'
+
+    # Allow specifying regexes to ignore, plus always ignore apple touch icons
+    @ignore = Array(options.ignore) + [/^apple-touch-icon/]
+
+    # Exclude .ico from the default list because browsers expect it
+    # to be named "favicon.ico"
+    @exts = options.exts || (app.config[:asset_extensions] - %w(.ico))
+
+    app.rewrite_inline_urls id: :asset_hash,
+                            url_extensions: @exts.sort.reverse,
+                            source_extensions: options.sources,
+                            ignore: @ignore,
+                            rewrite_ignore: options.rewrite_ignore,
+                            proc: method(:rewrite_url),
+                            after: :asset_host
+  end
+
+  Contract String, Or[String, Pathname], Any => Maybe[String]
+  def rewrite_url(asset_path, dirpath, _request_path)
+    uri = ::Middleman::Util.parse_uri(asset_path)
+    relative_path = !uri.path.start_with?('/')
+
+    full_asset_path = if relative_path
+      dirpath.join(asset_path).to_s
+    else
+      asset_path
+    end
+
+    return unless asset_page = app.sitemap.find_resource_by_destination_path(full_asset_path) || app.sitemap.find_resource_by_path(full_asset_path)
+
+    replacement_path = "/#{asset_page.destination_path}"
+    replacement_path = Pathname.new(replacement_path).relative_path_from(dirpath).to_s if relative_path
+
+    replacement_path
+  end
+
+  # Update the main sitemap resource list
+  # @return Array<Middleman::Sitemap::Resource>
+  Contract ResourceList => ResourceList
+  def manipulate_resource_list(resources)
+    @rack_client ||= begin
+      rack_app = ::Middleman::Rack.new(app).to_app
+      ::Rack::MockRequest.new(rack_app)
+    end
+
+    # Process resources in order: binary images and fonts, then SVG, then JS/CSS.
+    # This is so by the time we get around to the text files (which may reference
+    # images and fonts) the static assets' hashes are already calculated.
+    resources.sort_by do |a|
+      if %w(.svg .svgz).include? a.ext
+        0
+      elsif %w(.js .css).include? a.ext
+        1
+      else
+        -1
+      end
+    end.each(&method(:manipulate_single_resource))
+  end
+
+  Contract IsA['Middleman::Sitemap::Resource'] => Maybe[IsA['Middleman::Sitemap::Resource']]
+  def manipulate_single_resource(resource)
+    return unless @exts.include?(resource.ext)
+    return if ignored_resource?(resource)
+    return if resource.ignored?
+
+    digest = if resource.binary?
+      ::Digest::SHA1.file(resource.source_file).hexdigest[0..7]
+    else
+      # Render through the Rack interface so middleware and mounted apps get a shot
+      response = @rack_client.get(
+        ::WEBrick::HTTPUtils.escape(resource.destination_path),
+        'bypass_inline_url_rewriter_asset_hash' => 'true'
+      )
+
+      raise "#{resource.path} should be in the sitemap!" unless response.status == 200
+
+      ::Digest::SHA1.hexdigest(response.body)[0..7]
+    end
+
+    path, basename, extension = split_path(resource.destination_path)
+    resource.destination_path = options.rename_proc.call(path, basename, digest, extension, options)
+    resource
+  end
+
+  Contract IsA['Middleman::Sitemap::Resource'] => Bool
+  def ignored_resource?(resource)
+    @ignore.any? do |ignore|
+      Middleman::Util.path_match(ignore, resource.destination_path)
+    end
+  end
+
+  private
+
+  # Splits resource path into path, basename and extension
+  # (e.g. "/images/landscape.png" => ["/images/", "landscape", ".png]
+  def split_path(filepath)
+    basename = File.basename(filepath, extension = File.extname(filepath))
+    path = filepath.chomp(basename + extension)
+    [path, basename, extension]
+  end
+end

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

@@ -0,0 +1,41 @@
+require 'addressable/uri'
+
+class Middleman::Extensions::AssetHost < ::Middleman::Extension
+  option :host, nil, 'The asset host to use or a Proc to determine asset host', required: true
+  option :exts, nil, 'List of extensions that get cache busters strings appended to them.'
+  option :sources, %w(.css .htm .html .js .php .xhtml), 'List of extensions that are searched for bustable assets.'
+  option :ignore, [], 'Regexes of filenames to skip adding query strings to'
+  option :rewrite_ignore, [], 'Regexes of filenames to skip processing for host rewrites'
+
+  def initialize(app, options_hash={}, &block)
+    super
+
+    app.rewrite_inline_urls id: :asset_host,
+                            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
+
+  Contract String, Or[String, Pathname], Any => String
+  def rewrite_url(asset_path, dirpath, _request_path)
+    uri = ::Middleman::Util.parse_uri(asset_path)
+    relative_path = uri.path[0..0] != '/'
+
+    full_asset_path = if relative_path
+      dirpath.join(asset_path).to_s
+    else
+      asset_path
+    end
+
+    asset_prefix = if options[:host].is_a?(Proc)
+      options[:host].call(full_asset_path)
+    elsif options[:host].is_a?(String)
+      options[:host]
+    end
+
+    File.join(asset_prefix, full_asset_path)
+  end
+  memoize :rewrite_url
+end

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

@@ -8,13 +8,14 @@ class Middleman::Extensions::AutomaticAltTags < ::Middleman::Extension
       unless path.include?('://')
         params[:alt] ||= ''
 
-        real_path = path
-        real_path = File.join(images_dir, real_path) unless real_path.start_with?('/')
-        full_path = File.join(source_dir, real_path)
+        real_path = path.dup
+        real_path = File.join(config[:images_dir], real_path) unless real_path.start_with?('/')
 
-        if File.exist?(full_path)
+        file = app.files.find(:source, real_path)
+
+        if file && file[:full_path].exist?
           begin
-            alt_text = File.basename(full_path, '.*')
+            alt_text = File.basename(file[:full_path].to_s, '.*')
             alt_text.capitalize!
             params[:alt] = alt_text
           end

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

@@ -4,7 +4,7 @@ class Middleman::Extensions::AutomaticImageSizes < ::Middleman::Extension
     super
 
     # Include 3rd-party fastimage library
-    require 'vendored-middleman-deps/fastimage'
+    require 'fastimage'
   end
 
   helpers do
@@ -16,13 +16,22 @@ class Middleman::Extensions::AutomaticImageSizes < ::Middleman::Extension
     # @return [String]
     def image_tag(path, params={})
       if !params.key?(:width) && !params.key?(:height) && !path.include?('://')
-        real_path = path
-        real_path = File.join(images_dir, real_path) unless real_path.start_with?('/')
-        full_path = File.join(source_dir, real_path)
+        real_path = path.dup
+        real_path = File.join(config[:images_dir], real_path) unless real_path.start_with?('/')
 
-        if File.exist?(full_path)
+        file = app.files.find(:source, real_path) || app.files.find(:source, real_path.sub(/^\//, ''))
+
+        if file && file[:full_path].exist?
           begin
+            full_path = file[:full_path].to_s
             width, height = ::FastImage.size(full_path, raise_on_failure: true)
+            # Check for @2x and @3x image
+            retina = full_path.match(/@(\d)x\.[a-zA-Z]{3,4}$/)
+            if retina
+              factor = retina[1].to_i
+              width /= factor
+              height /= factor
+            end
             params[:width]  = width
             params[:height] = height
           rescue FastImage::UnknownImageType

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

@@ -0,0 +1,23 @@
+# The Cache Buster extension
+class Middleman::Extensions::CacheBuster < ::Middleman::Extension
+  option :exts, nil, 'List of extensions that get cache busters strings appended to them.'
+  option :sources, %w(.css .htm .html .js .php .xhtml), 'List of extensions that are searched for bustable assets.'
+  option :ignore, [], 'Regexes of filenames to skip adding query strings to'
+  option :rewrite_ignore, [], 'Regexes of filenames to skip processing for path rewrites'
+
+  def initialize(app, options_hash={}, &block)
+    super
+
+    app.rewrite_inline_urls id: :cache_buster,
+                            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
+
+  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-core/extensions/directory_indexes.rb

@@ -0,0 +1,32 @@
+# 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 Array<Middleman::Sitemap::Resource>
+  Contract ResourceList => ResourceList
+  def manipulate_resource_list(resources)
+    index_file = app.config[:index_file]
+    new_index_path = "/#{index_file}"
+
+    extensions = %w(.htm .html .php .xhtml)
+
+    resources.each do |resource|
+      # Check if it would be pointless to reroute
+      next if resource.destination_path == index_file ||
+              resource.destination_path.end_with?(new_index_path) ||
+              !extensions.include?(resource.ext)
+
+      # Check if file metadata (options set by "page" in config.rb or frontmatter) turns directory_index off
+      next if resource.options[:directory_index] == false
+
+      extensions.each do |ext|
+        resource.destination_path = resource.destination_path.chomp(ext)
+      end
+
+      resource.destination_path += new_index_path
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+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'
+  option :disable_background_execution, false, "Don't run the command in a separate background thread"
+
+  def initialize(app, config={}, &block)
+    super
+
+    return if app.mode?(:config)
+
+    require 'servolux'
+    require 'thread'
+    require 'fileutils'
+
+    source_path = File.expand_path(options[:source], app.root)
+
+    # Make sure it exists, or `listen` will explode.
+    ::FileUtils.mkdir_p(source_path)
+
+    @watcher = app.files.watch :source,
+                               path: source_path,
+                               latency: options[:latency],
+                               frontmatter: false
+
+    @current_thread = nil
+    app.reload(&method(:reload!))
+
+    logger.info "== Executing: `#{options[:command]}`"
+
+    if app.build? || options[:disable_background_execution]
+      watch_command!(false)
+
+      @watcher.poll_once!
+    else
+      watch_command!(true)
+    end
+  end
+
+  def reload!
+    if @current_thread
+      logger.info "== Stopping: `#{options[:command]}`"
+
+      @current_thread.stop
+      @current_thread = nil
+    end
+  end
+
+  def watch_command!(async)
+    @current_thread = ::Servolux::Child.new(
+      command: options[:command],
+      suspend: 2
+    )
+
+    @current_thread.start
+
+    watch_thread = Thread.new do
+      while buf = @current_thread.io.gets
+        without_newline = buf.sub(/\n$/, '')
+        logger.info "== External: #{without_newline}" unless without_newline.empty?
+      end
+
+      @current_thread.wait
+
+      if !@current_thread.exitstatus.nil? && @current_thread.exitstatus != 0
+        logger.error '== External: Command failed with non-zero exit status'
+        exit(1)
+      end
+    end
+
+    watch_thread.join unless async
+  rescue ::Errno::ENOENT => e
+    logger.error "== External: Command failed with message: #{e.message}"
+    exit(1)
+  end
+
+  private
+
+  def print_command(stdout)
+    while buf = stdout.gets
+      without_newline = buf.sub(/\n$/, '')
+      logger.info "== External: #{without_newline}" unless without_newline.empty?
+    end
+  end
+end

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

@@ -7,11 +7,16 @@
 # 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 .html, .htm, .js and .css.
+# to .css, .htm, .html, .js, and .xhtml
 #
 class Middleman::Extensions::Gzip < ::Middleman::Extension
-  option :exts, %w(.js .css .html .htm), 'File extensions to Gzip when building.'
+  option :exts, %w(.css .htm .html .js .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.'
+
+  class NumberHelpers
+    include ::Padrino::Helpers::NumberHelpers
+  end
 
   def initialize(app, options_hash={})
     super
@@ -24,7 +29,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,20 +64,21 @@ 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 :created, "#{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'
+    output_filename = options.overwrite ? path : path + '.gz'
     input_file_time = File.mtime(path)
 
     # Check if the right file's already there
-    if File.exist?(output_filename) && File.mtime(output_filename) == input_file_time
+    if !options.overwrite && File.exist?(output_filename) && File.mtime(output_filename) == input_file_time
       return [nil, nil, nil]
     end
 
@@ -100,7 +106,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

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

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

@@ -1,22 +1,21 @@
+require 'active_support/core_ext/object/try'
+require 'memoist'
+require 'middleman-core/contracts'
+require 'sassc'
+
 # Minify CSS Extension
 class Middleman::Extensions::MinifyCss < ::Middleman::Extension
-  option :compressor, nil, 'Set the CSS compressor to use.'
   option :inline, false, 'Whether to minify CSS inline within HTML files'
   option :ignore, [], 'Patterns to avoid minifying'
+  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'
 
-  def initialize(app, options_hash={}, &block)
-    super
-
-    app.config.define_setting :css_compressor, nil, 'Set the CSS compressor to use. Deprecated in favor of the :compressor option when activating :minify_css'
-  end
-
-  def after_configuration
-    chosen_compressor = app.config[:css_compressor] || options[:compressor] || SassCompressor
-
+  def ready
     # Setup Rack middleware to minify CSS
-    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],
@@ -24,25 +23,37 @@ class Middleman::Extensions::MinifyCss < ::Middleman::Extension
   end
 
   class SassCompressor
+    COMPRESSED_OPTIONS = { style: :compressed }.freeze
+
     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
+      options = options.merge(COMPRESSED_OPTIONS)
+
+      ::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
-      @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
@@ -63,7 +74,7 @@ class Middleman::Extensions::MinifyCss < ::Middleman::Extension
       end
 
       if minified
-        headers['Content-Length'] = ::Rack::Utils.bytesize(minified).to_s
+        headers['Content-Length'] = minified.bytesize.to_s
         response = [minified]
       end
 
@@ -76,8 +87,9 @@ class Middleman::Extensions::MinifyCss < ::Middleman::Extension
     # @param [String] path
     # @return [Boolean]
     def ignore?(path)
-      @ignore.any? { |ignore| Middleman::Util.path_match(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
@@ -85,6 +97,7 @@ class Middleman::Extensions::MinifyCss < ::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
@@ -92,6 +105,7 @@ class Middleman::Extensions::MinifyCss < ::Middleman::Extension
     def minifiable_inline?(content_type)
       @inline_content_types.include?(content_type)
     end
+    memoize :minifiable_inline?
 
     # Minify the content
     # @param [String] content
@@ -99,6 +113,7 @@ class Middleman::Extensions::MinifyCss < ::Middleman::Extension
     def minify(content)
       @compressor.compress(content)
     end
+    memoize :minify
 
     # Detect and minify inline content
     # @param [String] content
@@ -108,5 +123,6 @@ class Middleman::Extensions::MinifyCss < ::Middleman::Extension
         $1 + minify($2) + $3
       end
     end
+    memoize :minify_inline
   end
 end