middleman-core 4.5.0 → 5.0.0.rc.1

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

data/lib/middleman-core/extension.rb

@@ -1,6 +1,5 @@
 require 'forwardable'
 require 'memoist'
-require 'active_support/core_ext/class/attribute'
 require 'middleman-core/configuration'
 require 'middleman-core/contracts'
 
@@ -53,14 +52,14 @@ module Middleman
   #
   # Common lifecycle events can be handled by extensions simply by implementing an appropriately-named method:
   #
+  # * {#before_configuration}
   # * {#after_configuration}
-  # * {#after_build}
   # * {#before_build}
+  # * {#after_build}
+  # * {#ready}
   #
   # There are also some less common hooks that can be listened to from within an extension's `initialize` method:
   #
-  # * `app.before_render {|body, path, locs, template_class| ... }` - Manipulate template sources before they are rendered.
-  # * `app.after_render {|content, path, locs, template_class| ... }` - Manipulate output text after a template has been rendered. It is also common to install a Rack middleware to do this instead.
   # * `app.ready { ... }` - Run code once Middleman is ready to serve or build files (after `after_configuration`).
 
   #
@@ -134,8 +133,8 @@ module Middleman
       # @param [Symbol] key The name of the option
       # @param [Object] default The default value for the option
       # @param [String] description A human-readable description of what the option does
-      def option(key, default=nil, description=nil, options={})
-        config.define_setting(key, default, description, options)
+      def option(key, default = nil, description = nil, options_hash = ::Middleman::EMPTY_HASH)
+        config.define_setting(key, default, description, options_hash)
       end
 
       # @api private
@@ -151,8 +150,8 @@ module Middleman
       # @param [Symbol] key The name of the option
       # @param [Object] default The default value for the option
       # @param [String] description A human-readable description of what the option does
-      def define_setting(key, default=nil, description=nil, options={})
-        global_config.define_setting(key, default, description, options)
+      def define_setting(key, default = nil, description = nil, options_hash = ::Middleman::EMPTY_HASH)
+        global_config.define_setting(key, default, description, options_hash)
       end
 
       # Short-hand for simple Sitemap manipulation
@@ -203,12 +202,12 @@ module Middleman
       #   expose_to_application global_name: :local_name
       # @example with Array:
       #   expose_to_application :method1, :method2
-      # @param [Array<Sumbol>, Hash<Symbol, Symbol>] symbols An optional list of symbols representing instance methods to exposed.
+      # @param [Array<Symbol>, Hash<Symbol, Symbol>] symbols An optional list of symbols representing instance methods to exposed.
       # @return [void]
       def expose_to_application(*symbols)
         self.exposed_to_application ||= {}
 
-        if symbols.first && symbols.first.is_a?(Hash)
+        if symbols.first&.is_a?(Hash)
           self.exposed_to_application.merge!(symbols.first)
         elsif symbols.is_a? Array
           symbols.each do |sym|
@@ -223,12 +222,12 @@ module Middleman
       #   expose_to_config global_name: :local_name
       # @example with Array:
       #   expose_to_config :method1, :method2
-      # @param [Array<Sumbol>, Hash<Symbol, Symbol>] symbols An optional list of symbols representing instance methods to exposed.
+      # @param [Array<Symbol>, Hash<Symbol, Symbol>] symbols An optional list of symbols representing instance methods to exposed.
       # @return [void]
       def expose_to_config(*symbols)
         self.exposed_to_config ||= {}
 
-        if symbols.first && symbols.first.is_a?(Hash)
+        if symbols.first&.is_a?(Hash)
           self.exposed_to_config.merge!(symbols.first)
         elsif symbols.is_a? Array
           symbols.each do |sym|
@@ -243,12 +242,12 @@ module Middleman
       #   expose_to_template global_name: :local_name
       # @example with Array:
       #   expose_to_template :method1, :method2
-      # @param [Array<Sumbol>, Hash<Symbol, Symbol>] symbols An optional list of symbols representing instance methods to exposed.
+      # @param [Array<Symbol>, Hash<Symbol, Symbol>] symbols An optional list of symbols representing instance methods to exposed.
       # @return [void]
       def expose_to_template(*symbols)
         self.exposed_to_template ||= {}
 
-        if symbols.first && symbols.first.is_a?(Hash)
+        if symbols.first&.is_a?(Hash)
           self.exposed_to_template.merge!(symbols.first)
         elsif symbols.is_a? Array
           symbols.each do |sym|
@@ -281,7 +280,8 @@ module Middleman
       # @return [void]
       def activated_extension(instance)
         name = instance.class.ext_name
-        return unless @_extension_activation_callbacks && @_extension_activation_callbacks.key?(name)
+        return unless @_extension_activation_callbacks&.key?(name)
+
         @_extension_activation_callbacks[name].each do |block|
           block.arity == 1 ? block.call(instance) : block.call
         end
@@ -306,7 +306,7 @@ module Middleman
     # @param [Hash] options_hash The raw options hash. Subclasses should not manipulate this directly - it will be turned into {#options}.
     # @yield An optional block that can be used to customize options before the extension is activated.
     # @yieldparam [Middleman::Configuration::ConfigurationManager] options Extension options
-    def initialize(app, options_hash={}, &block)
+    def initialize(app, options_hash = ::Middleman::EMPTY_HASH, &block)
       @_helpers = []
       @app = app
 
@@ -404,9 +404,7 @@ module Middleman
       @app.after_configuration do
         ext.after_configuration if ext.respond_to?(:after_configuration)
 
-        if ext.respond_to?(:manipulate_resource_list)
-          ext.app.sitemap.register_resource_list_manipulators(ext.class.ext_name, ext, ext.class.resource_list_manipulator_priority)
-        end
+        ext.app.sitemap.register_resource_list_manipulators(ext.class.ext_name, ext, ext.class.resource_list_manipulator_priority) if ext.respond_to?(:manipulate_resource_list) || ext.respond_to?(:manipulate_resource_list_container!)
 
         if ext.class.resources_generators && !ext.class.resources_generators.empty?
           ext.app.sitemap.register_resource_list_manipulators(
@@ -422,18 +420,18 @@ module Middleman
     def generate_resources(resources)
       generator_defs = self.class.resources_generators.reduce({}) do |sum, g|
         resource_definitions = if g.is_a? Hash
-          g
-        elsif g.is_a? Symbol
-          definition = method(g)
-
-          if definition.arity == 0
-            send(g)
-          else
-            send(g, resources)
-          end
-        else
-          {}
-        end
+                                 g
+                               elsif g.is_a? Symbol
+                                 definition = method(g)
+
+                                 if definition.arity.zero?
+                                   send(g)
+                                 else
+                                   send(g, resources)
+                                 end
+                               else
+                                 {}
+                               end
 
         sum.merge!(resource_definitions)
       end
@@ -442,11 +440,11 @@ module Middleman
         if g.is_a? Symbol
           definition = method(g)
 
-          g = if definition.arity == 0
-            send(g)
-          else
-            send(g, resources)
-          end
+          g = if definition.arity.zero?
+                send(g)
+              else
+                send(g, resources)
+              end
         end
 
         ::Middleman::Sitemap::StringResource.new(
@@ -491,7 +489,7 @@ module Middleman
   end
 
   class ConfigExtension < Extension
-    def initialize(app, config={}, &block)
+    def initialize(app, _options_hash = ::Middleman::EMPTY_HASH, &block)
       @descriptors = {}
       @ready = false
 
@@ -527,11 +525,10 @@ module Middleman
     end
 
     # Update the main sitemap resource list
-    # @return Array<Middleman::Sitemap::Resource>
-    Contract ResourceList => ResourceList
-    def manipulate_resource_list(resources)
-      @descriptors.values.flatten.reduce(resources) do |sum, c|
-        c.execute_descriptor(app, sum)
+    Contract IsA['Middleman::Sitemap::ResourceListContainer'] => Any
+    def manipulate_resource_list_container!(resource_list)
+      @descriptors.values.flatten.each do |c|
+        c.execute_descriptor(app, resource_list)
       end
     end