middleman-core 4.3.11 → 5.0.0.rc.1

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

@@ -1,11 +1,4 @@
 require 'padrino-helpers'
-require 'padrino-helpers/output_helpers'
-require 'padrino-helpers/asset_tag_helpers'
-require 'padrino-helpers/form_helpers'
-require 'padrino-helpers/format_helpers'
-require 'padrino-helpers/number_helpers'
-require 'padrino-helpers/output_helpers'
-require 'padrino-helpers/render_helpers'
 require 'middleman-core/contracts'
 
 # Don't fail on invalid locale, that's not what our current
@@ -27,11 +20,9 @@ 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)
+  def initialize(app, options_hash = ::Middleman::EMPTY_HASH, &block)
     super
 
-    require 'active_support/core_ext/object/to_query'
-
     ::Middleman::TemplateContext.send :include, ::Padrino::Helpers::OutputHelpers
     ::Middleman::TemplateContext.send :include, ::Padrino::Helpers::TagHelpers
     ::Middleman::TemplateContext.send :include, ::Padrino::Helpers::AssetTagHelpers
@@ -45,7 +36,7 @@ class Middleman::CoreExtensions::DefaultHelpers < ::Middleman::Extension
   # The helpers
   helpers do
     # Make all block content html_safe
-    def content_tag(name, content=nil, options=nil, &block)
+    def content_tag(name, content = nil, options = nil, &block)
       # safe_content_tag(name, content, options, &block)
       if block_given?
         options = content if content.is_a?(Hash)
@@ -54,7 +45,7 @@ class Middleman::CoreExtensions::DefaultHelpers < ::Middleman::Extension
 
       options    = parse_data_options(name, options)
       attributes = tag_attributes(options)
-      output = ActiveSupport::SafeBuffer.new
+      output = ::ActiveSupport::SafeBuffer.new
       output.safe_concat "<#{name}#{attributes}>"
 
       if content.respond_to?(:each) && !content.is_a?(String)
@@ -71,11 +62,13 @@ class Middleman::CoreExtensions::DefaultHelpers < ::Middleman::Extension
     end
 
     def capture_html(*args, &block)
-      result = if handler = auto_find_proper_handler(&block)
-        handler.capture_from_template(*args, &block)
-      else
-        yield(*args)
-      end
+      handler = auto_find_proper_handler(&block)
+
+      result = if handler
+                 handler.capture_from_template(*args, &block)
+               else
+                 yield(*args)
+               end
 
       ::ActiveSupport::SafeBuffer.new.safe_concat(result)
     end
@@ -147,14 +140,14 @@ class Middleman::CoreExtensions::DefaultHelpers < ::Middleman::Extension
     # @param [Symbol] asset_ext The type of asset
     # @param [String] asset_dir Where to look for assets
     # @return [void]
-    def auto_tag(asset_ext, asset_dir=nil)
+    def auto_tag(asset_ext, asset_dir = nil)
       if asset_dir.nil?
         asset_dir = case asset_ext
-        when :js
-          config[:js_dir]
-        when :css
-          config[:css_dir]
-        end
+                    when :js
+                      config[:js_dir]
+                    when :css
+                      config[:css_dir]
+                    end
       end
 
       # If the basename of the request as no extension, assume we are serving a
@@ -162,13 +155,15 @@ class Middleman::CoreExtensions::DefaultHelpers < ::Middleman::Extension
       path = File.join(asset_dir, current_resource.path)
       path = path[0..-(File.extname(path).length + 1)] + ".#{asset_ext}"
 
-      yield path if sitemap.find_resource_by_path(path)
+      yield path if sitemap.by_path(path)
     end
 
     # Generate body css classes based on the current path
     #
     # @return [String]
-    def page_classes(path=current_path.dup, options={})
+    def page_classes(path = current_path.dup, options_hash = ::Middleman::EMPTY_HASH)
+      options = options_hash
+
       if path.is_a? Hash
         options = path
         path = current_path.dup
@@ -198,8 +193,8 @@ class Middleman::CoreExtensions::DefaultHelpers < ::Middleman::Extension
     # @param [String] source The path to the file
     # @param [Hash] options Data to pass through.
     # @return [String]
-    def asset_path(kind, source, options={})
-      options_with_resource = {}.merge!(options).merge!(current_resource: current_resource)
+    def asset_path(kind, source, options_hash = ::Middleman::EMPTY_HASH)
+      options_with_resource = {}.merge!(options_hash).merge!(current_resource: current_resource)
       ::Middleman::Util.asset_path(app, kind, source, options_with_resource)
     end
 
@@ -209,16 +204,16 @@ class Middleman::CoreExtensions::DefaultHelpers < ::Middleman::Extension
     # @param [String] prefix The type prefix (such as "images")
     # @param [Hash] options Additional options.
     # @return [String] The fully qualified asset url
-    def asset_url(path, prefix='', options={})
-      options_with_resource = {}.merge!(options).merge!(current_resource: current_resource)
+    def asset_url(path, prefix = '', options_hash = ::Middleman::EMPTY_HASH)
+      options_with_resource = {}.merge!(options_hash).merge!(current_resource: current_resource)
       ::Middleman::Util.asset_url(app, path, prefix, options_with_resource)
     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(path_or_resource, options={})
-      options_with_resource = {}.merge!(options).merge!(current_resource: current_resource)
+    def url_for(path_or_resource, options_hash = ::Middleman::EMPTY_HASH)
+      options_with_resource = {}.merge!(options_hash).merge!(current_resource: current_resource)
       ::Middleman::Util.url_for(app, path_or_resource, options_with_resource)
     end
 
@@ -239,11 +234,11 @@ class Middleman::CoreExtensions::DefaultHelpers < ::Middleman::Extension
       url_arg_index = block_given? ? 0 : 1
       options_index = block_given? ? 1 : 2
 
-      if block_given? && args.size > 2
-        raise ArgumentError, 'Too many arguments to link_to(url, options={}, &block)'
-      end
+      raise ArgumentError, 'Too many arguments to link_to(url, options={}, &block)' if block_given? && args.size > 2
+
+      url = args[url_arg_index]
 
-      if url = args[url_arg_index]
+      if url
         options = args[options_index] || {}
         raise ArgumentError, 'Options must be a hash' unless options.is_a?(Hash)
 
@@ -259,14 +254,14 @@ class Middleman::CoreExtensions::DefaultHelpers < ::Middleman::Extension
 
     # Modified Padrino form_for that uses Middleman's url_for
     # to transform the URL.
-    def form_tag(url, options={}, &block)
-      url = url_for(url, options)
+    def form_tag(url, options_hash = ::Middleman::EMPTY_HASH, &block)
+      url = url_for(url, options_hash)
       super
     end
 
     # Modified Padrino image_tag so that it finds the paths for srcset
     # using asset_path for the images listed in the srcset param
-    def image_tag(path, params={})
+    def image_tag(path, params = {})
       params.symbolize_keys!
 
       if params.key?(:srcset)
@@ -282,13 +277,13 @@ class Middleman::CoreExtensions::DefaultHelpers < ::Middleman::Extension
         params[:srcset] = images_sources.join(', ')
       end
 
-      params[:alt] ||= ''
-
       super(path, params)
     end
 
-    def partial(template, options={}, &block)
-      including_parent_locals = {}
+    def partial(template, options_hash = ::Middleman::EMPTY_HASH, &block)
+      options = options_hash.dup
+
+      including_parent_locals = Middleman::Util::EnhancedHash.new
       including_parent_locals.merge!(@locs || {})
       including_parent_locals.merge!(options[:locals] || {})
 

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

@@ -19,7 +19,7 @@ module Middleman
           module_name = app.config[:helpers_filename_to_module_name_proc].call(filename)
           next unless module_name
 
-          require filename
+          load filename
           next unless Object.const_defined?(module_name.to_sym)
 
           app.template_context_class.send :include, Object.const_get(module_name.to_sym)

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

@@ -24,7 +24,7 @@ module Middleman
       }.freeze
 
       # Setup the extension.
-      def initialize(app, config={}, &block)
+      def initialize(app, options_hash = ::Middleman::EMPTY_HASH, &block)
         super
 
         # Setup source collection.
@@ -59,9 +59,7 @@ module Middleman
           wait_for_delay: app.config[:watcher_wait_for_delay]
         )
 
-        if @original_source_dir != app.config[:source]
-          @watcher.update_path(app.config[:source])
-        end
+        @watcher.update_path(app.config[:source]) if @original_source_dir != app.config[:source]
 
         @sources.start!
         @sources.poll_once!

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

@@ -4,8 +4,6 @@ require 'pathname'
 # DbC
 require 'middleman-core/contracts'
 
-require 'active_support/core_ext/hash/keys'
-
 require 'middleman-core/util/data'
 
 # Extensions namespace
@@ -16,11 +14,11 @@ module Middleman::CoreExtensions
 
     # Set textual delimiters that denote the start and end of frontmatter
     define_setting :frontmatter_delims, {
-      json: [%w(;;; ;;;)],
-      yaml: [%w(--- ---), %w(--- ...)]
+      json: [%w[;;; ;;;]],
+      yaml: [%w[--- ---], %w[--- ...]]
     }, 'Allowed frontmatter delimiters'
 
-    def initialize(app, options_hash={}, &block)
+    def initialize(app, options_hash = ::Middleman::EMPTY_HASH, &block)
       super
 
       @cache = {}
@@ -30,11 +28,9 @@ module Middleman::CoreExtensions
       app.files.on_change(:source, &method(:clear_data))
     end
 
-    # @return Array<Middleman::Sitemap::Resource>
-    Contract ResourceList => ResourceList
-    def manipulate_resource_list(resources)
-      resources.each do |resource|
-        next if resource.binary?
+    Contract IsA['Middleman::Sitemap::ResourceListContainer'] => Any
+    def manipulate_resource_list_container!(resource_list)
+      resource_list.by_binary(false).each do |resource|
         next if resource.file_descriptor.nil?
         next if resource.file_descriptor[:types].include?(:no_frontmatter)
 
@@ -51,9 +47,21 @@ module Middleman::CoreExtensions
         # TODO: Enhance data? NOOOO
         # TODO: stringify-keys? immutable/freeze?
 
-        resource.add_metadata options: opts, page: fmdata
+        resource.add_metadata_options opts
+
+        if fmdata.key?(:id)
+          resource_list.update!(resource, :page_id) do
+            resource.add_metadata_page fmdata
+          end
+        else
+          resource.add_metadata_page fmdata
+        end
+
+        next unless ignored == true && !resource.is_a?(::Middleman::Sitemap::ProxyResource)
 
-        resource.ignore! if ignored == true && !resource.is_a?(::Middleman::Sitemap::ProxyResource)
+        resource_list.update!(resource, :ignored) do
+          resource.ignore!
+        end
 
         # TODO: Save new template here somewhere?
       end
@@ -76,10 +84,14 @@ module Middleman::CoreExtensions
       file_path = file[:full_path].to_s
 
       @cache[file_path] ||= begin
-        ::Middleman::Util::Data.parse(
-          file,
-          app.config[:frontmatter_delims]
-        )
+        if ::Middleman::Util.contains_frontmatter?(file_path, app.config[:frontmatter_delims])
+          ::Middleman::Util::Data.parse(
+            file,
+            app.config[:frontmatter_delims]
+          )
+        else
+          [{}, nil]
+        end
       end
     end
 

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

@@ -29,11 +29,11 @@ class Middleman::CoreExtensions::Internationalization < ::Middleman::Extension
     # don't completely reload middleman, I18n.load_path can get
     # polluted with paths from other test app directories that don't
     # exist anymore.
-    if ENV['TEST']
-      app.after_configuration_eval do
-        ::I18n.load_path.delete_if { |path| path =~ %r{tmp/aruba} }
-        ::I18n.reload!
-      end
+    return unless ENV['TEST']
+
+    app.after_configuration_eval do
+      ::I18n.load_path.delete_if { |path| path =~ %r{tmp/aruba} }
+      ::I18n.reload!
     end
   end
 
@@ -68,39 +68,32 @@ class Middleman::CoreExtensions::Internationalization < ::Middleman::Extension
       ::I18n.t(*args)
     end
 
-    def url_for(path_or_resource, options={})
-      locale = options.delete(:locale) || ::I18n.locale
+    def url_for(path_or_resource, options_hash = ::Middleman::EMPTY_HASH)
+      # Fucked up, intentional mutation :(
+      locale = options_hash.key?(:locale) ? options_hash.delete(:locale) : ::I18n.locale
 
-      opts = options.dup
+      opts = options_hash.dup
 
       should_relativize = opts.key?(:relative) ? opts[:relative] : config[:relative_links]
-      anchor = opts[:anchor]
 
-      # The first call to `super()` is only to find the correct URL. The next
-      # call will relativize and add the anchor.
       opts[:relative] = false
-      opts[:anchor] = nil
 
       href = super(path_or_resource, opts)
 
-      final_path = if result = extensions[:i18n].localized_path(href, locale)
-        result
-      else
-        # Should we log the missing file?
-        href
-      end
+      result = extensions[:i18n].localized_path(href, locale)
+
+      final_path = result || href
 
       opts[:relative] = should_relativize
-      opts[:anchor] = anchor
 
       begin
         super(final_path, opts)
       rescue RuntimeError
-        super(path_or_resource, options)
+        super(path_or_resource, options_hash)
       end
     end
 
-    def locate_partial(partial_name, try_static=false)
+    def locate_partial(partial_name, try_static = false)
       locals_dir = extensions[:i18n].options[:templates_dir]
 
       # Try /localizable
@@ -111,10 +104,10 @@ class Middleman::CoreExtensions::Internationalization < ::Middleman::Extension
       extname = File.extname(partial_name)
       maybe_static = !extname.empty?
       suffixed_partial_name = if maybe_static
-        partial_name.sub(extname, ".#{locale_suffix}#{extname}")
-      else
-        "#{partial_name}.#{locale_suffix}"
-      end
+                                partial_name.sub(extname, ".#{locale_suffix}#{extname}")
+                              else
+                                "#{partial_name}.#{locale_suffix}"
+                              end
 
       if locale_suffix
         super(suffixed_partial_name, maybe_static) ||
@@ -145,16 +138,17 @@ class Middleman::CoreExtensions::Internationalization < ::Middleman::Extension
   alias lang locale
 
   # Update the main sitemap resource list
-  # @return Array<Middleman::Sitemap::Resource>
-  Contract ResourceList => ResourceList
-  def manipulate_resource_list(resources)
+  Contract IsA['Middleman::Sitemap::ResourceListContainer'] => Any
+  def manipulate_resource_list_container!(resource_list)
     new_resources = []
 
-    file_extension_resources = resources.select do |resource|
-      parse_locale_extension(resource.path)
+    file_extension_resources = resource_list.select do |resource|
+      # Ignore resources which are outside of the localizable directory
+      File.fnmatch?(File.join(options[:templates_dir], '**'), resource.path) &&
+        parse_locale_extension(resource.path)
     end
 
-    localizable_folder_resources = resources.select do |resource|
+    localizable_folder_resources = resource_list.select do |resource|
       !file_extension_resources.include?(resource) && File.fnmatch?(File.join(options[:templates_dir], '**'), resource.path)
     end
 
@@ -169,14 +163,17 @@ class Middleman::CoreExtensions::Internationalization < ::Middleman::Extension
         new_resources << build_resource(path, resource.path, page_id, locale)
       end
 
-      resource.ignore!
+      resource_list.update!(resource, :ignored) do
+        resource.ignore!
+      end
 
       # This is for backwards compatibility with the old provides_metadata-based code
       # that used to be in this extension, but I don't know how much sense it makes.
       # next if resource.options[:locale]
 
       # $stderr.puts "Defaulting #{resource.path} to #{@mount_at_root}"
-      # resource.add_metadata options: { locale: @mount_at_root }, locals: { locale: @mount_at_root }
+      # resource.add_metadata_options(locale: @mount_at_root)
+      # resource.add_metadata_locals(locale: @mount_at_root)
     end
 
     # If it uses file extension localization
@@ -185,28 +182,88 @@ class Middleman::CoreExtensions::Internationalization < ::Middleman::Extension
 
       result = parse_locale_extension(resource.path)
       ext_locale, path, page_id = result
-      new_resources << build_resource(path, resource.path, page_id, ext_locale)
 
-      resource.ignore!
+      new_resource = build_resource(path, resource.path, page_id, ext_locale)
+
+      # extension resources replace original i18n attempt.
+      exists = new_resources.find { |r| r.path == new_resource.path }
+      new_resources.delete(exists) if exists
+
+      new_resources << new_resource
+
+      resource_list.update!(resource, :ignored) do
+        resource.ignore!
+      end
     end
 
-    @lookup = new_resources.each_with_object({}) do |desc, sum|
-      abs_path = desc.source_path.sub(options[:templates_dir], '')
-      sum[abs_path] ||= {}
-      sum[abs_path][desc.locale] = '/' + desc.path
+    # This generates a lookup hash that maps the real path (as seen by the web
+    # page user) to the paths of the localized versions. The lookup is later
+    # used by `url_for '/some/page.html', :locale => :en` and other url
+    # helpers.
+    #
+    # For example (given :mount_at_root => :es) and localized paths:
+    #
+    # @lookup['/en/magic/stuff.html'] = {:en => '/en/magic/stuff.html', :de => '/de/magisches/zeug.html', :es => '/magico/cosas.html'}
+    # @lookup['/de/index.html'] = {:en => '/en/index.html', :de => '/de/index.html', :es => '/index.html'}
+    # @lookup['/en/index.html'] = {:en => '/en/index.html', :de => '/de/index.html', :es => '/index.html'}
+    # @lookup['/index.html'] = {:en => '/en/index.html', :de => '/de/index.html', :es => '/index.html'}
+    #
+    # We do this by grouping by the source paths with the locales removed. All
+    # the localized pages with the same content in different languages get the
+    # same key.
+    #
+    @source_path_group = new_resources.group_by do |resource|
+      # Try to get source path without extension
+      _locale, path, _page_id = parse_locale_extension(resource.source_path)
+
+      # If that fails, there is no extension, so we use the original path. We
+      # can not use resource.path here, because .path may be translated, so the
+      # file names do not match up.
+      path ||= resource.source_path
+
+      # This will contain the localizable/ directory, but that does not matter,
+      # because it will be contained in both alternatives above, so the
+      # grouping key will be correct.
+      path
+    end
+
+    # Then we walk this grouped hash and generate the lookup table as given
+    # above.
+    @lookup = {}
+    @source_path_group.each do |_path, resources|
+      # For each group we generate a list of the paths the user really sees
+      # (e.g. ['/en/index.html', '/de/index.html', '/index.html'])
+      exposed_paths = resources.map(&:path)
+
+      # We also generate a map with the same infos, but with the locales as keys.
+      # e.g. {:en => '/en/index.html', :de => '/de/index.html', :es => '/index.html'}
+      locale_map = resources.each_with_object({}) do |resource, map|
+        map[resource.locale] = '/' + resource.path
+      end
+
+      # Then we add those to the lookup table, so every path has a
+      # cross-reference to any other path in other locales.
+      exposed_paths.each do |path|
+        @lookup['/' + path] = locale_map
+      end
     end
 
-    new_resources.reduce(resources) do |sum, r|
-      r.execute_descriptor(app, sum)
+    new_resources.each do |r|
+      r.execute_descriptor(app, resource_list)
     end
   end
 
   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?('/')
+    lookup = ::Middleman::Util.parse_uri(path)
+    lookup.path << app.config[:index_file] if lookup.path&.end_with?('/')
 
-    @lookup[lookup_path] && @lookup[lookup_path][locale]
+    if @lookup[lookup.path] && @lookup[lookup.path][locale]
+      lookup.path = @lookup[lookup.path][locale]
+      lookup.to_s
+    end
+  rescue ::Addressable::URI::InvalidURIError
+    nil
   end
 
   Contract Symbol => String
@@ -270,10 +327,10 @@ class Middleman::CoreExtensions::Internationalization < ::Middleman::Extension
   end
 
   LocalizedPageDescriptor = Struct.new(:path, :source_path, :locale) do
-    def execute_descriptor(app, resources)
+    def execute_descriptor(app, resource_list)
       r = ::Middleman::Sitemap::ProxyResource.new(app.sitemap, path, source_path)
-      r.add_metadata options: { locale: locale }
-      resources + [r]
+      r.add_metadata_options(locale: locale)
+      resource_list.add! r
     end
   end
 
@@ -282,10 +339,12 @@ class Middleman::CoreExtensions::Internationalization < ::Middleman::Extension
     old_locale = ::I18n.locale
     ::I18n.locale = locale
     localized_page_id = ::I18n.t("paths.#{page_id}", default: page_id, fallback: false)
+
     partially_localized_path = ''
 
     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, fallback: false)}"
     end