middleman-core 4.6.0 → 5.0.0.rc.1

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

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

@@ -0,0 +1,67 @@
+require 'hamster'
+require 'middleman-core/contracts'
+require 'middleman-core/dependencies/vertices/vertex'
+
+module Middleman
+  module Dependencies
+    class DataCollectionVertex < Vertex
+      include Contracts
+
+      TYPE_ID = :data
+
+      DATA_TYPE = Or[Hash, Array]
+
+      Contract Maybe[DATA_TYPE]
+      attr_accessor :data
+
+      Contract IsA['::Middleman::Application'], Symbol, Vertex::SERIALIZED_VERTEX_ATTRS => DataCollectionVertex
+      def self.deserialize(_app, key, attributes)
+        DataCollectionVertex.new(key, attributes.symbolize_keys)
+      end
+
+      Contract Symbol, DATA_TYPE => DataCollectionVertex
+      def self.from_data(key, data)
+        DataCollectionVertex.new(key, {}, data)
+      end
+
+      Contract Symbol, Vertex::VERTEX_ATTRS, Maybe[DATA_TYPE] => Any
+      def initialize(key, attributes, data = nil)
+        super(key, attributes)
+
+        @data = data
+      end
+
+      Contract Bool
+      def valid?
+        current_hash == previous_hash
+      end
+
+      Contract DataCollectionVertex => Any
+      def merge!(other)
+        super
+        @data = other.data if @data.nil?
+      end
+
+      Contract Vertex::SERIALIZED_VERTEX
+      def serialize
+        super({
+          hash: current_hash || previous_hash
+        })
+      end
+
+      protected
+
+      Contract Maybe[String]
+      def current_hash
+        return nil if @data.nil?
+
+        @current_hash ||= ::Middleman::Util.hash_string(@data.to_s)
+      end
+
+      Contract Maybe[String]
+      def previous_hash
+        @attributes[:hash]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+require 'pathname'
+require 'middleman-core/contracts'
+require 'middleman-core/dependencies/vertices/vertex'
+
+module Middleman
+  module Dependencies
+    class FileVertex < Vertex
+      include Contracts
+
+      TYPE_ID = :file
+
+      Contract IsA['::Middleman::Application'], Symbol, Vertex::SERIALIZED_VERTEX_ATTRS => FileVertex
+      def self.deserialize(app, key, attributes)
+        FileVertex.new(app.root_path, key, attributes.symbolize_keys)
+      end
+
+      Contract IsA['Middleman::Sitemap::Resource'] => FileVertex
+      def self.from_resource(resource)
+        from_source_file(resource.app, resource.file_descriptor)
+      end
+
+      Contract IsA['::Middleman::Application'], IsA['::Middleman::SourceFile'] => FileVertex
+      def self.from_source_file(app, source_file)
+        FileVertex.new(app.root_path, source_file[:full_path].to_s.to_sym)
+      end
+
+      Contract Or[String, Pathname], Symbol, Maybe[VERTEX_ATTRS] => Any
+      def initialize(root, key, attributes = {})
+        @root = Pathname(root)
+        @full_path = full_path(@root, key.to_s)
+        super(relative_path(@root, key.to_s).to_sym, attributes)
+      end
+
+      Contract Bool
+      def valid?
+        @is_valid = (previous_hash.nil? || hash_file == previous_hash) if @is_valid.nil?
+        @is_valid
+      end
+
+      Contract IsA['Middleman::Sitemap::Resource'] => Bool
+      def matches_resource?(resource)
+        resource.file_descriptor[:full_path].to_s == @full_path
+      end
+
+      Contract Vertex::SERIALIZED_VERTEX
+      def serialize
+        super({
+          hash: valid? && !previous_hash.nil? ? previous_hash : hash_file
+        })
+      end
+
+      private
+
+      Contract Maybe[String]
+      def previous_hash
+        @attributes[:hash]
+      end
+
+      Contract String
+      def hash_file
+        ::Middleman::Util.hash_file(@full_path)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+require 'pathname'
+require 'middleman-core/contracts'
+
+module Middleman
+  module Dependencies
+    class Vertex
+      include Contracts
+
+      VERTEX_KEY = Symbol
+      VERTEX_ATTRS = HashOf[Symbol, String]
+      SERIALIZED_VERTEX_ATTRS = HashOf[String, String]
+      SERIALIZED_VERTEX = {
+        'key' => Any, # Weird type inheritance bug
+        'type' => String,
+        'attrs' => SERIALIZED_VERTEX_ATTRS
+      }.freeze
+
+      Contract VERTEX_KEY
+      attr_reader :key
+
+      Contract VERTEX_ATTRS
+      attr_reader :attributes
+
+      Contract VERTEX_KEY, VERTEX_ATTRS => Any
+      def initialize(key, attributes)
+        @key = key
+        @attributes = attributes
+      end
+
+      Contract Vertex => Bool
+      def ==(other)
+        key == other.key
+      end
+
+      Contract Bool
+      def valid?
+        raise NotImplementedError
+      end
+
+      Contract Vertex => Any
+      def merge!(other)
+        @attributes.merge!(other.attributes)
+      end
+
+      Contract IsA['Middleman::Sitemap::Resource'] => Bool
+      def matches_resource?(_resource)
+        false
+      end
+
+      Contract Maybe[VERTEX_ATTRS] => SERIALIZED_VERTEX
+      def serialize(attributes = {})
+        {
+          'key' => @key.to_s,
+          'type' => type_id.to_s,
+          'attrs' => @attributes.merge(attributes).stringify_keys
+        }
+      end
+
+      Contract String
+      def to_s
+        "<Vertex type=#{type_id} key=#{key}>"
+      end
+
+      Contract Symbol
+      def type_id
+        self.class.const_get :TYPE_ID
+      end
+
+      protected
+
+      Contract Pathname, String => String
+      def relative_path(root, file)
+        Pathname(File.expand_path(file)).relative_path_from(root).to_s
+      end
+
+      Contract Pathname, String => String
+      def full_path(root, file)
+        File.expand_path(file, root)
+      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

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

@@ -8,8 +8,8 @@ module Middleman
 
       public
 
-      def initialize(opts={})
-        @timeouts = opts.fetch(:timeouts, 2)
+      def initialize(options_hash = ::Middleman::EMPTY_HASH)
+        @timeouts = options_hash.fetch(:timeouts, 2)
       end
 
       # Get names for ip
@@ -21,7 +21,7 @@ module Middleman
       #   Array of Names
       def getnames(ip)
         resolver.getnames(ip.to_s).map(&:to_s)
-      rescue Resolv::ResolvError, Errno::EADDRNOTAVAIL
+      rescue Resolv::ResolvError, Errno::EADDRNOTAVAIL, Errno::ENETUNREACH
         []
       end
 
@@ -34,7 +34,7 @@ module Middleman
       #   Array of ipaddresses
       def getaddresses(name)
         resolver.getaddresses(name.to_s).map(&:to_s)
-      rescue Resolv::ResolvError, Errno::EADDRNOTAVAIL
+      rescue Resolv::ResolvError, Errno::EADDRNOTAVAIL, Errno::ENETUNREACH
         []
       end
 
@@ -43,6 +43,8 @@ module Middleman
       # @param [Integer] value
       #   The timeout value
       def timeouts=(timeouts)
+        return if RUBY_VERSION < '2'
+
         resolver.timeouts = timeouts
       end
     end

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

@@ -8,11 +8,11 @@ module Middleman
 
       public
 
-      def initialize(opts={})
+      def initialize(options_hash = ::Middleman::EMPTY_HASH)
         # 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))
+        @resolver = options_hash.fetch(:resolver, Resolv::Hosts.new(*hosts_file))
       end
 
       # Get names for ip

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

@@ -4,11 +4,11 @@ module Middleman
   class DnsResolver
     # Use network name server to resolve ips and names
     class LocalLinkResolver < BasicNetworkResolver
-      def initialize(opts={})
+      def initialize(options_hash = ::Middleman::EMPTY_HASH)
         super
 
-        @timeouts = opts.fetch(:timeouts, 1)
-        @resolver = opts.fetch(:resolver, Resolv::MDNS.new(nameserver_config))
+        @timeouts = options_hash.fetch(:timeouts, 1)
+        @resolver = options_hash.fetch(:resolver, Resolv::MDNS.new(nameserver_config))
 
         self.timeouts = timeouts
       end

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

@@ -4,10 +4,10 @@ module Middleman
   class DnsResolver
     # Use network name server to resolve ips and names
     class NetworkResolver < BasicNetworkResolver
-      def initialize(opts={})
+      def initialize(options_hash = ::Middleman::EMPTY_HASH)
         super
 
-        @resolver = opts.fetch(:resolver, Resolv::DNS.new(nameserver_config))
+        @resolver = options_hash.fetch(:resolver, Resolv::DNS.new(nameserver_config))
         self.timeouts = timeouts
       end
 

data/lib/middleman-core/dns_resolver.rb

@@ -27,14 +27,16 @@ module Middleman
     #
     # First the local resolver is queried. If this raises an error or returns
     # nil or [] the network resolver is queried.
-    def initialize(opts={})
+    def initialize(options_hash = ::Middleman::EMPTY_HASH)
       @resolvers = []
-      @resolvers << opts.fetch(:hosts_resolver, HostsResolver.new)
+      @resolvers << options_hash.fetch(:hosts_resolver, HostsResolver.new)
 
-      require 'middleman-core/dns_resolver/local_link_resolver'
-      @resolvers << opts.fetch(:local_link_resolver, LocalLinkResolver.new)
+      if RUBY_VERSION >= '2.1'
+        require 'middleman-core/dns_resolver/local_link_resolver'
+        @resolvers << options_hash.fetch(:local_link_resolver, LocalLinkResolver.new)
+      end
 
-      @resolvers << opts.fetch(:network_resolver, NetworkResolver.new)
+      @resolvers << options_hash.fetch(:network_resolver, NetworkResolver.new)
     end
 
     # Get names for given ip