middleman-core 4.3.11 → 5.0.0.rc.1

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/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.rb

@@ -0,0 +1,131 @@
+require 'hamster'
+require 'set'
+require 'pathname'
+require 'yaml'
+require 'middleman-core/contracts'
+require 'middleman-core/dependencies/graph'
+require 'middleman-core/dependencies/vertices'
+
+module Middleman
+  module Dependencies
+    include Contracts
+
+    DEFAULT_FILE_PATH = 'deps.yml'.freeze
+    GLOBAL_FILES = ['config.rb', 'lib/**/*.rb', 'helpers/**/*.rb', 'Gemfile.lock'].freeze
+
+    module_function
+
+    Contract IsA['::Middleman::Application'], Graph, Maybe[String] => Any
+    def serialize_and_save(app, graph, file_path = DEFAULT_FILE_PATH)
+      new_output = serialize(app, graph)
+
+      File.open(file_path, 'w') do |file|
+        file.write new_output
+      end
+    end
+
+    Contract IsA['::Middleman::Application'], Graph => Any
+    def visualize_graph(_app, graph)
+      require 'rgl/dot'
+      graph.graph.write_to_graphic_file('jpg', 'graph')
+    end
+
+    Contract IsA['::Middleman::Application'], Graph => String
+    def serialize(app, graph)
+      serialized = graph.serialize
+
+      global = Dir.glob(GLOBAL_FILES)
+                  .sort
+                  .each_with_object({}) do |file, sum|
+        p = Pathname(File.expand_path(file)).relative_path_from(app.root_path).to_s
+        sum[p] = ::Middleman::Util.hash_file(file)
+      end
+
+      ::YAML.dump(
+        {
+          'data_depth' => app.config[:data_collection_depth],
+          'global' => global
+        }.merge(serialized)
+      )
+    end
+
+    Contract String => Graph
+    def parse_yaml(file_path)
+      ::YAML.load_file(file_path)
+    rescue StandardError, ::Psych::SyntaxError => error
+      warn "YAML Exception parsing dependency graph: #{error.message}"
+    end
+
+    Contract IsA['::Middleman::Application'], Hash[String, String] => Array[String]
+    def invalidated_global(app, known_files)
+      known_files.keys.reject do |key|
+        p = File.expand_path(key, app.root)
+        !(File.exist? p) || known_files[key] == ::Middleman::Util.hash_file(p)
+      end
+    end
+
+    class InvalidDepsYAML < RuntimeError
+    end
+
+    class ChangedDepth < RuntimeError
+    end
+
+    class InvalidatedGlobalFiles < RuntimeError
+      attr_reader :invalidated
+
+      def initialize(invalidated)
+        super()
+
+        @invalidated = invalidated
+      end
+    end
+
+    Contract IsA['::Middleman::Application'], Maybe[String] => Graph
+    def load_and_deserialize(app, file_path = DEFAULT_FILE_PATH)
+      return Graph.new unless File.exist?(file_path)
+
+      data = parse_yaml(file_path)
+
+      global = data['global']
+
+      raise ChangedDepth if data['data_depth'] != app.config[:data_collection_depth]
+
+      unless (invalidated = invalidated_global(app, global)).empty?
+        raise InvalidatedGlobalFiles, invalidated
+      end
+
+      # Pre-existing vertices (from config.rb)
+      preexisting_vertices = app.data.vertices.each_with_object({}) do |vertex, sum|
+        sum[vertex.key] = vertex
+      end
+
+      vertices = data['vertices'].each_with_object(preexisting_vertices) do |(type, verts), sum|
+        verts.each do |(k, h)|
+          vertex_class = VERTICES_BY_TYPE[type.to_sym]
+          vertex = vertex_class.deserialize(app, k.to_sym, 'hash' => h)
+          if sum[vertex.key.to_sym]
+            sum[vertex.key.to_sym].merge!(vertex)
+          else
+            sum[vertex.key.to_sym] = vertex
+          end
+        end
+      end
+
+      graph = Graph.new
+      vertices.values.each { |v| graph.add_vertex(v) }
+
+      data['edges'].each do |k, deps|
+        deps.each do |d|
+          graph.add_edge_by_key(d.to_sym, k.to_sym)
+        end
+      end
+
+      # require 'rgl/dot'
+      # graph.graph.write_to_graphic_file('jpg', 'valid')
+
+      graph
+    rescue StandardError
+      raise InvalidDepsYAML
+    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.rb

@@ -0,0 +1,18 @@
+require 'middleman-core/dependencies/vertices/data_collection_vertex'
+require 'middleman-core/dependencies/vertices/data_collection_path_vertex'
+require 'middleman-core/dependencies/vertices/file_vertex'
+
+module Middleman
+  module Dependencies
+    VERTICES_BY_TYPE = {
+      DataCollectionVertex::TYPE_ID => DataCollectionVertex,
+      DataCollectionPathVertex::TYPE_ID => DataCollectionPathVertex,
+      FileVertex::TYPE_ID => FileVertex
+    }.freeze
+
+    def self.deserialize_vertex(app, data)
+      vertex_class = VERTICES_BY_TYPE[data['type'].to_sym]
+      vertex_class.deserialize(app, data['key'].to_sym, data['attrs'])
+    end
+  end
+end