middleman-core 4.5.0 → 5.0.0.rc.1

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,18 +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|
+    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
 
@@ -171,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
@@ -187,9 +182,18 @@ 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
 
     # This generates a lookup hash that maps the real path (as seen by the web
@@ -226,7 +230,7 @@ class Middleman::CoreExtensions::Internationalization < ::Middleman::Extension
     # Then we walk this grouped hash and generate the lookup table as given
     # above.
     @lookup = {}
-    @source_path_group.each do |src_path, resources|
+    @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)
@@ -242,24 +246,24 @@ class Middleman::CoreExtensions::Internationalization < ::Middleman::Extension
       exposed_paths.each do |path|
         @lookup['/' + path] = locale_map
       end
-
-      if @mount_at_root == false
-        src_path = src_path.sub(options[:templates_dir] + '/', '')
-        @lookup["/#{src_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
@@ -288,9 +292,7 @@ class Middleman::CoreExtensions::Internationalization < ::Middleman::Extension
     ::I18n.default_locale = @mount_at_root
 
     # Reset fallbacks to fall back to our new default
-    if ::I18n.respond_to?(:fallbacks)
-      ::I18n.fallbacks = ::I18n::Locale::Fallbacks.new(::I18n.default_locale)
-    end
+    ::I18n.fallbacks = ::I18n::Locale::Fallbacks.new if ::I18n.respond_to?(:fallbacks)
   end
 
   Contract ArrayOf[Symbol]
@@ -325,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
 
@@ -337,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
 

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

@@ -47,3 +47,9 @@ Middleman::Extensions.register :less_renderer, auto_activate: :before_configurat
   require 'middleman-core/renderers/less'
   Middleman::Renderers::Less
 end
+
+# Stylus Support
+Middleman::Extensions.register :stylus_renderer, auto_activate: :before_configuration do
+  require 'middleman-core/renderers/stylus'
+  Middleman::Renderers::Stylus
+end

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

@@ -9,25 +9,35 @@ module Middleman
       # Expose the `page` method to config.
       expose_to_config :page
 
-      PageDescriptor = Struct.new(:path, :metadata) do
-        def execute_descriptor(app, resources)
+      PageDescriptor = Struct.new(:path, :locals, :page, :options) do
+        def execute_descriptor(app, resource_list)
           normalized_path = path.dup
 
           if normalized_path.is_a?(String) && !normalized_path.include?('*')
             # Normalize path
             normalized_path = ::Middleman::Util.normalize_path(normalized_path)
-            if normalized_path.end_with?('/') || app.files.by_type(:source).watchers.any? { |w| (w.directory + Pathname(normalized_path)).directory? }
-              normalized_path = ::File.join(normalized_path, app.config[:index_file])
-            end
+            normalized_path = ::File.join(normalized_path, app.config[:index_file]) if normalized_path.end_with?('/') || app.files.by_type(:source).watchers.any? { |w| (w.directory + Pathname(normalized_path)).directory? }
           end
 
           normalized_path = '/' + ::Middleman::Util.strip_leading_slash(normalized_path) if normalized_path.is_a?(String)
 
-          resources
+          resource_list
             .select { |r| ::Middleman::Util.path_match(normalized_path, "/#{r.path}") }
-            .each { |r| r.add_metadata(metadata, true) }
+            .each do |r|
+              r.add_metadata_locals(locals, true) if locals
+
+              if page
+                if page.key?(:id)
+                  resource_list.update!(r, :page_id) do
+                    r.add_metadata_page(page, true)
+                  end
+                else
+                  r.add_metadata_page(page, true)
+                end
+              end
 
-          resources
+              r.add_metadata_options(options, true) if options
+            end
         end
       end
 
@@ -49,20 +59,13 @@ module Middleman
       # @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 Or[String, Regexp], Hash => PageDescriptor
-      def page(path, opts={})
-        options = opts.dup
+      def page(path, options_hash = ::Middleman::EMPTY_HASH)
+        options = options_hash.dup
 
         page_data = options.delete(:data) || {}
         page_data[:id] = options.delete(:id) if options.key?(:id)
 
-        # Default layout
-        metadata = {
-          locals: options.delete(:locals) || {},
-          page: page_data,
-          options: options
-        }
-
-        PageDescriptor.new(path, metadata)
+        PageDescriptor.new(path, options.delete(:locals), page_data, options)
       end
     end
   end

data/lib/middleman-core/core_extensions.rb

@@ -16,13 +16,7 @@ end
 # to dynamic requests.
 Middleman::Extensions.register :data, auto_activate: :before_sitemap do
   require 'middleman-core/core_extensions/data'
-  Middleman::CoreExtensions::Data
-end
-
-# Rewrite embedded URLs via Rack
-Middleman::Extensions.register :inline_url_rewriter, auto_activate: :before_sitemap do
-  require 'middleman-core/core_extensions/inline_url_rewriter'
-  Middleman::CoreExtensions::InlineURLRewriter
+  Middleman::CoreExtensions::Data::DataExtension
 end
 
 # Catch and show exceptions at the Rack level
@@ -100,10 +94,10 @@ Middleman::Extensions.register :minify_css do
   Middleman::Extensions::MinifyCss
 end
 
-# MinifyJavascript compresses JS
+# MinifyJavaScript compresses JS
 Middleman::Extensions.register :minify_javascript do
   require 'middleman-core/extensions/minify_javascript'
-  Middleman::Extensions::MinifyJavascript
+  Middleman::Extensions::MinifyJavaScript
 end
 
 # GZIP assets and pages during build

data/lib/middleman-core/data_proxy.rb

@@ -0,0 +1,69 @@
+require 'hamster'
+require 'middleman-core/contracts'
+require 'middleman-core/core_extensions/data/proxies/array'
+require 'middleman-core/core_extensions/data/proxies/hash'
+require 'middleman-core/dependencies/vertices/data_collection_path_vertex'
+
+module Middleman
+  class DataProxy
+    attr_reader :accessed_keys
+
+    def initialize(ctx)
+      @ctx = ctx
+      @accessed_keys = ::Hamster::Set.new
+    end
+
+    def take_ownership_of_proxies(locs)
+      take_ownership_of_hash(locs)
+    end
+
+    def take_ownership_of_hash(h)
+      h.keys.each_with_object({}) do |key, sum|
+        v = h[key]
+        sum[key] = take_ownership_of_value(v)
+      end
+    end
+
+    def take_ownership_of_array(a)
+      a.map do |v|
+        take_ownership_of_value(v)
+      end
+    end
+
+    def take_ownership_of_value(v)
+      if v.is_a?(::Array)
+        take_ownership_of_array(v)
+      elsif v.is_a?(::Hash)
+        take_ownership_of_hash(v)
+      elsif v.is_a?(::Middleman::CoreExtensions::Data::Proxies::ArrayProxy)
+        v.clone.tap { |p| p._top._replace_parent(self) }
+      elsif v.is_a?(::Middleman::CoreExtensions::Data::Proxies::HashProxy)
+        v.clone.tap { |p| p._top._replace_parent(self) }
+      else
+        v
+      end
+    end
+
+    def log_access(key)
+      return if @accessed_keys.include?(key)
+
+      @accessed_keys <<= key
+
+      @ctx.vertices <<= ::Middleman::Dependencies::DataCollectionPathVertex.from_data(
+        @ctx.app,
+        key
+      )
+    end
+
+    def method_missing(method, *args, &block)
+      return @ctx.internal_data_store.proxied_data(method, self) if @ctx.internal_data_store.key?(method)
+
+      super
+    end
+
+    # Needed so that method_missing makes sense
+    def respond_to?(method, include_private = false)
+      super || @ctx.internal_data_store.key?(method)
+    end
+  end
+end

data/lib/middleman-core/dependencies/edge.rb

@@ -0,0 +1,27 @@
+require 'middleman-core/contracts'
+require 'middleman-core/dependencies/vertices/vertex'
+
+module Middleman
+  module Dependencies
+    class Edge
+      include Contracts
+
+      Contract Vertex
+      attr_reader :vertex
+
+      Contract ImmutableSetOf[Vertex]
+      attr_accessor :depends_on
+
+      Contract Vertex, ImmutableSetOf[Vertex] => Any
+      def initialize(vertex, depends_on)
+        @vertex = vertex
+        @depends_on = depends_on
+      end
+
+      Contract String
+      def to_s
+        "#<#{self.class} vertex=#{@vertex} edges=#{@edges}>"
+      end
+    end
+  end
+end

data/lib/middleman-core/dependencies/graph.rb

@@ -0,0 +1,144 @@
+require 'set'
+require 'rgl/adjacency'
+require 'middleman-core/contracts'
+require 'middleman-core/dependencies/vertices/vertex'
+require 'middleman-core/dependencies/edge'
+
+module Middleman
+  module Dependencies
+    class DirectedAdjacencyGraph < ::RGL::DirectedAdjacencyGraph
+      def initialize(*args)
+        super
+
+        @vertices_by_key = {}
+      end
+
+      def add_vertex(v)
+        mv = merged_vertex_or_new(v)
+
+        @vertices_by_key[mv.key] = mv
+
+        super(mv)
+      end
+
+      def add_edge(u, v)
+        super(merged_vertex_or_new(u), merged_vertex_or_new(v))
+      end
+
+      def remove_vertex(vertex)
+        each_adjacent(vertex) do |v|
+          remove_vertex(v) unless v == vertex
+        end
+
+        @vertices_by_key.delete(vertex.key)
+
+        super(vertex)
+      end
+
+      def find_vertex_by_key(key)
+        @vertices_by_key[key]
+      end
+
+      protected
+
+      def merged_vertex_or_new(vertex)
+        found_vertex = find_vertex_by_key(vertex.key)
+
+        if found_vertex
+          found_vertex.merge!(vertex)
+          found_vertex
+        else
+          vertex
+        end
+      end
+    end
+
+    class Graph
+      include Contracts
+
+      Contract DirectedAdjacencyGraph
+      attr_reader :graph
+
+      def initialize(_vertices = {})
+        @graph = DirectedAdjacencyGraph.new
+      end
+
+      def invalidate_vertex!(vertex)
+        @graph.remove_vertex(vertex)
+      end
+
+      Contract Vertex => Any
+      def add_vertex(vertex)
+        @graph.add_vertex(vertex)
+      end
+
+      Contract Vertex, Vertex => Any
+      def add_edge(source, target)
+        if source == target
+          add_vertex(source)
+        else
+          @graph.add_edge(source, target)
+        end
+      end
+
+      Contract Symbol, Symbol => Any
+      def add_edge_by_key(source, target)
+        a = @graph.find_vertex_by_key(source)
+        b = @graph.find_vertex_by_key(target)
+
+        add_edge(a, b)
+      end
+
+      Contract Edge => Any
+      def add_edge_set(edge)
+        return if edge.depends_on.nil?
+
+        edge.depends_on.each do |depended_on|
+          add_edge(depended_on, edge.vertex)
+        end
+      end
+
+      def serialize
+        edges = @graph.edges
+                      .sort_by { |edge| edge.target.key }
+                      .each_with_object({}) do |edge, sum|
+          sum[edge.target.key.to_s] ||= []
+          sum[edge.target.key.to_s] << edge.source.key.to_s
+        end
+
+        # Sort dependencies list
+        edges = edges.each { |(k, v)| edges[k] = v.sort }
+
+        vertices = @graph.vertices
+                         .sort_by { |v| [v.type_id, v.key] }
+                         .each_with_object({}) do |v, sum|
+          s = v.serialize
+          k = s.delete 'key'
+          t = s.delete 'type'
+          a = s.delete 'attrs'
+
+          sum[t] ||= {}
+          sum[t][k] = a['hash']
+        end
+
+        {
+          'edges' => edges,
+          'vertices' => vertices
+        }
+      end
+
+      Contract ImmutableSetOf[Vertex]
+      def invalidated
+        invalidated = @graph.vertices.reject(&:valid?)
+        invalidated.each { |v| @graph.remove_vertex(v) }
+
+        ::Hamster::Set.new(invalidated)
+      end
+
+      Contract IsA['::Middleman::Sitemap::Resource'] => Bool
+      def invalidates_resource?(resource)
+        @graph.vertices.none? { |d| d.matches_resource?(resource) }
+      end
+    end
+  end
+end

data/lib/middleman-core/dependencies/vertices/data_collection_path_vertex.rb

@@ -0,0 +1,78 @@
+require 'hamster'
+require 'middleman-core/contracts'
+require 'middleman-core/dependencies/vertices/vertex'
+require 'middleman-core/core_extensions/data/controller'
+
+module Middleman
+  module Dependencies
+    class DataCollectionPathVertex < Vertex
+      include Contracts
+
+      TYPE_ID = :data_path
+
+      DATA_TYPE = Or[Num, String, Symbol, Hash, Array]
+
+      Contract IsA['::Middleman::Application'], Symbol, Vertex::SERIALIZED_VERTEX_ATTRS => DataCollectionPathVertex
+      def self.deserialize(app, key, attributes)
+        DataCollectionPathVertex.new(key, attributes.symbolize_keys, app.data)
+      end
+
+      Contract IsA['::Middleman::Application'], ArrayOf[Or[Symbol, Num]] => DataCollectionPathVertex
+      def self.from_data(app, path)
+        DataCollectionPathVertex.new(path.map(&:to_s).join('.').to_sym, {}, app.data)
+      end
+
+      Contract Symbol, Vertex::VERTEX_ATTRS, ::Middleman::CoreExtensions::Data::DataStoreController => Any
+      def initialize(key, attributes, controller = nil)
+        super(key, attributes)
+
+        @controller = controller
+      end
+
+      Contract Bool
+      def valid?
+        current_hash == previous_hash
+      end
+
+      Contract Vertex::SERIALIZED_VERTEX
+      def serialize
+        super({
+          hash: current_hash || previous_hash
+        })
+      end
+
+      protected
+
+      Contract Maybe[String]
+      def current_hash
+        @current_hash ||= begin
+          data = lookup_path(key_to_path)
+          ::Middleman::Util.hash_string(data.to_s)
+        end
+      end
+
+      Contract Maybe[String]
+      def previous_hash
+        @attributes[:hash]
+      end
+
+      Contract ArrayOf[Or[Symbol, Num]] => Maybe[DataCollectionPathVertex::DATA_TYPE]
+      def lookup_path(path)
+        path.reduce(@controller) do |sum, part|
+          part == :__full_access__ ? sum : sum[part]
+        end
+      end
+
+      Contract ArrayOf[Or[Symbol, Num]]
+      def key_to_path
+        @key.to_s.split('.').map do |part|
+          begin
+            Integer(part)
+          rescue StandardError
+            part.to_sym
+          end
+        end
+      end
+    end
+  end
+end