middleman-core 3.3.12 → 4.4.2

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

@@ -1,21 +1,25 @@
-require 'active_support/core_ext/hash/keys'
+# Core Pathname library used for traversal
 require 'pathname'
 
-# Parsing YAML frontmatter
-require 'yaml'
+# DbC
+require 'middleman-core/contracts'
+
+require 'active_support/core_ext/hash/keys'
 
-# Parsing JSON frontmatter
-require 'active_support/json'
+require 'middleman-core/util/data'
 
 # Extensions namespace
 module Middleman::CoreExtensions
   class FrontMatter < ::Middleman::Extension
-    YAML_ERRORS = [StandardError]
+    # Try to run after routing but before directory_indexes
+    self.resource_list_manipulator_priority = 20
 
-    # https://github.com/tenderlove/psych/issues/23
-    if defined?(Psych) && defined?(Psych::SyntaxError)
-      YAML_ERRORS << Psych::SyntaxError
-    end
+    # Set textual delimiters that denote the start and end of frontmatter
+    define_setting :frontmatter_delims, {
+      json: [%w(;;; ;;;)],
+      toml: [%w(+++ +++)],
+      yaml: [%w(--- ---), %w(--- ...)]
+    }, 'Allowed frontmatter delimiters'
 
     def initialize(app, options_hash={}, &block)
       super
@@ -24,192 +28,67 @@ module Middleman::CoreExtensions
     end
 
     def before_configuration
-      ext = self
-      app.files.changed { |file| ext.clear_data(file) }
-      app.files.deleted { |file| ext.clear_data(file) }
+      app.files.on_change(:source, &method(:clear_data))
     end
 
-    def after_configuration
-      app.extensions[:frontmatter] = self
-      app.ignore %r{\.frontmatter$}
-
-      ::Middleman::Sitemap::Resource.send :include, ResourceInstanceMethods
+    # @return Array<Middleman::Sitemap::Resource>
+    Contract ResourceList => ResourceList
+    def manipulate_resource_list(resources)
+      resources.each do |resource|
+        next if resource.binary?
+        next if resource.file_descriptor.nil?
+        next if resource.file_descriptor[:types].include?(:no_frontmatter)
 
-      app.sitemap.provides_metadata do |path|
-        fmdata = data(path).first
+        fmdata = data(resource.file_descriptor[:full_path].to_s).first.dup
 
-        data = {}
-        [:layout, :layout_engine].each do |opt|
-          data[opt] = fmdata[opt] unless fmdata[opt].nil?
-        end
+        # Copy over special options
+        # TODO: Should we make people put these under "options" instead of having
+        # special known keys?
+        opts = fmdata.extract!(:layout, :layout_engine, :renderer_options, :directory_index, :content_type)
+        opts[:renderer_options].symbolize_keys! if opts.key?(:renderer_options)
 
-        { options: data, page: ::Middleman::Util.recursively_enhance(fmdata).freeze }
-      end
-    end
+        ignored = fmdata.delete(:ignored)
 
-    module ResourceInstanceMethods
-      def ignored?
-        if !proxy? && raw_data[:ignored] == true
-          true
-        else
-          super
-        end
-      end
+        # TODO: Enhance data? NOOOO
+        # TODO: stringify-keys? immutable/freeze?
 
-      # This page's frontmatter without being enhanced for access by either symbols or strings.
-      # Used internally
-      # @private
-      # @return [Hash]
-      def raw_data
-        data = app.extensions[:frontmatter].data(source_file).first
+        resource.add_metadata options: opts, page: fmdata
 
-        if proxy?
-          url_data = app.extensions[:frontmatter].data(File.join(app.source_dir, url).chomp('/')).first
-          data     = data.deep_merge(url_data)
-        end
-
-        data
-      end
+        resource.ignore! if ignored == true && !resource.is_a?(::Middleman::Sitemap::ProxyResource)
 
-      # This page's frontmatter
-      # @return [Hash]
-      def data
-        @enhanced_data ||= ::Middleman::Util.recursively_enhance(raw_data).freeze
-      end
-
-      # Override Resource#content_type to take into account frontmatter
-      def content_type
-        # Allow setting content type in frontmatter too
-        raw_data.fetch :content_type do
-          super
-        end
+        # TODO: Save new template here somewhere?
       end
     end
 
-    helpers do
-      # Get the template data from a path
-      # @param [String] path
-      # @return [String]
-      def template_data_for_file(path)
-        extensions[:frontmatter].data(path).last
-      end
+    # Get the template data from a path
+    # @param [String] path
+    # @return [String]
+    Contract String => Maybe[String]
+    def template_data_for_file(path)
+      data(path).last
     end
 
+    Contract String => [Hash, Maybe[String]]
     def data(path)
-      p = normalize_path(path)
-      @cache[p] ||= begin
-        data, content = frontmatter_and_content(p)
+      file = app.files.find(:source, path)
 
-        if app.files.exists?("#{path}.frontmatter")
-          external_data, _ = frontmatter_and_content("#{p}.frontmatter")
-          data = external_data.deep_merge(data)
-        end
+      return [{}, nil] unless file
 
-        [data, content]
-      end
-    end
-
-    def clear_data(file)
-      # Copied from Sitemap::Store#file_to_path, but without
-      # removing the file extension
-      file = File.join(app.root, file)
-      prefix = app.source_dir.sub(/\/$/, '') + '/'
-      return unless file.include?(prefix)
-      path = file.sub(prefix, '').sub(/\.frontmatter$/, '')
-
-      @cache.delete(path)
-    end
+      file_path = file[:full_path].to_s
 
-    private
-
-    # Parse YAML frontmatter out of a string
-    # @param [String] content
-    # @return [Array<Hash, String>]
-    def parse_yaml_front_matter(content, full_path)
-      yaml_regex = /\A(---\s*\n.*?\n?)^((---|\.\.\.)\s*$\n?)/m
-      if content =~ yaml_regex
-        content = content.sub(yaml_regex, '')
-
-        begin
-          data = YAML.load($1) || {}
-          data = data.symbolize_keys
-        rescue *YAML_ERRORS => e
-          app.logger.error "YAML Exception parsing #{full_path}: #{e.message}"
-          return false
-        end
-      else
-        return false
+      @cache[file_path] ||= begin
+        ::Middleman::Util::Data.parse(
+          file,
+          app.config[:frontmatter_delims]
+        )
       end
-
-      [data, content]
-    rescue
-      [{}, content]
     end
 
-    def parse_json_front_matter(content, full_path)
-      json_regex = /\A(;;;\s*\n.*?\n?)^(;;;\s*$\n?)/m
-
-      if content =~ json_regex
-        content = content.sub(json_regex, '')
-
-        begin
-          json = ($1 + $2).sub(';;;', '{').sub(';;;', '}')
-          data = ActiveSupport::JSON.decode(json).symbolize_keys
-        rescue => e
-          app.logger.error "JSON Exception parsing #{full_path}: #{e.message}"
-          return false
-        end
-
-      else
-        return false
-      end
-
-      [data, content]
-    rescue
-      [{}, content]
-    end
-
-    # Get the frontmatter and plain content from a file
-    # @param [String] path
-    # @return [Array<Thor::CoreExt::HashWithIndifferentAccess, String>]
-    def frontmatter_and_content(path)
-      full_path = if Pathname(path).relative?
-        File.join(app.source_dir, path)
-      else
-        path
-      end
-
-      data = {}
-
-      return [data, nil] if !app.files.exists?(full_path) || ::Middleman::Util.binary?(full_path)
-
-      # Avoid weird race condition when a file is renamed.
-      content = begin
-        File.read(full_path)
-      rescue ::EOFError
-      rescue ::IOError
-      rescue ::Errno::ENOENT
-        ''
+    Contract ArrayOf[IsA['Middleman::SourceFile']], ArrayOf[IsA['Middleman::SourceFile']] => Any
+    def clear_data(updated_files, removed_files)
+      (updated_files + removed_files).each do |file|
+        @cache.delete(file[:full_path].to_s)
       end
-
-      begin
-        if content =~ /\A.*coding:/
-          lines = content.split(/\n/)
-          lines.shift
-          content = lines.join("\n")
-        end
-
-        result = parse_yaml_front_matter(content, full_path) || parse_json_front_matter(content, full_path)
-        return result if result
-      rescue
-        # Probably a binary file, move on
-      end
-
-      [data, content]
-    end
-
-    def normalize_path(path)
-      path.sub(%r{^#{Regexp.escape(app.source_dir)}\/}, '')
     end
   end
 end

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

@@ -0,0 +1,307 @@
+class Middleman::CoreExtensions::Internationalization < ::Middleman::Extension
+  option :no_fallbacks, false, 'Disable I18n fallbacks'
+  option :locales, nil, 'List of locales, will autodiscover by default'
+  option :langs, nil, 'Backwards compatibility if old option name. Use `locales` instead.'
+  option :locale_map, {}, 'Locale shortname map'
+  option :lang_map, nil, 'Backwards compatibility if old option name. Use `locale_map` instead.'
+  option :path, '/:locale/', 'URL prefix path'
+  option :templates_dir, 'localizable', 'Location of templates to be localized'
+  option :mount_at_root, nil, 'Mount a specific locale at the root of the site'
+  option :data, 'locales', 'The directory holding your locale configurations'
+
+  # Exposes `locales` to templates
+  expose_to_template :locales, :langs, :locale, :lang
+
+  def initialize(*)
+    super
+
+    require 'i18n'
+
+    options[:locales] = options[:langs] unless options[:langs].nil?
+
+    options[:locale_map] = options[:lang_map] unless options[:lang_map].nil?
+
+    # Don't fail on invalid locale, that's not what our current
+    # users expect.
+    ::I18n.enforce_available_locales = false
+
+    # This is for making the tests work - since the tests
+    # 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
+    end
+  end
+
+  def after_configuration
+    # See https://github.com/svenfuchs/i18n/wiki/Fallbacks
+    unless options[:no_fallbacks]
+      require 'i18n/backend/fallbacks'
+      ::I18n::Backend::Simple.send(:include, ::I18n::Backend::Fallbacks)
+    end
+
+    locales_file_path = options[:data]
+
+    # Tell the file watcher to observe the :data_dir
+    app.files.watch :locales,
+                    path: File.join(app.root, locales_file_path),
+                    only: /.*(rb|yml|yaml)$/
+
+    # Setup data files before anything else so they are available when
+    # parsing config.rb
+    app.files.on_change(:locales, &method(:on_file_changed))
+
+    @maps = {}
+    @mount_at_root = options[:mount_at_root].nil? ? locales.first : options[:mount_at_root]
+
+    configure_i18n
+
+    logger.info "== Locales: #{locales.join(', ')} (Default #{@mount_at_root})"
+  end
+
+  helpers do
+    def t(*args)
+      ::I18n.t(*args)
+    end
+
+    def url_for(path_or_resource, options={})
+      locale = options.delete(:locale) || ::I18n.locale
+
+      opts = options.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
+
+      opts[:relative] = should_relativize
+      opts[:anchor] = anchor
+
+      begin
+        super(final_path, opts)
+      rescue RuntimeError
+        super(path_or_resource, options)
+      end
+    end
+
+    def locate_partial(partial_name, try_static=false)
+      locals_dir = extensions[:i18n].options[:templates_dir]
+
+      # Try /localizable
+      partials_path = File.join(locals_dir, partial_name)
+
+      locale_suffix = ::I18n.locale
+
+      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
+
+      if locale_suffix
+        super(suffixed_partial_name, maybe_static) ||
+          super(File.join(locals_dir, suffixed_partial_name), maybe_static) ||
+          super(partials_path, try_static) ||
+          super
+      else
+        super(partials_path, try_static) ||
+          super
+      end
+    end
+  end
+
+  Contract ArrayOf[Symbol]
+  def locales
+    @locales ||= known_locales
+  end
+
+  # Backwards API compat
+  alias langs locales
+
+  Contract Symbol
+  def locale
+    ::I18n.locale
+  end
+
+  # Backwards API compat
+  alias lang locale
+
+  # Update the main sitemap resource list
+  # @return Array<Middleman::Sitemap::Resource>
+  Contract ResourceList => ResourceList
+  def manipulate_resource_list(resources)
+    new_resources = []
+
+    file_extension_resources = resources.select do |resource|
+      parse_locale_extension(resource.path)
+    end
+
+    localizable_folder_resources = resources.select do |resource|
+      !file_extension_resources.include?(resource) && File.fnmatch?(File.join(options[:templates_dir], '**'), resource.path)
+    end
+
+    # If it's a "localizable template"
+    localizable_folder_resources.each do |resource|
+      next if resource.ignored?
+
+      page_id = File.basename(resource.path, File.extname(resource.path))
+      locales.each do |locale|
+        # Remove folder name
+        path = resource.path.sub(options[:templates_dir], '')
+        new_resources << build_resource(path, resource.path, page_id, locale)
+      end
+
+      resource.ignore!
+
+      # 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 }
+    end
+
+    # If it uses file extension localization
+    file_extension_resources.each do |resource|
+      next if resource.ignored?
+
+      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!
+    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
+    end
+
+    new_resources.reduce(resources) do |sum, r|
+      r.execute_descriptor(app, sum)
+    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[lookup_path] && @lookup[lookup_path][locale]
+  end
+
+  Contract Symbol => String
+  def path_root(locale)
+    if (options[:mount_at_root] == locale) || (options[:mount_at_root].nil? && locales[0] == locale)
+      '/'
+    else
+      replacement = options[:locale_map][locale] || locale
+      options[:path].sub(':locale', replacement.to_s).sub(':lang', replacement.to_s) # Backward compat
+    end
+  end
+
+  private
+
+  def on_file_changed(_updated_files, _removed_files)
+    ::I18n.load_path |= app.files.by_type(:locales).files.map { |p| p[:full_path].to_s }
+    ::I18n.reload!
+
+    @app.sitemap.rebuild_resource_list!(:touched_locale_file)
+  end
+
+  def configure_i18n
+    ::I18n.load_path |= app.files.by_type(:locales).files.map { |p| p[:full_path].to_s }
+    ::I18n.reload!
+
+    ::I18n.default_locale = @mount_at_root
+
+    # Reset fallbacks to fall back to our new default
+    ::I18n.fallbacks = ::I18n::Locale::Fallbacks.new if ::I18n.respond_to?(:fallbacks)
+  end
+
+  Contract ArrayOf[Symbol]
+  def known_locales
+    if options[:locales]
+      Array(options[:locales]).map(&:to_sym)
+    else
+      known_locales = app.files.by_type(:locales).files.select do |p|
+        p[:relative_path].to_s.split(File::SEPARATOR).length == 1
+      end
+
+      known_locales.map do |p|
+        File.basename(p[:relative_path].to_s).sub(/\.ya?ml$/, '').sub(/\.rb$/, '')
+      end.sort.map(&:to_sym)
+    end
+  end
+
+  # Parse locale extension filename
+  # @return [locale, path, basename]
+  # will return +nil+ if no locale extension
+  Contract String => Maybe[[Symbol, String, String]]
+  def parse_locale_extension(path)
+    path_bits = path.split('.')
+    return nil if path_bits.size < 3
+
+    locale = path_bits.delete_at(-2).to_sym
+    return nil unless locales.include?(locale)
+
+    path = path_bits.join('.')
+    basename = File.basename(path_bits[0..-2].join('.'))
+    [locale, path, basename]
+  end
+
+  LocalizedPageDescriptor = Struct.new(:path, :source_path, :locale) do
+    def execute_descriptor(app, resources)
+      r = ::Middleman::Sitemap::ProxyResource.new(app.sitemap, path, source_path)
+      r.add_metadata options: { locale: locale }
+      resources + [r]
+    end
+  end
+
+  Contract String, String, String, Symbol => LocalizedPageDescriptor
+  def build_resource(path, source_path, page_id, locale)
+    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
+
+    path = "#{partially_localized_path}/#{File.basename(path)}"
+
+    prefix = path_root(locale)
+
+    # path needs to be changed if file has a localizable extension. (options[mount_at_root] == locale)
+    path = ::Middleman::Util.normalize_path(
+      File.join(prefix, path.sub(page_id, localized_page_id))
+    )
+
+    path = path.sub(options[:templates_dir] + '/', '')
+
+    ::I18n.locale = old_locale
+
+    LocalizedPageDescriptor.new(path, source_path, locale)
+  end
+end