middleman-core 3.3.12 → 4.4.2

data/lib/middleman-core/util/rack.rb

@@ -0,0 +1,62 @@
+require 'middleman-core/contracts'
+
+module Middleman
+  module Util
+    include Contracts
+
+    module_function
+
+    # Extract the text of a Rack response as a string.
+    # Useful for extensions implemented as Rack middleware.
+    # @param response The response from #call
+    # @return [String] The whole response as a string.
+    Contract RespondTo[:each] => String
+    def extract_response_text(response)
+      # The rack spec states all response bodies must respond to each
+      result = ''
+      response.each do |part, _|
+        result << part
+      end
+      result
+    end
+
+    Contract String, String, ArrayOf[String], IsA['::Middleman::Application'], Proc => String
+    def rewrite_paths(body, path, exts, app, &_block)
+      matcher = /([\'\"\(,]\s*|# sourceMappingURL=)([^\s\'\"\)\(>]+(#{::Regexp.union(exts)}))/
+
+      url_fn_prefix = 'url('
+
+      body.dup.gsub(matcher) do |match|
+        opening_character = $1
+        asset_path = $2
+
+        if asset_path.start_with?(url_fn_prefix)
+          opening_character << url_fn_prefix
+          asset_path = asset_path[url_fn_prefix.length..-1]
+        end
+
+        current_resource = app.sitemap.find_resource_by_destination_path(path)
+
+        begin
+          uri = ::Middleman::Util.parse_uri(asset_path)
+
+          if uri.relative? && uri.host.nil? && !(asset_path =~ /^[^\/].*[a-z]+\.[a-z]+\/.*/)
+            dest_path = ::Middleman::Util.url_for(app, asset_path, relative: false, current_resource: current_resource)
+
+            resource = app.sitemap.find_resource_by_destination_path(dest_path)
+
+            if resource && (result = yield(asset_path))
+              "#{opening_character}#{result}"
+            else
+              match
+            end
+          else
+            match
+          end
+        rescue ::Addressable::URI::InvalidURIError
+          match
+        end
+      end
+    end
+  end
+end

data/lib/middleman-core/util/uri_templates.rb

@@ -0,0 +1,97 @@
+# For URI templating
+require 'addressable/uri'
+require 'addressable/template'
+require 'active_support/inflector'
+require 'active_support/inflector/transliterate'
+
+module Middleman
+  module Util
+    # Handy methods for dealing with URI templates. Mix into whatever class.
+    module UriTemplates
+      module_function
+
+      # Given a URI template string, make an Addressable::Template
+      # This supports the legacy middleman-blog/Sinatra style :colon
+      # URI templates as well as RFC6570 templates.
+      #
+      # @param [String] tmpl_src URI template source
+      # @return [Addressable::Template] a URI template
+      def uri_template(tmpl_src)
+        # Support the RFC6470 templates directly if people use them
+        if tmpl_src.include?(':')
+          tmpl_src = tmpl_src.gsub(/:([A-Za-z0-9]+)/, '{\1}')
+        end
+
+        ::Addressable::Template.new(::Middleman::Util.normalize_path(tmpl_src))
+      end
+
+      # Apply a URI template with the given data, producing a normalized
+      # Middleman path.
+      #
+      # @param [Addressable::Template] template
+      # @param [Hash] data
+      # @return [String] normalized path
+      def apply_uri_template(template, data)
+        ::Middleman::Util.normalize_path(::Addressable::URI.unencode(template.expand(data)).to_s)
+      end
+
+      # Use a template to extract parameters from a path, and validate some special (date)
+      # keys. Returns nil if the special keys don't match.
+      #
+      # @param [Addressable::Template] template
+      # @param [String] path
+      def extract_params(template, path)
+        template.extract(path, BlogTemplateProcessor)
+      end
+
+      # Parameterize a string preserving any multibyte characters
+      def safe_parameterize(str)
+        sep = '-'
+
+        # Reimplementation of http://api.rubyonrails.org/classes/ActiveSupport/Inflector.html#method-i-parameterize that preserves un-transliterate-able multibyte chars.
+        parameterized_string = ::ActiveSupport::Inflector.transliterate(str.to_s).downcase
+        parameterized_string.gsub!(/[^a-z0-9\-_\?]+/, sep)
+
+        parameterized_string.chars.to_a.each_with_index do |char, i|
+          next unless char == '?' && str[i].bytes.count != 1
+          parameterized_string[i] = str[i]
+        end
+
+        re_sep = ::Regexp.escape(sep)
+        # No more than one of the separator in a row.
+        parameterized_string.gsub!(/#{re_sep}{2,}/, sep)
+        # Remove leading/trailing separator.
+        parameterized_string.gsub!(/^#{re_sep}|#{re_sep}$/, '')
+
+        parameterized_string
+      end
+
+      # Convert a date into a hash of components to strings
+      # suitable for using in a URL template.
+      # @param [DateTime] date
+      # @return [Hash] parameters
+      def date_to_params(date)
+        {
+          year: date.year.to_s,
+          month: date.month.to_s.rjust(2, '0'),
+          day: date.day.to_s.rjust(2, '0')
+        }
+      end
+    end
+
+    # A special template processor that validates date fields
+    # and has an extra-permissive default regex.
+    #
+    # See https://github.com/sporkmonger/addressable/blob/master/lib/addressable/template.rb#L279
+    class BlogTemplateProcessor
+      def self.match(name)
+        case name
+        when 'year' then '\d{4}'
+        when 'month' then '\d{2}'
+        when 'day' then '\d{2}'
+        else '.*?'
+        end
+      end
+    end
+  end
+end

data/lib/middleman-core/util.rb

@@ -1,286 +1,24 @@
 # For instrumenting
 require 'active_support/notifications'
 
-# Using Thor's indifferent hash access
-require 'thor'
-
-# Core Pathname library used for traversal
-require 'pathname'
-
-# Template and Mime detection
-require 'tilt'
-require 'rack/mime'
+require 'middleman-core/application'
+require 'middleman-core/sources'
+require 'middleman-core/sitemap/resource'
+require 'middleman-core/util/binary'
+require 'middleman-core/util/data'
+require 'middleman-core/util/files'
+require 'middleman-core/util/paths'
+require 'middleman-core/util/rack'
+require 'middleman-core/util/uri_templates'
 
 module Middleman
   module Util
-    class << self
-      # Whether the source file is binary.
-      #
-      # @param [String] filename The file to check.
-      # @return [Boolean]
-      def binary?(filename)
-        ext = File.extname(filename)
-
-        # We hardcode detecting of gzipped SVG files
-        return true if ext == '.svgz'
-
-        return false if Tilt.registered?(ext.sub('.', ''))
-
-        dot_ext = (ext.to_s[0] == '.') ? ext.dup : ".#{ext}"
-
-        if mime = ::Rack::Mime.mime_type(dot_ext, nil)
-          !nonbinary_mime?(mime)
-        else
-          file_contents_include_binary_bytes?(filename)
-        end
-      end
-
-      # Facade for ActiveSupport/Notification
-      def instrument(name, payload={}, &block)
-        suffixed_name = (name =~ /\.middleman$/) ? name.dup : "#{name}.middleman"
-        ::ActiveSupport::Notifications.instrument(suffixed_name, payload, &block)
-      end
-
-      # Recursively convert a normal Hash into a HashWithIndifferentAccess
-      #
-      # @private
-      # @param [Hash] data Normal hash
-      # @return [Thor::CoreExt::HashWithIndifferentAccess]
-      def recursively_enhance(data)
-        if data.is_a? Hash
-          data = ::Thor::CoreExt::HashWithIndifferentAccess.new(data)
-          data.each do |key, val|
-            data[key] = recursively_enhance(val)
-          end
-          data
-        elsif data.is_a? Array
-          data.each_with_index do |val, i|
-            data[i] = recursively_enhance(val)
-          end
-          data
-        else
-          data
-        end
-      end
-
-      # Normalize a path to not include a leading slash
-      # @param [String] path
-      # @return [String]
-      def normalize_path(path)
-        # The tr call works around a bug in Ruby's Unicode handling
-        URI.decode(path).sub(%r{^/}, '').tr('', '')
-      end
-
-      # This is a separate method from normalize_path in case we
-      # change how we normalize paths
-      def strip_leading_slash(path)
-        path.sub(%r{^/}, '')
-      end
-
-      # Extract the text of a Rack response as a string.
-      # Useful for extensions implemented as Rack middleware.
-      # @param response The response from #call
-      # @return [String] The whole response as a string.
-      def extract_response_text(response)
-        # The rack spec states all response bodies must respond to each
-        result = ''
-        response.each do |part, _|
-          result << part
-        end
-        result
-      end
-
-      # Takes a matcher, which can be a literal string
-      # or a string containing glob expressions, or a
-      # regexp, or a proc, or anything else that responds
-      # to #match or #call, and returns whether or not the
-      # given path matches that matcher.
-      #
-      # @param matcher A matcher string/regexp/proc/etc
-      # @param path A path as a string
-      # @return [Boolean] Whether the path matches the matcher
-      def path_match(matcher, path)
-        case
-        when matcher.is_a?(String)
-          path.match(matcher)
-        when matcher.respond_to?(:match)
-          matcher.match(path)
-        when matcher.respond_to?(:call)
-          matcher.call(path)
-        else
-          File.fnmatch(matcher.to_s, path)
-        end
-      end
-
-      # Get a recusive list of files inside a path.
-      # Works with symlinks.
-      #
-      # @param path Some path string or Pathname
-      # @param ignore A proc/block that returns true if a given path should be ignored - if a path
-      #               is ignored, nothing below it will be searched either.
-      # @return [Array<Pathname>] An array of Pathnames for each file (no directories)
-      def all_files_under(path, &ignore)
-        path = Pathname(path)
-
-        return [] if ignore && ignore.call(path)
-
-        if path.directory?
-          path.children.flat_map do |child|
-            all_files_under(child, &ignore)
-          end.compact
-        elsif path.file?
-          [path]
-        else
-          []
-        end
-      end
-
-      # Given a source path (referenced either absolutely or relatively)
-      # or a Resource, this will produce the nice URL configured for that
-      # path, respecting :relative_links, directory indexes, etc.
-      def url_for(app, path_or_resource, options={})
-        # Handle Resources and other things which define their own url method
-        url = if path_or_resource.respond_to?(:url)
-          path_or_resource.url
-        else
-          path_or_resource.dup
-        end
-
-        # Try to parse URL
-        begin
-          uri = URI(url)
-        rescue URI::InvalidURIError
-          # Nothing we can do with it, it's not really a URI
-          return url
-        end
-
-        relative = options[:relative]
-        raise "Can't use the relative option with an external URL" if relative && uri.host
-
-        # Allow people to turn on relative paths for all links with
-        # set :relative_links, true
-        # but still override on a case by case basis with the :relative parameter.
-        effective_relative = relative || false
-        effective_relative = true if relative.nil? && app.config[:relative_links]
-
-        # Try to find a sitemap resource corresponding to the desired path
-        this_resource = options[:current_resource]
-
-        if path_or_resource.is_a?(::Middleman::Sitemap::Resource)
-          resource = path_or_resource
-          resource_url = url
-        elsif this_resource && uri.path && !uri.host
-          # Handle relative urls
-          url_path = Pathname(uri.path)
-          current_source_dir = Pathname('/' + this_resource.path).dirname
-          url_path = current_source_dir.join(url_path) if url_path.relative?
-          resource = app.sitemap.find_resource_by_path(url_path.to_s)
-          resource_url = resource.url if resource
-        elsif options[:find_resource] && uri.path && !uri.host
-          resource = app.sitemap.find_resource_by_path(uri.path)
-          resource_url = resource.url if resource
-        end
-
-        if resource
-          uri.path = URI.encode(relative_path_from_resource(this_resource, resource_url, effective_relative))
-        else
-          # If they explicitly asked for relative links but we can't find a resource...
-          raise "No resource exists at #{url}" if relative
-        end
-
-        # Support a :query option that can be a string or hash
-        if query = options[:query]
-          uri.query = query.respond_to?(:to_param) ? query.to_param : query.to_s
-        end
-
-        # Support a :fragment or :anchor option just like Padrino
-        fragment = options[:anchor] || options[:fragment]
-        uri.fragment = fragment.to_s if fragment
-
-        # Finally make the URL back into a string
-        uri.to_s
-      end
-
-      # Expand a path to include the index file if it's a directory
-      #
-      # @param [String] path Request path/
-      # @param [Middleman::Application] app The requesting app.
-      # @return [String] Path with index file if necessary.
-      def full_path(path, app)
-        resource = app.sitemap.find_resource_by_destination_path(path)
-
-        unless resource
-          # Try it with /index.html at the end
-          indexed_path = File.join(path.sub(%r{/$}, ''), app.config[:index_file])
-          resource = app.sitemap.find_resource_by_destination_path(indexed_path)
-        end
-
-        if resource
-          '/' + resource.destination_path
-        else
-          '/' + normalize_path(path)
-        end
-      end
-
-      private
-
-      # Is mime type known to be non-binary?
-      #
-      # @param [String] mime The mimetype to check.
-      # @return [Boolean]
-      def nonbinary_mime?(mime)
-        case
-        when mime.start_with?('text/')
-          true
-        when mime.include?('xml')
-          true
-        when mime.include?('json')
-          true
-        when mime.include?('javascript')
-          true
-        else
-          false
-        end
-      end
-
-      # Read a few bytes from the file and see if they are binary.
-      #
-      # @param [String] filename The file to check.
-      # @return [Boolean]
-      def file_contents_include_binary_bytes?(filename)
-        binary_bytes = [0, 1, 2, 3, 4, 5, 6, 11, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 28, 29, 30, 31]
-        s = File.read(filename, 4096) || ''
-        s.each_byte do |c|
-          return true if binary_bytes.include?(c)
-        end
-
-        false
-      end
-
-      # Get a relative path to a resource.
-      #
-      # @param [Middleman::Sitemap::Resource] curr_resource The resource.
-      # @param [String] resource_url The target url.
-      # @param [Boolean] relative If the path should be relative.
-      # @return [String]
-      def relative_path_from_resource(curr_resource, resource_url, relative)
-        # Switch to the relative path between resource and the given resource
-        # if we've been asked to.
-        if relative && curr_resource
-          # Output urls relative to the destination path, not the source path
-          current_dir = Pathname('/' + curr_resource.destination_path).dirname
-          relative_path = Pathname(resource_url).relative_path_from(current_dir).to_s
-
-          # Put back the trailing slash to avoid unnecessary Apache redirects
-          if resource_url.end_with?('/') && !relative_path.end_with?('/')
-            relative_path << '/'
-          end
+    module_function
 
-          relative_path
-        else
-          resource_url
-        end
-      end
+    # Facade for ActiveSupport/Notification
+    def instrument(name, payload={}, &block)
+      suffixed_name = name =~ /\.middleman$/ ? name.dup : "#{name}.middleman"
+      ::ActiveSupport::Notifications.instrument(suffixed_name, payload, &block)
     end
   end
 end

data/lib/middleman-core/version.rb

@@ -1,5 +1,5 @@
 module Middleman
   # Current Version
   # @return [String]
-  VERSION = '3.3.12' unless const_defined?(:VERSION)
+  VERSION = '4.4.2'.freeze unless const_defined?(:VERSION)
 end

data/lib/middleman-core.rb

@@ -6,9 +6,6 @@ $LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
 
 # Top-level Middleman namespace
 module Middleman
-  # Backwards compatibility namespace
-  module Features; end
-
   autoload :Application, 'middleman-core/application'
 end
 

data/middleman-core.gemspec

@@ -1,43 +1,62 @@
 # -*- encoding: utf-8 -*-
-require File.expand_path("../lib/middleman-core/version", __FILE__)
+$LOAD_PATH.push File.expand_path('../lib', __FILE__)
+require File.expand_path('../lib/middleman-core/version', __FILE__)
 
 Gem::Specification.new do |s|
-  s.name        = "middleman-core"
+  s.name        = 'middleman-core'
   s.version     = Middleman::VERSION
   s.platform    = Gem::Platform::RUBY
-  s.license     = "MIT"
-  s.authors     = ["Thomas Reynolds", "Ben Hollis", "Karl Freeman"]
-  s.email       = ["me@tdreyno.com", "ben@benhollis.net", "karlfreeman@gmail.com"]
-  s.homepage    = "http://middlemanapp.com"
-  s.summary     = "Hand-crafted frontend development"
-  s.description = "A static site generator. Provides dozens of templating languages (Haml, Sass, Compass, Slim, CoffeeScript, and more). Makes minification, compression, cache busting, Yaml data (and more) an easy part of your development cycle."
+  s.license     = 'MIT'
+  s.authors     = ['Thomas Reynolds', 'Ben Hollis', 'Karl Freeman']
+  s.email       = ['me@tdreyno.com', 'ben@benhollis.net', 'karlfreeman@gmail.com']
+  s.homepage    = 'http://middlemanapp.com'
+  s.summary     = 'Hand-crafted frontend development'
+  s.description = 'A static site generator. Provides dozens of templating languages (Haml, Sass, Compass, Slim, CoffeeScript, and more). Makes minification, compression, cache busting, Yaml data (and more) an easy part of your development cycle.'
 
   s.files        = `git ls-files -z`.split("\0")
   s.test_files   = `git ls-files -z -- {fixtures,features}/*`.split("\0")
-  s.executable   = "middleman"
-  s.require_path = "lib"
-  s.required_ruby_version = '>= 1.9.3'
+  s.require_path = 'lib'
+  s.required_ruby_version = '>= 2.5.0'
 
   # Core
-  s.add_dependency("bundler", ["~> 1.1"])
-  s.add_dependency("rack", [">= 1.4.5", "< 2.0"])
-  s.add_dependency("tilt", ["~> 1.4.1", "< 2.0"])
-  s.add_dependency("erubis")
-  s.add_dependency("hooks", ["~> 0.3"])
-
-  # Builder
-  s.add_dependency("rack-test", ["~> 0.6.2"])
-
-  # CLI
-  s.add_dependency("thor", [">= 0.15.2", "< 2.0"])
+  s.add_dependency('bundler', '~> 2.0')
+  s.add_dependency('rack', ['>= 1.4.5', '< 3'])
+  s.add_dependency('tilt', ['~> 2.0.9'])
+  s.add_dependency('erubis')
+  s.add_dependency('fast_blank')
+  s.add_dependency('parallel')
+  s.add_dependency('servolux')
+  s.add_dependency('dotenv')
+  s.add_dependency('toml')
+  s.add_dependency('webrick')
 
   # Helpers
-  s.add_dependency("activesupport", ["~> 4.1.0"])
-  s.add_dependency("padrino-helpers", ["~> 0.12.3"])
+  s.add_dependency('activesupport', ['>= 6.1', '< 7.0'])
+  s.add_dependency('padrino-helpers', ['~> 0.15.0'])
+  s.add_dependency("addressable", ["~> 2.4"])
+  s.add_dependency('memoist', ['~> 0.14'])
 
   # Watcher
-  s.add_dependency("listen", [">= 2.7.9", "< 3.0"])
+  s.add_dependency('listen', ['~> 3.0.0'])
 
   # i18n
-  s.add_dependency("i18n", ["~> 0.7.0"])
+  s.add_dependency('i18n', ['~> 1.6.0'])
+
+  # Automatic Image Sizes
+  s.add_dependency('fastimage', ['~> 2.0'])
+
+  # Sass and Minify CSS
+  s.add_dependency('sassc', ['~> 2.0'])
+
+  # Minify JS
+  s.add_dependency('uglifier', ['~> 3.0'])
+  s.add_dependency('execjs', ['~> 2.0'])
+
+  # Testing
+  s.add_dependency('contracts', ['~> 0.13.0'])
+
+  # Hash stuff
+  s.add_dependency('hashie', ['~> 3.4'])
+  s.add_dependency('hamster', ['~> 3.0'])
+  s.add_dependency('backports', ['~> 3.6'])
 end