middleman-core 4.6.0 → 5.0.0.rc.1

data/lib/middleman-core/renderers/haml.rb

@@ -23,24 +23,18 @@ module Middleman
       def initialize(*args, &block)
         super
 
-        @context = @options[:context]
+        @context = @options[:context] if @options.key?(:context)
       end
 
       def prepare; end
 
       def evaluate(scope, locals, &block)
-        options = {}.merge!(@options).merge!(context: @context || scope)
+        options = {}.merge!(@options).merge!(filename: eval_file, line: line, context: @context || scope)
         if options.include?(:outvar)
           options[:buffer] = options.delete(:outvar)
           options[:save_buffer] = true
         end
-        if Object.const_defined?('::Haml::Template') # haml 6+
-          @engine = ::Haml::Template.new(eval_file, line, options) { data }
-        else
-          options[:filename] = eval_file
-          options[:line] = line
-          @engine = ::Haml::Engine.new(data, options)
-        end
+        @engine = ::Haml::Engine.new(data, options)
         output = @engine.render(scope, locals, &block)
 
         output
@@ -49,46 +43,20 @@ module Middleman
 
     # Haml Renderer
     class Haml < ::Middleman::Extension
-      def initialize(app, options={}, &block)
+      def initialize(app, options_hash = ::Middleman::EMPTY_HASH, &block)
         super
 
-        if Object.const_defined?('::Haml::Options') # Haml 5 and older
-          ::Haml::Options.defaults[:context] = nil
-          ::Haml::Options.send :attr_accessor, :context
-        else # Haml 6+
-          ::Haml::Engine.define_options context: nil
-        end
-        if defined?(::Haml::TempleEngine)
-          ::Haml::TempleEngine.define_options context: nil
-        end
-
+        ::Haml::Options.defaults[:context] = nil
+        ::Haml::Options.send :attr_accessor, :context
+        ::Haml::TempleEngine.define_options context: nil if defined?(::Haml::TempleEngine)
         [::Haml::Filters::Sass, ::Haml::Filters::Scss, ::Haml::Filters::Markdown].each do |f|
           f.class_exec do
-            if respond_to?(:template_class) # Haml 5 and older
-              def self.render_with_options(text, compiler_options)
-                modified_options = options.dup
-                modified_options[:context] = compiler_options[:context]
-
-                text = template_class.new(nil, 1, modified_options) { text }.render
-                super(text, compiler_options)
-              end
-            else # Haml 6+
-              def initialize(options = {})
-                super
-                @context = options[:context]
-              end
-
-              def compile_with_tilt(node, name, indent_width: 0)
-                options = { context: @context }
-                source = node.value[:text]
-                result = ::Tilt["t.#{name}"].new(nil, 1, options) { source }.render
+            def self.render_with_options(text, compiler_options)
+              modified_options = options.dup
+              modified_options[:context] = compiler_options[:context]
 
-                temple = [:multi, [:static, result.gsub(/^/, ' ' * indent_width)]]
-                source.lines.size.times do
-                  temple << [:newline]
-                end
-                temple
-              end
+              text = template_class.new(nil, 1, modified_options) { text }.render
+              super(text, compiler_options)
             end
           end
         end

data/lib/middleman-core/renderers/kramdown.rb

@@ -4,16 +4,20 @@ module Middleman
   module Renderers
     # Our own Kramdown Tilt template that simply uses our custom renderer.
     class KramdownTemplate < ::Tilt::KramdownTemplate
-      private
+      def initialize(*args, &block)
+        super
 
-      def _prepare_output
-        @context = @options[:context]
+        @context = @options[:context] if @options.key?(:context)
+      end
+
+      def evaluate(context, *)
         MiddlemanKramdownHTML.scope = @context || context
 
-        @engine = Kramdown::Document.new(data, options)
-        output, warnings = MiddlemanKramdownHTML.convert(@engine.root, @engine.options)
-        @engine.warnings.concat(warnings)
-        output
+        @output ||= begin
+          output, warnings = MiddlemanKramdownHTML.convert(@engine.root, @engine.options)
+          @engine.warnings.concat(warnings)
+          output
+        end
       end
     end
 
@@ -41,10 +45,6 @@ module Middleman
         attr = el.attr.dup
         link = attr.delete('href')
 
-        # options to link_to are expected to be symbols, but in Markdown
-        # everything is a string.
-        attr.transform_keys!(&:to_sym)
-
         scope.link_to(content, link, attr)
       end
     end

data/lib/middleman-core/renderers/less.rb

@@ -1,20 +1,36 @@
+require 'less'
+
 module Middleman
   module Renderers
     # Sass renderer
     class Less < ::Middleman::Extension
-      # A SassTemplate for Tilt which outputs debug messages
-      class DummyLessTemplate < ::Tilt::Template
-        def evaluate(scope, locals, &block)
-          raise <<~ERROR
-            The builtin less renderer has been removed from middleman.
-            To continue using less, make sure to setup an external pipeline.
-            See external pipeline documentation at https://middlemanapp.com/advanced/external-pipeline
-            for more information.
-          ERROR
+      define_setting :less, {}, 'LESS compiler options'
+
+      def initialize(app, options_hash = ::Middleman::EMPTY_HASH, &block)
+        super
+
+        # Tell Tilt to use it as well (for inline sass blocks)
+        ::Tilt.register 'less', LocalLoadingLessTemplate
+        ::Tilt.prefer(LocalLoadingLessTemplate)
+      end
+
+      def after_configuration
+        app.files.by_type(:source).watchers.each do |source|
+          ::Less.paths << (source.directory + app.config[:css_dir]).to_s
         end
       end
 
-      ::Tilt.register 'less', DummyLessTemplate
+      # A SassTemplate for Tilt which outputs debug messages
+      class LocalLoadingLessTemplate < ::Tilt::LessTemplate
+        def prepare
+          if ::Less.const_defined? :Engine
+            @engine = ::Less::Engine.new(data)
+          else
+            parser = ::Less::Parser.new({}.merge!(options).merge!(filename: eval_file, line: line, paths: ['.', File.dirname(eval_file)]))
+            @engine = parser.parse(data)
+          end
+        end
+      end
     end
   end
 end

data/lib/middleman-core/renderers/liquid.rb

@@ -11,25 +11,22 @@ module Middleman
       end
 
       # Called by Liquid to retrieve a template file
-      def read_template_file(template_path, _ = nil)
-        file = app.files.find(:source, "_#{template_path}.liquid")
+      def read_template_file(template_path)
+        file = app.files.find(:source, "#{File.dirname(template_path)}/_#{File.basename(template_path)}.liquid")
         raise ::Liquid::FileSystemError, "No such template '#{template_path}'" unless file
+
         file.read
       end
 
-      # @return Array<Middleman::Sitemap::Resource>
-      Contract ResourceList => ResourceList
-      def manipulate_resource_list(resources)
-        return resources unless app.extensions[:data]
-
-        resources.each do |resource|
-          next if resource.file_descriptor.nil?
-          next unless resource.file_descriptor[:full_path].to_s =~ %r{\.liquid$}
+      Contract IsA['Middleman::Sitemap::ResourceListContainer'] => Any
+      def manipulate_resource_list_container!(resource_list)
+        return unless app.extensions[:data]
 
+        resource_list.by_source_extension('.liquid').each do |resource|
           # Convert data object into a hash for liquid
-          resource.add_metadata locals: {
+          resource.add_metadata_locals(
             data: stringify_recursive(app.extensions[:data].data_store.to_h)
-          }
+          )
         end
       end
 

data/lib/middleman-core/renderers/markdown.rb

@@ -7,7 +7,7 @@ module Middleman
 
       # Once configuration is parsed
       def after_configuration
-        markdown_exts = %w(markdown mdown md mkd mkdn)
+        markdown_exts = %w[markdown mdown md mkd mkdn]
 
         begin
           # Look for the user's preferred engine
@@ -20,12 +20,12 @@ module Middleman
           elsif app.config[:markdown_engine]
             # Map symbols to classes
             markdown_engine_klass = if app.config[:markdown_engine].is_a? Symbol
-              engine = app.config[:markdown_engine].to_s
-              engine = engine == 'rdiscount' ? 'RDiscount' : engine.camelize
-              app.config[:markdown_engine_prefix].const_get("#{engine}Template")
-            else
-              app.config[:markdown_engine_prefix]
-            end
+                                      engine = app.config[:markdown_engine].to_s
+                                      engine = engine == 'rdiscount' ? 'RDiscount' : engine.camelize
+                                      app.config[:markdown_engine_prefix].const_get("#{engine}Template")
+                                    else
+                                      app.config[:markdown_engine_prefix]
+                                    end
 
             # Tell tilt to use that engine
             ::Tilt.prefer(markdown_engine_klass, *markdown_exts)
@@ -33,9 +33,7 @@ module Middleman
         rescue LoadError
           # If they just left it at the default engine and don't happen to have it,
           # then they're using middleman-core bare and we shouldn't bother them.
-          if app.config.setting(:markdown_engine).value_set?
-            logger.warn "Requested Markdown engine (#{app.config[:markdown_engine]}) not found. Maybe the gem needs to be installed and required?"
-          end
+          logger.warn "Requested Markdown engine (#{app.config[:markdown_engine]}) not found. Maybe the gem needs to be installed and required?" if app.config.setting(:markdown_engine).value_set?
         end
       end
     end

data/lib/middleman-core/renderers/redcarpet.rb

@@ -1,5 +1,4 @@
 require 'redcarpet'
-require 'active_support/core_ext/module/attribute_accessors'
 
 module Middleman
   module Renderers
@@ -10,12 +9,13 @@ module Middleman
         escape_html: :filter_html
       }.freeze
 
-      private
+      def initialize(*args, &block)
+        super
 
-      def _prepare_output
-        Redcarpet::Markdown.new(generate_renderer, options).render(data)
+        @context = @options[:context] if @options.key?(:context)
       end
 
+      # Overwrite built-in Tilt version.
       # Don't overload :renderer option with smartypants
       # Support renderer-level options
       def generate_renderer
@@ -25,7 +25,6 @@ module Middleman
 
         # Pick a renderer
         renderer = MiddlemanRedcarpetHTML
-        renderer.scope = options[:context]
 
         if options.delete(:smartypants)
           # Support SmartyPants
@@ -35,7 +34,7 @@ module Middleman
         end
 
         # Renderer Options
-        possible_render_opts = [:filter_html, :no_images, :no_links, :no_styles, :safe_links_only, :with_toc_data, :hard_wrap, :xhtml, :prettify, :link_attributes]
+        possible_render_opts = %i[filter_html no_images no_links no_styles safe_links_only with_toc_data hard_wrap xhtml prettify link_attributes]
 
         render_options = possible_render_opts.each_with_object({}) do |opt, sum|
           sum[opt] = options.delete(opt) if options.key?(opt)
@@ -44,6 +43,16 @@ module Middleman
         renderer.new(render_options)
       end
 
+      def evaluate(scope, _)
+        @output ||= begin
+          MiddlemanRedcarpetHTML.scope = @context || scope
+
+          @engine.render(data)
+        end
+      end
+
+      private
+
       def covert_options_to_aliases!
         ALIASES.each do |aka, actual|
           options[actual] = options.delete(aka) if options.key? aka
@@ -55,8 +64,8 @@ module Middleman
     class MiddlemanRedcarpetHTML < ::Redcarpet::Render::HTML
       cattr_accessor :scope
 
-      def initialize(options={})
-        @local_options = options.dup
+      def initialize(options_hash = ::Middleman::EMPTY_HASH)
+        @local_options = options_hash.dup
 
         super
       end

data/lib/middleman-core/renderers/sass.rb

@@ -1,20 +1,26 @@
+require 'hamster'
 require 'sassc'
+require 'middleman-core/dependencies'
+require 'middleman-core/dependencies/vertices/file_vertex'
 
 module Middleman
   module Renderers
     # Sass renderer
     class Sass < ::Middleman::Extension
+      DEFAULT_SASS_CACHE_LOCATION = './.sass-cache'.freeze
+
       opts = { output_style: :nested }
       opts[:line_comments] = false if ENV['TEST']
       define_setting :sass, opts, 'Sass engine options'
       define_setting :sass_assets_paths, [], 'Paths to extra SASS/SCSS files'
       define_setting :sass_source_maps, nil, 'Whether to inline sourcemap into Sass'
+      define_setting :sass_cache_location, ENV['SASS_CACHE_LOCATION'] || DEFAULT_SASS_CACHE_LOCATION, 'Where to store sass cache files'
 
       # Setup extension
-      def initialize(app, options={}, &block)
+      def initialize(app, options_hash = ::Middleman::EMPTY_HASH, &block)
         super
 
-        app.files.ignore :sass_cache, :source, /(^|\/)\.sass-cache\//
+        app.files.ignore :sass_cache, :source, /(^|\/)\.sass-cache\// if app.config[:sass_cache_location] == DEFAULT_SASS_CACHE_LOCATION
 
         # Tell Tilt to use it as well (for inline sass blocks)
         ::Tilt.register 'sass', SassPlusCSSFilenameTemplate
@@ -29,19 +35,26 @@ module Middleman
 
       # A SassTemplate for Tilt which outputs debug messages
       class SassPlusCSSFilenameTemplate < ::Tilt::SassTemplate
+        def initialize(*args, &block)
+          super
+
+          @context = @options[:context] if @options.key?(:context)
+        end
+
         # Define the expected syntax for the template
         # @return [Symbol]
         def syntax
           :sass
         end
 
-        private
+        def prepare; end
 
         # Add exception messaging
         # @param [Class] context
         # @return [String]
-        def _prepare_output
-          @context = @options[:context]
+        def evaluate(context, _)
+          @context ||= context
+
           @engine = ::SassC::Engine.new(data, sass_options)
 
           begin
@@ -69,6 +82,14 @@ module Middleman
           END
         end
 
+        def vertices
+          @engine.dependencies.reduce(::Hamster::Set.empty) do |sum, d|
+            sum << ::Middleman::Dependencies::FileVertex.new(@context.app.root_path, d.filename.to_sym)
+          end
+        rescue ::SassC::NotRenderedError
+          ::Hamster::Set.empty
+        end
+
         # Change Sass path, for url functions, to the build folder if we're building
         # @return [Hash]
         def sass_options
@@ -76,8 +97,8 @@ module Middleman
 
           preexisting_load_paths = begin
             ::Sass.load_paths
-          rescue
-            []
+                                   rescue StandardError
+                                     []
           end
 
           more_opts = {
@@ -85,6 +106,7 @@ module Middleman
             filename: eval_file,
             line: line,
             syntax: syntax,
+            cache_location: ctx.app.config[:sass_cache_location],
             custom: {}.merge!(options[:custom] || {}).merge!(
               middleman_context: ctx.app,
               current_resource: ctx.current_resource
@@ -97,9 +119,7 @@ module Middleman
             more_opts[:source_map_contents] = true
           end
 
-          if ctx.is_a?(::Middleman::TemplateContext) && file
-            more_opts[:css_filename] = file.sub(/\.s[ac]ss$/, '')
-          end
+          more_opts[:css_filename] = file.sub(/\.s[ac]ss$/, '') if ctx.is_a?(::Middleman::TemplateContext) && file
 
           {}.merge!(options).merge!(more_opts)
         end

data/lib/middleman-core/renderers/sass_functions.rb

@@ -14,8 +14,8 @@ module Middleman
       #   background: url(image-path("image.jpg"));                // background: url("/assets/image.jpg");
       #   background: url(image-path("image.jpg", $digest: true)); // background: url("/assets/image-27a8f1f96afd8d4c67a59eb9447f45bd.jpg");
       #
-      def image_path(source, options={})
-        p = ::Middleman::Util.asset_path(middleman_context, :images, source.value, map_options(options))
+      def image_path(source, options_hash = ::Middleman::EMPTY_HASH)
+        p = ::Middleman::Util.asset_path(middleman_context, :images, source.value, map_options(options_hash))
         ::SassC::Script::Value::String.new p.to_s, :string
       end
 
@@ -28,8 +28,10 @@ module Middleman
       #   background: image-url("image.jpg");                // background: url("/assets/image.jpg");
       #   background: image-url("image.jpg", $digest: true); // background: url("/assets/image-27a8f1f96afd8d4c67a59eb9447f45bd.jpg");
       #
-      def image_url(source, options={}, _cache_buster=nil)
-        # Work with the Sass #image_url API
+      def image_url(source, options_hash = ::Middleman::EMPTY_HASH, _cache_buster = nil)
+        options = options_hash.dup
+
+        # Work with the Compass #image_url API
         if options.respond_to? :value
           case options.value
           when true
@@ -51,8 +53,8 @@ module Middleman
       #   src: url(font-path("font.ttf"));                // src: url("/assets/font.ttf");
       #   src: url(font-path("font.ttf", $digest: true)); // src: url("/assets/font-27a8f1f96afd8d4c67a59eb9447f45bd.ttf");
       #
-      def font_path(source, options={})
-        p = ::Middleman::Util.asset_path(middleman_context, :fonts, source.value, map_options(options))
+      def font_path(source, options_hash = ::Middleman::EMPTY_HASH)
+        p = ::Middleman::Util.asset_path(middleman_context, :fonts, source.value, map_options(options_hash))
         ::SassC::Script::Value::String.new p.to_s, :string
       end
 
@@ -65,8 +67,10 @@ module Middleman
       #   src: font-url("font.ttf");                  // src: url("/assets/font.ttf");
       #   src: font-url("image.jpg", $digest: true);  // src: url("/assets/font-27a8f1f96afd8d4c67a59eb9447f45bd.ttf");
       #
-      def font_url(source, options={})
-        # Work with the Sass #font_url API
+      def font_url(source, options_hash = ::Middleman::EMPTY_HASH)
+        options = options_hash.dup
+
+        # Work with the Compass #font_url API
         if options.respond_to? :value
           case options.value
           when true
@@ -93,8 +97,10 @@ module Middleman
 
       # Returns an options hash where the keys are symbolized
       # and the values are unwrapped Sass literals.
-      def map_options(options={}) # :nodoc:
-        # ::Sass::Util.map_hash(options) do |key, value|
+      def map_options(options_hash = ::Middleman::EMPTY_HASH) # :nodoc:
+        options = options_hash.dup
+
+        # ::SassC::Util.map_hash(options) do |key, value|
         #   [key.to_sym, value.respond_to?(:value) ? value.value : value]
         # end
 

data/lib/middleman-core/renderers/slim.rb

@@ -13,7 +13,7 @@ class ::Slim::Template
   def initialize(file, line, opts, &block)
     if opts.key?(:context)
       ::Slim::Embedded::SassEngine.disable_option_validator!
-      %w(sass scss markdown).each do |engine|
+      %w[sass scss markdown].each do |engine|
         (::Slim::Embedded.options[engine.to_sym] ||= {})[:context] = opts[:context]
       end
     end
@@ -31,7 +31,7 @@ module Middleman
     # Slim renderer
     class Slim < ::Middleman::Extension
       # Setup extension
-      def initialize(_app, _options={}, &_block)
+      def initialize(_app, _options_hash = ::Middleman::EMPTY_HASH, &_block)
         super
 
         # Setup Slim options to work with partials
@@ -39,17 +39,9 @@ module Middleman
         ::Slim::Engine.set_options(
           buffer: '@_out_buf',
           use_html_safe: true,
+          generator: ::Temple::Generators::RailsOutputBuffer,
           disable_escape: true
         )
-        begin
-          require "action_view"
-        rescue LoadError
-          # Don't add generator option if action_view is not available, since it depends on it
-        else
-          ::Slim::Engine.set_options(
-            generator: ::Temple::Generators::RailsOutputBuffer,
-          )
-        end
       end
     end
   end

data/lib/middleman-core/renderers/stylus.rb

@@ -0,0 +1,10 @@
+require 'stylus'
+require 'stylus/tilt'
+
+module Middleman
+  module Renderers
+    class Stylus < ::Middleman::Extension
+      define_setting :styl, {}, 'Stylus config options'
+    end
+  end
+end

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

@@ -12,9 +12,7 @@ module Middleman
         # @param [String, Regexp] path Path glob expression, or path regex
         # @return [IgnoreDescriptor]
         Contract Or[String, Regexp, Proc] => RespondTo[:execute_descriptor]
-        def ignore(path=nil, &block)
-          @app.sitemap.invalidate_resources_not_ignored_cache!
-
+        def ignore(path = nil, &block)
           if path.is_a? Regexp
             RegexpIgnoreDescriptor.new(path)
           elsif path.is_a? String
@@ -33,17 +31,15 @@ module Middleman
         end
 
         IgnoreDescriptor = Struct.new(:path, :block) do
-          def execute_descriptor(_app, resources)
-            resources.map do |r|
+          def execute_descriptor(_app, resource_list)
+            resource_list.each do |r|
               # Ignore based on the source path (without template extensions)
               if ignored?(r.normalized_path)
-                r.ignore!
+                resource_list.update!(r, :ignored) { r.ignore! }
               elsif !r.is_a?(ProxyResource) && r.file_descriptor && ignored?(r.file_descriptor.normalized_relative_path)
                 # This allows files to be ignored by their source file name (with template extensions)
-                r.ignore!
+                resource_list.update!(r, :ignored) { r.ignore! }
               end
-
-              r
             end
           end
 

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

@@ -11,28 +11,27 @@ module Middleman
         expose_to_config :import_file, :import_path
 
         ImportFileDescriptor = Struct.new(:from, :to) do
-          def execute_descriptor(app, resources)
-            source = ::Middleman::SourceFile.new(Pathname(from).relative_path_from(app.source_dir), Pathname(from), app.source_dir, Set.new([:source, :binary]), 0)
-
-            resources + [
-              ::Middleman::Sitemap::Resource.new(app.sitemap, to, source)
-            ]
+          def execute_descriptor(app, resource_list)
+            source = ::Middleman::SourceFile.new(Pathname(from).relative_path_from(app.source_dir), Pathname(from), app.source_dir, Set.new(%i[source binary]), 0)
+            resource_list.add! ::Middleman::Sitemap::Resource.new(app.sitemap, to, source)
           end
         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
+          def execute_descriptor(app, resource_list)
+            new_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
+
+              ::Middleman::Sitemap::Resource.new(
+                app.sitemap,
+                renameProc.call(target_path, path),
+                path
+              )
+            end
 
-                          ::Middleman::Sitemap::Resource.new(
-                            app.sitemap,
-                            renameProc.call(target_path, path),
-                            path
-                          )
-                        end
+            resource_list.add!(*new_resources)
           end
         end
 

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

@@ -13,12 +13,14 @@ module Middleman
         expose_to_config :move_file
 
         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 execute_descriptor(_app, resource_list)
+            resource_list.each do |r|
+              next unless from == r.path || from == r.destination_path
 
-            resources
+              resource_list.update!(r, :destination_path) do
+                r.destination_path = to
+              end
+            end
           end
         end
 

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

@@ -7,7 +7,7 @@ module Middleman
       class OnDisk < Extension
         self.resource_list_manipulator_priority = 0
 
-        def initialize(app, config={}, &block)
+        def initialize(app, options_hash = ::Middleman::EMPTY_HASH, &block)
           super
 
           @file_paths_on_disk = Set.new
@@ -57,14 +57,15 @@ module Middleman
         end
 
         # Update the main sitemap resource list
-        # @return Array<Middleman::Sitemap::Resource>
-        Contract ResourceList => ResourceList
-        def manipulate_resource_list(resources)
-          resources + files_for_sitemap.map do |file|
-            ::Middleman::Sitemap::Resource.new(
-              @app.sitemap,
-              @app.sitemap.file_to_path(file),
-              file
+        Contract IsA['Middleman::Sitemap::ResourceListContainer'] => Any
+        def manipulate_resource_list_container!(resource_list)
+          files_for_sitemap.each do |file|
+            resource_list.add!(
+              ::Middleman::Sitemap::Resource.new(
+                @app.sitemap,
+                @app.sitemap.file_to_path(file),
+                file
+              )
             )
           end
         end