middleman-core 4.1.0.rc.1 → 4.1.0.rc.2

data/lib/middleman-core/callback_manager.rb

@@ -48,8 +48,15 @@ module Middleman
 
     Contract Or[Symbol, ArrayOf[Symbol]], Maybe[ArrayOf[Any]], Maybe[RespondTo[:instance_exec]] => Any
     def execute(keys, args=[], scope=self)
-      callbacks_for(keys).each { |b| scope.instance_exec(*args, &b) }
+      callbacks = callbacks_for(keys)
+      callbacks_count = callbacks.length + @subscribers.length
+
+      return if callbacks_count < 1
+
+      # ::Middleman::Util.instrument "callbacks.execute", keys: keys, length: callbacks_count do
+      callbacks.each { |b| scope.instance_exec(*args, &b) }
       @subscribers.each { |b| scope.instance_exec(keys, args, &b) }
+      # end
     end
 
     Contract Or[Symbol, ArrayOf[Symbol]] => ::Hamster::Vector

data/lib/middleman-core/contracts.rb

@@ -1,112 +1,23 @@
-if ENV['TEST'] || ENV['CONTRACTS'] == 'true'
-  require 'contracts'
-  require 'hamster'
+require 'contracts'
+require 'hamster'
 
-  module Contracts
-    class IsA
-      def self.[](val)
-        @lookup ||= {}
-        @lookup[val] ||= new(val)
-      end
-
-      def initialize(val)
-        @val = val
-      end
-
-      def valid?(val)
-        val.is_a? @val.constantize
-      end
-    end
-
-    VectorOf = Contracts::CollectionOf::Factory.new(::Hamster::Vector)
-    ResourceList = Contracts::ArrayOf[IsA['Middleman::Sitemap::Resource']]
-  end
-else
-  module Contracts
-    def self.included(base)
-      base.extend self
-    end
-
-    # rubocop:disable MethodName
-    def Contract(*)
-    end
-
-    class Callable
-      def self.[](*)
-      end
-    end
-
-    class Bool
-    end
-
-    class Num
-    end
-
-    class Pos
-    end
-
-    class Neg
-    end
-
-    class Any
-    end
-
-    class None
-    end
-
-    class Or < Callable
-    end
-
-    class Xor < Callable
-    end
-
-    class And < Callable
-    end
-
-    class Not < Callable
-    end
-
-    class RespondTo < Callable
-    end
-
-    class Send < Callable
-    end
-
-    class Exactly < Callable
-    end
-
-    class ArrayOf < Callable
-    end
-
-    class ResourceList < Callable
-    end
-
-    class Args < Callable
-    end
-
-    class HashOf < Callable
-    end
-
-    class Bool
-    end
-
-    class Maybe < Callable
-    end
-
-    class IsA < Callable
-    end
-
-    class SetOf < Callable
+module Contracts
+  class IsA
+    def self.[](val)
+      @lookup ||= {}
+      @lookup[val] ||= new(val)
     end
 
-    class Frozen < Callable
+    def initialize(val)
+      @val = val
     end
 
-    class VectorOf < Callable
+    def valid?(val)
+      val.is_a? @val.constantize
     end
   end
-end
 
-module Contracts
+  VectorOf = ::Contracts::CollectionOf::Factory.new(::Hamster::Vector)
+  ResourceList = ::Contracts::ArrayOf[IsA['Middleman::Sitemap::Resource']]
   PATH_MATCHER = Or[String, RespondTo[:match], RespondTo[:call], RespondTo[:to_s]]
 end

data/lib/middleman-core/core_extensions.rb

@@ -19,6 +19,12 @@ Middleman::Extensions.register :data, auto_activate: :before_sitemap do
   Middleman::CoreExtensions::Data
 end
 
+# Rewrite embedded URLs via Rack
+Middleman::Extensions.register :inline_url_rewriter, auto_activate: :before_sitemap do
+  require 'middleman-core/core_extensions/inline_url_rewriter'
+  Middleman::CoreExtensions::InlineURLRewriter
+end
+
 # Catch and show exceptions at the Rack level
 Middleman::Extensions.register :show_exceptions, auto_activate: :before_configuration, modes: [:server] do
   require 'middleman-core/core_extensions/show_exceptions'

data/lib/middleman-core/core_extensions/collections/lazy_step.rb

@@ -2,7 +2,7 @@ module Middleman
   module CoreExtensions
     module Collections
       class LazyCollectorStep < BasicObject
-        DELEGATE = [:hash, :eql?]
+        DELEGATE = [:hash, :eql?].freeze
 
         def initialize(name, args, block, parent=nil)
           @name = name

data/lib/middleman-core/core_extensions/data.rb

@@ -8,6 +8,8 @@ module Middleman
     class Data < Extension
       attr_reader :data_store
 
+      define_setting :data_dir, 'data', 'The directory data files are stored in'
+
       # Make the internal `data_store` method available as `app.data`
       expose_to_application data: :data_store
 
@@ -21,7 +23,6 @@ module Middleman
         super
 
         @data_store = DataStore.new(app, DATA_FILE_MATCHER)
-        app.config.define_setting :data_dir, 'data', 'The directory data files are stored in'
 
         start_watching(app.config[:data_dir])
       end
@@ -188,7 +189,7 @@ module Middleman
           (@local_data.keys + @local_sources.keys + @callback_sources.keys).include?(key.to_s)
         end
 
-        alias_method :has_key?, :key?
+        alias has_key? key?
 
         # Convert all the data into a static hash
         #

data/lib/middleman-core/core_extensions/default_helpers.rb

@@ -9,7 +9,7 @@ class Padrino::Helpers::OutputHelpers::ErbHandler
   def capture_from_template(*args, &block)
     self.output_buffer = ''
     buf_was = output_buffer
-    raw = block.call(*args)
+    raw = yield(*args)
     captured = template.instance_variable_get(:@_out_buf)
     self.output_buffer = buf_was
     engine_matches?(block) && !captured.empty? ? captured : raw
@@ -17,6 +17,8 @@ class Padrino::Helpers::OutputHelpers::ErbHandler
 end
 
 class Middleman::CoreExtensions::DefaultHelpers < ::Middleman::Extension
+  define_setting :relative_links, false, 'Whether to generate relative links instead of absolute ones'
+
   def initialize(app, options_hash={}, &block)
     super
 
@@ -30,8 +32,6 @@ class Middleman::CoreExtensions::DefaultHelpers < ::Middleman::Extension
     ::Middleman::TemplateContext.send :include, ::Padrino::Helpers::RenderHelpers
     ::Middleman::TemplateContext.send :include, ::Padrino::Helpers::NumberHelpers
     # ::Middleman::TemplateContext.send :include, ::Padrino::Helpers::TranslationHelpers
-
-    app.config.define_setting :relative_links, false, 'Whether to generate relative links instead of absolute ones'
   end
 
   # The helpers
@@ -55,7 +55,7 @@ class Middleman::CoreExtensions::DefaultHelpers < ::Middleman::Extension
           output.safe_concat ::Padrino::Helpers::TagHelpers::NEWLINE
         end
       else
-        output.safe_concat "#{content}"
+        output.safe_concat content.to_s
       end
       output.safe_concat "</#{name}>"
 
@@ -66,7 +66,7 @@ class Middleman::CoreExtensions::DefaultHelpers < ::Middleman::Extension
       result = if handler = auto_find_proper_handler(&block)
         handler.capture_from_template(*args, &block)
       else
-        block.call(*args)
+        yield(*args)
       end
 
       ::ActiveSupport::SafeBuffer.new.safe_concat(result)

data/lib/middleman-core/core_extensions/external_helpers.rb

@@ -2,17 +2,12 @@ module Middleman
   module CoreExtensions
     # Load helpers in `helpers/`
     class ExternalHelpers < Extension
-      def initialize(app, options_hash={}, &block)
-        super
-
-        # Setup a default helpers paths
-        app.config.define_setting :helpers_dir, 'helpers', 'Directory to autoload helper modules from'
-        app.config.define_setting :helpers_filename_glob, '**.rb', 'Glob pattern for matching helper ruby files'
-        app.config.define_setting :helpers_filename_to_module_name_proc, proc { |filename|
-          basename = File.basename(filename, File.extname(filename))
-          basename.camelcase
-        }, 'Proc implementing the conversion from helper filename to module name'
-      end
+      define_setting :helpers_dir, 'helpers', 'Directory to autoload helper modules from'
+      define_setting :helpers_filename_glob, '**.rb', 'Glob pattern for matching helper ruby files'
+      define_setting :helpers_filename_to_module_name_proc, proc { |filename|
+        basename = File.basename(filename, File.extname(filename))
+        basename.camelcase
+      }, 'Proc implementing the conversion from helper filename to module name'
 
       def after_configuration
         helpers_path = File.join(app.root, app.config[:helpers_dir])

data/lib/middleman-core/core_extensions/file_watcher.rb

@@ -21,7 +21,7 @@ module Middleman
         tilde_files: /~$/,
         ds_store: /\.DS_Store$/,
         git: /(^|\/)\.git(ignore|modules|\/)/
-      }
+      }.freeze
 
       # Setup the extension.
       def initialize(app, config={}, &block)

data/lib/middleman-core/core_extensions/front_matter.rb

@@ -28,6 +28,7 @@ module Middleman::CoreExtensions
     Contract ResourceList => ResourceList
     def manipulate_resource_list(resources)
       resources.each do |resource|
+        next if resource.binary?
         next if resource.ignored?
         next if resource.file_descriptor.nil?
 

data/lib/middleman-core/core_extensions/i18n.rb

@@ -127,7 +127,7 @@ class Middleman::CoreExtensions::Internationalization < ::Middleman::Extension
   end
 
   # Backwards API compat
-  alias_method :langs, :locales
+  alias langs locales
 
   Contract Symbol
   def locale
@@ -135,7 +135,7 @@ class Middleman::CoreExtensions::Internationalization < ::Middleman::Extension
   end
 
   # Backwards API compat
-  alias_method :lang, :locale
+  alias lang locale
 
   # Update the main sitemap resource list
   # @return Array<Middleman::Sitemap::Resource>
@@ -190,7 +190,7 @@ class Middleman::CoreExtensions::Internationalization < ::Middleman::Extension
     end
   end
 
-  Contract String, Symbol => String
+  Contract String, Symbol => Maybe[String]
   def localized_path(path, locale)
     lookup_path = path.dup
     lookup_path << app.config[:index_file] if lookup_path.end_with?('/')
@@ -274,7 +274,7 @@ class Middleman::CoreExtensions::Internationalization < ::Middleman::Extension
 
     File.dirname(path).split('/').each do |path_sub|
       next if path_sub == ''
-      partially_localized_path = "#{partially_localized_path}/#{(::I18n.t("paths.#{path_sub}", default: path_sub).to_s)}"
+      partially_localized_path = "#{partially_localized_path}/#{::I18n.t("paths.#{path_sub}", default: path_sub)}"
     end
 
     path = "#{partially_localized_path}/#{File.basename(path)}"

data/lib/middleman-core/core_extensions/inline_url_rewriter.rb

@@ -0,0 +1,150 @@
+require 'rack'
+require 'rack/response'
+require 'addressable/uri'
+require 'middleman-core/util'
+require 'middleman-core/contracts'
+
+module Middleman
+  module CoreExtensions
+    class InlineURLRewriter < ::Middleman::Extension
+      include Contracts
+
+      expose_to_application rewrite_inline_urls: :add
+
+      IGNORE_DESCRIPTOR = Or[Regexp, RespondTo[:call], String]
+      REWRITER_DESCRIPTOR = {
+        id: Symbol,
+        proc: Or[Proc, Method],
+        url_extensions: ArrayOf[String],
+        source_extensions: ArrayOf[String],
+        ignore: ArrayOf[IGNORE_DESCRIPTOR],
+        after: Maybe[Symbol]
+      }.freeze
+
+      def initialize(app, options_hash={}, &block)
+        super
+
+        @rewriters = {}
+      end
+
+      Contract REWRITER_DESCRIPTOR => Any
+      def add(options)
+        @rewriters[options] = options
+      end
+
+      def after_configuration
+        rewriters = @rewriters.values.sort do |a, b|
+          if b[:after] && b[:after] == a[:id]
+            1
+          else
+            0
+          end
+        end
+
+        app.use Rack, rewriters: rewriters, middleman_app: @app
+      end
+
+      class Rack
+        include Contracts
+
+        Contract RespondTo[:call], {
+          middleman_app: IsA['Middleman::Application'],
+          rewriters: ArrayOf[REWRITER_DESCRIPTOR]
+        } => Any
+        def initialize(app, options={})
+          @rack_app = app
+          @middleman_app = options.fetch(:middleman_app)
+          @rewriters = options.fetch(:rewriters)
+        end
+
+        def call(env)
+          status, headers, response = @rack_app.call(env)
+
+          # Allow configuration or upstream request to skip all rewriting
+          return [status, headers, response] if env['bypass_inline_url_rewriter'] == 'true'
+
+          all_source_exts = @rewriters
+                            .reduce([]) { |sum, rewriter| sum + rewriter[:source_extensions] }
+                            .flatten
+                            .uniq
+          source_exts_regex_text = Regexp.union(all_source_exts).to_s
+
+          all_asset_exts = @rewriters
+                           .reduce([]) { |sum, rewriter| sum + rewriter[:url_extensions] }
+                           .flatten
+                           .uniq
+
+          path = ::Middleman::Util.full_path(env['PATH_INFO'], @middleman_app)
+
+          return [status, headers, response] unless path =~ /(^\/$)|(#{source_exts_regex_text}$)/
+          return [status, headers, response] unless body = ::Middleman::Util.extract_response_text(response)
+
+          dirpath = ::Pathname.new(File.dirname(path))
+
+          rewritten = ::Middleman::Util.instrument 'inline_url_rewriter', path: path do
+            ::Middleman::Util.rewrite_paths(body, path, all_asset_exts) do |asset_path|
+              uri = ::Addressable::URI.parse(asset_path)
+
+              relative_path = uri.host.nil?
+
+              full_asset_path = if relative_path
+                dirpath.join(asset_path).to_s
+              else
+                asset_path
+              end
+
+              @rewriters.each do |rewriter|
+                uid = rewriter.fetch(:id)
+
+                # Allow upstream request to skip this specific rewriting
+                next if env["bypass_inline_url_rewriter_#{uid}"] == 'true'
+
+                exts = rewriter.fetch(:url_extensions)
+                next unless exts.include?(::File.extname(asset_path))
+
+                source_exts = rewriter.fetch(:source_extensions)
+                next unless source_exts.include?(::File.extname(path))
+
+                ignore = rewriter.fetch(:ignore)
+                next if ignore.any? { |r| should_ignore?(r, full_asset_path) }
+
+                rewrite_ignore = Array(rewriter.fetch(:rewrite_ignore, []))
+                next if rewrite_ignore.any? { |i| ::Middleman::Util.path_match(i, path) }
+
+                proc = rewriter.fetch(:proc)
+
+                result = proc.call(asset_path, dirpath, path)
+                asset_path = result if result
+              end
+
+              asset_path
+            end
+          end
+
+          ::Rack::Response.new(
+            rewritten,
+            status,
+            headers
+          ).finish
+        end
+
+        Contract IGNORE_DESCRIPTOR, String => Bool
+        def should_ignore?(validator, value)
+          if validator.is_a? Regexp
+            # Treat as Regexp
+            !value.match(validator).nil?
+          elsif validator.respond_to? :call
+            # Treat as proc
+            validator.call(value)
+          elsif validator.is_a? String
+            # Treat as glob
+            File.fnmatch(value, validator)
+          else
+            # If some unknown thing, don't ignore
+            false
+          end
+        end
+      end
+    end
+  end
+end