middleman-core 4.0.0 → 4.1.0.rc.1

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

@@ -10,7 +10,7 @@
 # to .html, .htm, .js and .css.
 #
 class Middleman::Extensions::Gzip < ::Middleman::Extension
-  option :exts, %w(.js .css .html .htm), 'File extensions to Gzip when building.'
+  option :exts, %w(.js .css .html .htm .svg), 'File extensions to Gzip when building.'
   option :ignore, [], 'Patterns to avoid gzipping'
   option :overwrite, false, 'Overwrite original files instead of adding .gz extension.'
 

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

@@ -5,6 +5,7 @@ class Middleman::Extensions::RelativeAssets < ::Middleman::Extension
   option :exts, %w(.css .png .jpg .jpeg .webp .svg .svgz .js .gif .ttf .otf .woff .woff2 .eot), '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'
+  option :rewrite_ignore, [], 'Regexes of filenames to skip processing for path rewrites'
 
   def initialize(app, options_hash={}, &block)
     super
@@ -18,6 +19,7 @@ class Middleman::Extensions::RelativeAssets < ::Middleman::Extension
             url_extensions: options.exts,
             source_extensions: options.sources,
             ignore: options.ignore,
+            rewrite_ignore: options.rewrite_ignore,
             middleman_app: app,
             proc: method(:rewrite_url)
   end

data/lib/middleman-core/load_paths.rb

@@ -22,7 +22,7 @@ module Middleman
 
     # Set BUNDLE_GEMFILE and run Bundler setup. Raises an exception if there is no Gemfile
     def setup_bundler
-      ENV['BUNDLE_GEMFILE'] ||= findup('Gemfile', ENV['MM_ROOT'])
+      ENV['BUNDLE_GEMFILE'] ||= File.join(findup('Gemfile', ENV['MM_ROOT']), 'Gemfile')
 
       unless File.exist?(ENV['BUNDLE_GEMFILE'])
         ENV['BUNDLE_GEMFILE'] = File.expand_path('../../../../Gemfile', __FILE__)

data/lib/middleman-core/meta_pages/sitemap_resource.rb

@@ -42,7 +42,7 @@ module Middleman
         props['Source File'] = @resource.file_descriptor ? @resource.file_descriptor[:full_path].to_s.sub(/^#{Regexp.escape(ENV['MM_ROOT'] + '/')}/, '') : 'Dynamic'
 
         data = @resource.data
-        props['Data'] = data.inspect unless data.empty?
+        props['Data'] = data.to_hash(symbolize_keys: true).inspect unless data.empty?
 
         options = @resource.options
         props['Options'] = options.inspect unless options.empty?

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

@@ -34,13 +34,16 @@ module Middleman
         @source_exts_regex_text = Regexp.union(@source_exts).to_s
 
         @ignore = options.fetch(:ignore)
+        @rewrite_ignore = Array(options.fetch(:rewrite_ignore, []))
       end
 
       def call(env)
         status, headers, response = @rack_app.call(env)
 
-        # Allow upstream request to skip all rewriting
-        return [status, headers, response] if env['bypass_inline_url_rewriter'] == 'true'
+        # Allow configuration or upstream request to skip all rewriting
+        if rewrite_ignore?(env['PATH_INFO']) || env['bypass_inline_url_rewriter'] == 'true'
+          return [status, headers, response]
+        end
 
         # Allow upstream request to skip this specific rewriting
         if @uid
@@ -96,6 +99,11 @@ module Middleman
           false
         end
       end
+
+      Contract String => Bool
+      def rewrite_ignore?(path)
+        @rewrite_ignore.any? { |ignore| Middleman::Util.path_match(ignore, path) }
+      end
     end
   end
 end

data/lib/middleman-core/sitemap/extensions/ignores.rb

@@ -2,58 +2,56 @@ module Middleman
   module Sitemap
     module Extensions
       # Class to handle managing ignores
-      class Ignores < Extension
+      class Ignores < ConfigExtension
         self.resource_list_manipulator_priority = 0
 
-        # Expose `create_ignore` as `app.ignore`
-        expose_to_application ignore: :create_ignore
-
-        # Expose `create_ignore` to config as `ignore`
         expose_to_config ignore: :create_ignore
 
-        def initialize(app, config={}, &block)
-          super
-
-          # Array of callbacks which can assign ignored
-          @ignored_callbacks = Set.new
-
-          @app.sitemap.define_singleton_method(:ignored?, &method(:ignored?))
-        end
-
         # Ignore a path or add an ignore callback
         # @param [String, Regexp] path Path glob expression, or path regex
-        # @return [void]
-        Contract Maybe[Or[String, Regexp]], Maybe[Proc] => Any
+        # @return [IgnoreDescriptor]
+        Contract Maybe[Or[String, Regexp]], Maybe[Proc] => RespondTo[:execute_descriptor]
         def create_ignore(path=nil, &block)
-          if path.is_a? Regexp
-            @ignored_callbacks << proc { |p| p =~ path }
-          elsif path.is_a? String
-            path_clean = ::Middleman::Util.normalize_path(path)
-            if path_clean.include?('*') # It's a glob
-              if defined? File::FNM_EXTGLOB
-                @ignored_callbacks << proc { |p| File.fnmatch(path_clean, p, File::FNM_EXTGLOB) }
+          @app.sitemap.invalidate_resources_not_ignored_cache!
+          IgnoreDescriptor.new(path, block)
+        end
+
+        IgnoreDescriptor = Struct.new(:path, :block) do
+          def execute_descriptor(_app, resources)
+            resources.map do |r|
+              # Ignore based on the source path (without template extensions)
+              if ignored?(r.path)
+                r.ignore!
               else
-                @ignored_callbacks << proc { |p| File.fnmatch(path_clean, p) }
+                # This allows files to be ignored by their source file name (with template extensions)
+                r.ignore! if !r.is_a?(ProxyResource) && r.file_descriptor && ignored?(r.file_descriptor[:relative_path].to_s)
               end
-            else
-              # Add a specific-path ignore unless that path is already covered
-              return if ignored?(path_clean)
-              @ignored_callbacks << proc { |p| p == path_clean }
+
+              r
             end
-          elsif block_given?
-            @ignored_callbacks << block
           end
 
-          @app.sitemap.invalidate_resources_not_ignored_cache!
-        end
+          def ignored?(match_path)
+            match_path = ::Middleman::Util.normalize_path(match_path)
+
+            if path.is_a? Regexp
+              match_path =~ path
+            elsif path.is_a? String
+              path_clean = ::Middleman::Util.normalize_path(path)
 
-        # Whether a path is ignored
-        # @param [String] path
-        # @return [Boolean]
-        Contract String => Bool
-        def ignored?(path)
-          path_clean = ::Middleman::Util.normalize_path(path)
-          @ignored_callbacks.any? { |b| b.call(path_clean) }
+              if path_clean.include?('*') # It's a glob
+                if defined?(::File::FNM_EXTGLOB)
+                  ::File.fnmatch(path_clean, match_path, ::File::FNM_EXTGLOB)
+                else
+                  ::File.fnmatch(path_clean, match_path)
+                end
+              else
+                match_path == path_clean
+              end
+            elsif block_given?
+              block.call(match_path)
+            end
+          end
         end
       end
     end

data/lib/middleman-core/sitemap/extensions/import.rb

@@ -4,46 +4,45 @@ require 'middleman-core/contracts'
 module Middleman
   module Sitemap
     module Extensions
-      class Import < Extension
+      class Import < ConfigExtension
         self.resource_list_manipulator_priority = 1
 
-        ImportFileDescriptor = Struct.new(:from, :to)
-        ImportPathDescriptor = Struct.new(:from, :renameProc)
-
         # Expose `create_import_file` to config as `import_file`
         expose_to_config import_file: :create_import_file
 
         # Expose `create_import_path` to config as `import_path`
         expose_to_config import_path: :create_import_path
 
-        def initialize(app, config={}, &block)
-          super
-
-          @import_file_configs = Set.new
-          @import_path_configs = Set.new
+        ImportFileDescriptor = Struct.new(:from, :to) do
+          def execute_descriptor(app, resources)
+            resources + [
+              ::Middleman::Sitemap::Resource.new(app.sitemap, to, from)
+            ]
+          end
         end
 
-        def after_configuration
-          ::Middleman::CoreExtensions::Collections::StepContext.add_to_context(:import_file, &method(:create_import_file))
-          ::Middleman::CoreExtensions::Collections::StepContext.add_to_context(:import_path, &method(:create_import_path))
-        end
+        ImportPathDescriptor = Struct.new(:from, :renameProc) do
+          def execute_descriptor(app, resources)
+            resources + ::Middleman::Util.glob_directory(File.join(from, '**/*'))
+                        .reject { |path| File.directory?(path) }
+                        .map do |path|
+              target_path = Pathname(path).relative_path_from(Pathname(from).parent).to_s
 
-        # Import an external file into `source`
-        # @param [String] from The original path.
-        # @param [String] to The new path.
-        # @return [void]
-        Contract String, String => Any
-        def create_import_file(from, to)
-          @import_file_configs << create_anonymous_import_file(from, to)
-          @app.sitemap.rebuild_resource_list!(:added_import_file)
+              ::Middleman::Sitemap::Resource.new(
+                app.sitemap,
+                renameProc.call(target_path, path),
+                path
+              )
+            end
+          end
         end
 
         # Import an external file into `source`
         # @param [String] from The original path.
         # @param [String] to The new path.
-        # @return [ImportFileDescriptor]
+        # @return [void]
         Contract String, String => ImportFileDescriptor
-        def create_anonymous_import_file(from, to)
+        def create_import_file(from, to)
           ImportFileDescriptor.new(
             File.expand_path(from, @app.root),
             ::Middleman::Util.normalize_path(to)
@@ -54,54 +53,13 @@ module Middleman
         # @param [String] from The original path.
         # @param [Proc] block Renaming method
         # @return [void]
-        Contract String, Maybe[Proc] => Any
+        Contract String, Maybe[Proc] => ImportPathDescriptor
         def create_import_path(from, &block)
-          rename_proc = block_given? ? block : proc { |path| path }
-          @import_path_configs << create_anonymous_import_path(from, rename_proc)
-          @app.sitemap.rebuild_resource_list!(:added_import_path)
-        end
-
-        # Import an external glob into `source`
-        # @param [String] from The original path.
-        # @param [Proc] block Renaming method
-        # @return [ImportPathDescriptor]
-        Contract String, Proc => ImportPathDescriptor
-        def create_anonymous_import_path(from, block)
           ImportPathDescriptor.new(
             from,
-            block
+            block_given? ? block : proc { |path| path }
           )
         end
-
-        Contract IsA['Middleman::SourceFile'] => Bool
-        def ignored?(file)
-          @app.config[:ignored_sitemap_matchers].any? { |_, fn| fn.call(file, @app) }
-        end
-
-        # Update the main sitemap resource list
-        # @return Array<Middleman::Sitemap::Resource>
-        Contract ResourceList => ResourceList
-        def manipulate_resource_list(resources)
-          resources + @import_file_configs.map { |c|
-            ::Middleman::Sitemap::Resource.new(
-              @app.sitemap,
-              c[:to],
-              c[:from]
-            )
-          } + @import_path_configs.flat_map { |c|
-            ::Middleman::Util.glob_directory(File.join(c[:from], '**/*'))
-              .reject { |path| File.directory?(path) }
-              .map do |path|
-              target_path = Pathname(path).relative_path_from(Pathname(c[:from]).parent).to_s
-
-              ::Middleman::Sitemap::Resource.new(
-                @app.sitemap,
-                c[:renameProc].call(target_path, path),
-                path
-              )
-            end
-          }
-        end
       end
     end
   end

data/lib/middleman-core/sitemap/extensions/move_file.rb

@@ -6,62 +6,33 @@ module Middleman
     module Extensions
       # Manages the list of proxy configurations and manipulates the sitemap
       # to include new resources based on those configurations
-      class MoveFile < Extension
-        MoveFileDescriptor = Struct.new(:from, :to)
-
+      class MoveFile < ConfigExtension
         self.resource_list_manipulator_priority = 101
 
         # Expose `create_move_file` to config as `move_file`
         expose_to_config move_file: :create_move_file
 
-        def initialize(app, config={}, &block)
-          super
-
-          @move_configs = Set.new
-        end
+        MoveFileDescriptor = Struct.new(:from, :to) do
+          def execute_descriptor(_app, resources)
+            resources.each do |r|
+              r.destination_path = to if from == r.path || from == r.destination_path
+            end
 
-        def after_configuration
-          ::Middleman::CoreExtensions::Collections::StepContext.add_to_context(:move_file, &method(:create_move_file))
+            resources
+          end
         end
 
         # Setup a move from one path to another
         # @param [String] from The original path.
         # @param [String] to The new path.
         # @return [void]
-        Contract String, String => Any
-        def create_move_file(from, to)
-          @move_configs << create_anonymous_move(from, to)
-          @app.sitemap.rebuild_resource_list!(:added_move_file)
-        end
-
-        # Setup a move from one path to another
-        # @param [String] from The original path.
-        # @param [String] to The new path.
-        # @return [MoveFileDescriptor]
         Contract String, String => MoveFileDescriptor
-        def create_anonymous_move(from, to)
+        def create_move_file(from, to)
           MoveFileDescriptor.new(
             ::Middleman::Util.normalize_path(from),
             ::Middleman::Util.normalize_path(to)
           )
         end
-
-        # Update the main sitemap resource list
-        # @return Array<Middleman::Sitemap::Resource>
-        Contract ResourceList => ResourceList
-        def manipulate_resource_list(resources)
-          resources.each do |r|
-            matches = @move_configs.select do |c|
-              c.from == r.path || c.from == r.destination_path
-            end
-
-            if c = matches.last
-              r.destination_path = c.to
-            end
-          end
-
-          resources
-        end
       end
     end
   end

data/lib/middleman-core/sitemap/extensions/proxies.rb

@@ -6,28 +6,12 @@ module Middleman
     module Extensions
       # Manages the list of proxy configurations and manipulates the sitemap
       # to include new resources based on those configurations
-      class Proxies < Extension
+      class Proxies < ConfigExtension
         self.resource_list_manipulator_priority = 0
 
-        # Expose `create_proxy` as `app.proxy`
-        expose_to_application proxy: :create_proxy
-
         # Expose `create_proxy` to config as `proxy`
         expose_to_config proxy: :create_proxy
 
-        def initialize(app, config={}, &block)
-          super
-
-          @proxy_configs = Set.new
-          @post_config = false
-        end
-
-        def after_configuration
-          @post_config = true
-
-          ::Middleman::CoreExtensions::Collections::StepContext.add_to_context(:proxy, &method(:create_anonymous_proxy))
-        end
-
         # Setup a proxy from a path to a target
         # @param [String] path The new, proxied path to create
         # @param [String] target The existing path that should be proxied to. This must be a real resource, not another proxy.
@@ -36,51 +20,35 @@ module Middleman
         # @option opts [Boolean] directory_indexes Whether or not the `:directory_indexes` extension applies to these paths.
         # @option opts [Hash] locals Local variables for the template. These will be available when the template renders.
         # @option opts [Hash] data Extra metadata to add to the page. This is the same as frontmatter, though frontmatter will take precedence over metadata defined here. Available via {Resource#data}.
-        # @return [void]
-        Contract String, String, Maybe[Hash] => Any
+        # @return [ProxyDescriptor]
+        Contract String, String, Maybe[Hash] => RespondTo[:execute_descriptor]
         def create_proxy(path, target, opts={})
-          options = opts.dup
-          @app.ignore(target) if options.delete(:ignore)
-
-          @proxy_configs << create_anonymous_proxy(path, target, options)
-          @app.sitemap.rebuild_resource_list!(:added_proxy)
-        end
-
-        # Setup a proxy from a path to a target
-        # @param [String] path The new, proxied path to create
-        # @param [String] target The existing path that should be proxied to. This must be a real resource, not another proxy.
-        # @option opts [Boolean] ignore Ignore the target from the sitemap (so only the new, proxy resource ends up in the output)
-        # @option opts [Symbol, Boolean, String] layout The layout name to use (e.g. `:article`) or `false` to disable layout.
-        # @option opts [Boolean] directory_indexes Whether or not the `:directory_indexes` extension applies to these paths.
-        # @option opts [Hash] locals Local variables for the template. These will be available when the template renders.
-        # @option opts [Hash] data Extra metadata to add to the page. This is the same as frontmatter, though frontmatter will take precedence over metadata defined here. Available via {Resource#data}.
-        # @return [void]
-        def create_anonymous_proxy(path, target, options={})
           ProxyDescriptor.new(
             ::Middleman::Util.normalize_path(path),
             ::Middleman::Util.normalize_path(target),
-            options
+            opts.dup
           )
         end
-
-        # Update the main sitemap resource list
-        # @return Array<Middleman::Sitemap::Resource>
-        Contract ResourceList => ResourceList
-        def manipulate_resource_list(resources)
-          resources + @proxy_configs.map { |c| c.to_resource(@app) }
-        end
       end
 
       ProxyDescriptor = Struct.new(:path, :target, :metadata) do
-        def to_resource(app)
-          ProxyResource.new(app.sitemap, path, target).tap do |p|
-            md = metadata.dup
-            p.add_metadata(
-              locals: md.delete(:locals) || {},
-              page: md.delete(:data) || {},
-              options: md
-            )
+        def execute_descriptor(app, resources)
+          md = metadata.dup
+          should_ignore = md.delete(:ignore)
+
+          r = ProxyResource.new(app.sitemap, path, target)
+          r.add_metadata(
+            locals: md.delete(:locals) || {},
+            page: md.delete(:data) || {},
+            options: md
+          )
+
+          if should_ignore
+            d = ::Middleman::Sitemap::Extensions::Ignores::IgnoreDescriptor.new(target)
+            d.execute_descriptor(app, resources)
           end
+
+          resources + [r]
         end
       end
     end