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

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

@@ -19,7 +19,8 @@ module Middleman
 
         return unless File.exist?(helpers_path)
 
-        Dir[File.join(helpers_path, app.config[:helpers_filename_glob])].each do |filename|
+        glob = File.join(helpers_path, app.config[:helpers_filename_glob])
+        ::Middleman::Util.glob_directory(glob).each do |filename|
           module_name = app.config[:helpers_filename_to_module_name_proc].call(filename)
           next unless module_name
 

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

@@ -12,7 +12,7 @@ require 'middleman-core/util/data'
 module Middleman::CoreExtensions
   class FrontMatter < ::Middleman::Extension
     # Try to run after routing but before directory_indexes
-    self.resource_list_manipulator_priority = 10
+    self.resource_list_manipulator_priority = 20
 
     def initialize(app, options_hash={}, &block)
       super
@@ -65,7 +65,10 @@ module Middleman::CoreExtensions
 
       return [{}, nil] unless file
 
-      @cache[file[:full_path]] ||= ::Middleman::Util::Data.parse(file[:full_path])
+      @cache[file[:full_path]] ||= ::Middleman::Util::Data.parse(
+        file[:full_path],
+        app.config[:frontmatter_delims]
+      )
     end
 
     Contract ArrayOf[IsA['Middleman::SourceFile']], ArrayOf[IsA['Middleman::SourceFile']] => Any

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

@@ -50,9 +50,6 @@ class Middleman::CoreExtensions::Internationalization < ::Middleman::Extension
     @maps = {}
     @mount_at_root = options[:mount_at_root].nil? ? langs.first : options[:mount_at_root]
 
-    # Don't output localizable files
-    app.ignore File.join(options[:templates_dir], '**')
-
     configure_i18n
 
     logger.info "== Locales: #{langs.join(', ')} (Default #{@mount_at_root})"
@@ -63,13 +60,40 @@ class Middleman::CoreExtensions::Internationalization < ::Middleman::Extension
       ::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]
+
+      opts[:relative] = false
+
+      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
+
+      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)
 
-      lang_suffix = current_resource.metadata[:locals] && current_resource.metadata[:locals][:lang]
+      lang_suffix = ::I18n.locale
 
       extname = File.extname(partial_name)
       maybe_static = extname.length > 0
@@ -102,29 +126,56 @@ class Middleman::CoreExtensions::Internationalization < ::Middleman::Extension
   def manipulate_resource_list(resources)
     new_resources = []
 
-    resources.each do |resource|
-      # If it uses file extension localization
-      if result = parse_locale_extension(resource.path)
-        ext_lang, path, page_id = result
-        new_resources << build_resource(path, resource.path, page_id, ext_lang)
-      # If it's a "localizable template"
-      elsif File.fnmatch?(File.join(options[:templates_dir], '**'), resource.path)
-        page_id = File.basename(resource.path, File.extname(resource.path))
-        langs.each do |lang|
-          # Remove folder name
-          path = resource.path.sub(options[:templates_dir], '')
-          new_resources << build_resource(path, resource.path, page_id, lang)
-        end
+    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|
+      page_id = File.basename(resource.path, File.extname(resource.path))
+      langs.each do |lang|
+        # Remove folder name
+        path = resource.path.sub(options[:templates_dir], '')
+        new_resources << build_resource(path, resource.path, page_id, lang)
       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[:lang]
+      # next if resource.options[:lang]
 
-      resource.add_metadata options: { lang: @mount_at_root }, locals: { lang: @mount_at_root }
+      # $stderr.puts "Defaulting #{resource.path} to #{@mount_at_root}"
+      # resource.add_metadata options: { lang: @mount_at_root }, locals: { lang: @mount_at_root }
     end
 
-    resources + new_resources
+    # If it uses file extension localization
+    file_extension_resources.each do |resource|
+      result = parse_locale_extension(resource.path)
+      ext_lang, path, page_id = result
+      new_resources << build_resource(path, resource.path, page_id, ext_lang)
+
+      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.lang] = '/' + desc.path
+    end
+
+    resources + new_resources.map { |r| r.to_resource(app) }
+  end
+
+  def localized_path(path, lang)
+    lookup_path = path.dup
+    lookup_path << app.config[:index_file] if lookup_path.end_with?('/')
+
+    @lookup[lookup_path] && @lookup[lookup_path][lang]
   end
 
   private
@@ -132,12 +183,12 @@ class Middleman::CoreExtensions::Internationalization < ::Middleman::Extension
   def on_file_changed(_updated_files, _removed_files)
     @_langs = nil # Clear langs cache
 
-    # TODO, add new file to ::I18n.load_path
+    ::I18n.load_path |= app.files.by_type(:locales).files.map { |p| p[:full_path].to_s }
     ::I18n.reload!
   end
 
   def configure_i18n
-    ::I18n.load_path += app.files.by_type(:locales).files.map { |p| p[:full_path].to_s }
+    ::I18n.load_path |= app.files.by_type(:locales).files.map { |p| p[:full_path].to_s }
     ::I18n.reload!
 
     ::I18n.default_locale = @mount_at_root
@@ -155,9 +206,9 @@ class Middleman::CoreExtensions::Internationalization < ::Middleman::Extension
         p[:relative_path].to_s.split(File::SEPARATOR).length == 1
       end
 
-      known_langs.map { |p|
+      known_langs.map do |p|
         File.basename(p[:relative_path].to_s).sub(/\.ya?ml$/, '').sub(/\.rb$/, '')
-      }.sort.map(&:to_sym)
+      end.sort.map(&:to_sym)
     end
   end
 
@@ -177,12 +228,29 @@ class Middleman::CoreExtensions::Internationalization < ::Middleman::Extension
     [lang, path, basename]
   end
 
-  Contract String, String, String, Symbol => IsA['Middleman::Sitemap::Resource']
+  LocalizedPageDescriptor = Struct.new(:path, :source_path, :lang) do
+    def to_resource(app)
+      r = ::Middleman::Sitemap::ProxyResource.new(app.sitemap, path, source_path)
+      r.add_metadata options: { lang: lang }
+      r
+    end
+  end
+
+  Contract String, String, String, Symbol => LocalizedPageDescriptor
   def build_resource(path, source_path, page_id, lang)
     old_locale = ::I18n.locale
     ::I18n.locale = lang
     localized_page_id = ::I18n.t("paths.#{page_id}", default: page_id, fallback: [])
 
+    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).to_s)}"
+    end
+
+    path = "#{partially_localized_path}/#{File.basename(path)}"
+
     prefix = if (options[:mount_at_root] == lang) || (options[:mount_at_root].nil? && langs[0] == lang)
       '/'
     else
@@ -197,10 +265,8 @@ class Middleman::CoreExtensions::Internationalization < ::Middleman::Extension
 
     path = path.sub(options[:templates_dir] + '/', '')
 
-    p = ::Middleman::Sitemap::ProxyResource.new(app.sitemap, path, source_path)
-    p.add_metadata locals: { lang: lang, page_id: path }, options: { lang: lang }
-
     ::I18n.locale = old_locale
-    p
+
+    LocalizedPageDescriptor.new(path, source_path, lang)
   end
 end

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

@@ -4,7 +4,7 @@ module Middleman
     class Routing < Extension
       # This should always run late, but not as late as :directory_indexes,
       # so it can add metadata to any pages generated by other extensions
-      self.resource_list_manipulator_priority = 80
+      self.resource_list_manipulator_priority = 10
 
       # Expose the `page` method to config.
       expose_to_config :page
@@ -28,7 +28,7 @@ module Middleman
       PageDescriptor = Struct.new(:path, :metadata)
 
       # The page method allows options to be set for a given source path, regex, or glob.
-      # Options that may be set include layout, locals, proxy, andx ignore.
+      # Options that may be set include layout, locals, andx ignore.
       #
       # @example
       #   page '/about.html', layout: false

data/lib/middleman-core/dns_resolver.rb

@@ -0,0 +1,73 @@
+require 'resolv'
+require 'middleman-core/dns_resolver/network_resolver'
+require 'middleman-core/dns_resolver/hosts_resolver'
+
+module Middleman
+  # This resolves IP address to names and vice versa
+  class DnsResolver
+    private
+
+    attr_reader :resolvers
+
+    public
+
+    # Create resolver
+    #
+    # First the local resolver is used. If environment variable HOSTSRC is
+    # given this file is used for local name lookup.
+    #
+    # @param [#getnames, #getaddresses] network_resolver
+    #   The resolver which uses a network name server to resolve ip addresses
+    #   and names.
+    #
+    # @param [#getnames, #getaddresses] local_resolver
+    #   The resolver uses /etc/hosts on POSIX-systems and
+    #   C:\Windows\System32\drivers\etc\hosts on Windows-operating systems to
+    #   resolve ip addresses and names.
+    #
+    # First the local resolver is queried. If this raises an error or returns
+    # nil or [] the network resolver is queried.
+    def initialize(opts={})
+      @resolvers = []
+      @resolvers << opts.fetch(:hosts_resolver, HostsResolver.new)
+
+      if RUBY_VERSION >= '2.1'
+        require 'middleman-core/dns_resolver/local_link_resolver'
+        @resolvers << opts.fetch(:local_link_resolver, LocalLinkResolver.new)
+      end
+
+      @resolvers << opts.fetch(:network_resolver, NetworkResolver.new)
+    end
+
+    # Get names for given ip
+    #
+    # @param [String] ip
+    #   The ip which should be resolved.
+    def names_for(ip)
+      resolvers.each do |r|
+        names = r.getnames(ip)
+
+        return names unless names.nil? || names.empty?
+      end
+
+      []
+    end
+
+    # Get ips for given name
+    #
+    # First the local resolver is used. On POSIX-systems /etc/hosts is used. On
+    # Windows C:\Windows\System32\drivers\etc\hosts is used.
+    #
+    # @param [String] name
+    #   The name which should be resolved.
+    def ips_for(name)
+      resolvers.each do |r|
+        ips = r.getaddresses(name)
+
+        return ips unless ips.nil? || ips.empty?
+      end
+
+      []
+    end
+  end
+end

data/lib/middleman-core/dns_resolver/basic_network_resolver.rb

@@ -0,0 +1,52 @@
+module Middleman
+  class DnsResolver
+    # Use network name server to resolve ips and names
+    class BasicNetworkResolver
+      private
+
+      attr_reader :resolver, :timeouts
+
+      public
+
+      def initialize(opts={})
+        @timeouts = opts.fetch(:timeouts, 2)
+      end
+
+      # Get names for ip
+      #
+      # @param [#to_s] ip
+      #   The ip to resolve into names
+      #
+      # @return [Array]
+      #   Array of Names
+      def getnames(ip)
+        resolver.getnames(ip.to_s).map(&:to_s)
+      rescue Resolv::ResolvError, Errno::EADDRNOTAVAIL
+        []
+      end
+
+      # Get ips for name
+      #
+      # @param [#to_s] name
+      #   The name to resolve into ips
+      #
+      # @return [Array]
+      #   Array of ipaddresses
+      def getaddresses(name)
+        resolver.getaddresses(name.to_s).map(&:to_s)
+      rescue Resolv::ResolvError, Errno::EADDRNOTAVAIL
+        []
+      end
+
+      # Set timeout for lookup
+      #
+      # @param [Integer] value
+      #   The timeout value
+      def timeouts=(timeouts)
+        return if RUBY_VERSION < '2'
+
+        resolver.timeouts = timeouts
+      end
+    end
+  end
+end

data/lib/middleman-core/dns_resolver/hosts_resolver.rb

@@ -0,0 +1,63 @@
+module Middleman
+  class DnsResolver
+    # Use network name server to resolve ips and names
+    class HostsResolver
+      private
+
+      attr_reader :resolver
+
+      public
+
+      def initialize(opts={})
+        # using the splat operator works around a non-existing HOSTSRC variable
+        # using nil as input does not work, but `*[]` does and then Resolv::Hosts
+        # uses its defaults
+        @resolver = opts.fetch(:resolver, Resolv::Hosts.new(*hosts_file))
+      end
+
+      # Get names for ip
+      #
+      # @param [#to_s] ip
+      #   The ip to resolve into names
+      #
+      # @return [Array]
+      #   Array of Names
+      def getnames(ip)
+        resolver.getnames(ip.to_s).map(&:to_s)
+      rescue Resolv::ResolvError
+        []
+      end
+
+      # Get ips for name
+      #
+      # @param [#to_s] name
+      #   The name to resolve into ips
+      #
+      # @return [Array]
+      #   Array of ipaddresses
+      def getaddresses(name)
+        resolver.getaddresses(name.to_s).map(&:to_s)
+      rescue Resolv::ResolvError
+        []
+      end
+
+      private
+
+      # Path to hosts file
+      #
+      # This looks for MM_HOSTSRC in your environment
+      #
+      # @return [Array]
+      #   This needs to be an array, to make the splat operator work
+      #
+      # @example
+      #   # <ip> <hostname>
+      #   127.0.0.1 localhost.localhost localhost
+      def hosts_file
+        return [ENV['MM_HOSTSRC']] if ENV.key?('MM_HOSTSRC') && File.file?(ENV['MM_HOSTSRC'])
+
+        []
+      end
+    end
+  end
+end

data/lib/middleman-core/dns_resolver/local_link_resolver.rb

@@ -0,0 +1,44 @@
+require 'middleman-core/dns_resolver/basic_network_resolver'
+
+module Middleman
+  class DnsResolver
+    # Use network name server to resolve ips and names
+    class LocalLinkResolver < BasicNetworkResolver
+      def initialize(opts={})
+        super
+
+        @timeouts = opts.fetch(:timeouts, 1)
+        @resolver = opts.fetch(:resolver, Resolv::MDNS.new(nameserver_config))
+
+        self.timeouts = timeouts
+      end
+
+      private
+
+      # Hosts + Ports for MDNS resolver
+      #
+      # This looks for MM_MDNSRC in your environment. If you are going to use
+      # IPv6-addresses: Make sure you do not forget to add the port at the end.
+      #
+      # MM_MDNSRC=ip:port ip:port
+      #
+      # @return [Hash]
+      #   Returns the configuration for the nameserver
+      #
+      # @example
+      #   export MM_MDNSRC="224.0.0.251:5353 ff02::fb:5353"
+      #
+      def nameserver_config
+        return unless ENV.key?('MM_MDNSRC') && ENV['MM_MDNSRC']
+
+        address, port = ENV['MM_MDNSRC'].split(/:/)
+
+        {
+          nameserver_port: [[address, port.to_i]]
+        }
+      rescue StandardError
+        {}
+      end
+    end
+  end
+end