middleman-core 4.3.11 → 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/dns_resolver.rb

@@ -27,16 +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)
 
       if RUBY_VERSION >= '2.1'
         require 'middleman-core/dns_resolver/local_link_resolver'
-        @resolvers << opts.fetch(:local_link_resolver, LocalLinkResolver.new)
+        @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/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
 

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