middleman-core 4.5.1 → 5.0.0.rc.1

data/lib/middleman-core/configuration.rb

@@ -1,3 +1,5 @@
+require 'set'
+
 module Middleman
   module Configuration
     # A class that manages a collection of documented settings.
@@ -43,15 +45,15 @@ module Middleman
         if defines_setting?(method) && args.empty?
           self[method]
         elsif method.to_s =~ /^(\w+)=$/ && args.size == 1
-          self[$1.to_sym] = args[0]
+          self[Regexp.last_match(1).to_sym] = args[0]
         else
           super
         end
       end
 
       # Needed so that method_missing makes sense
-      def respond_to?(method, include_private=false)
-        super || defines_setting?(method) || (method =~ /^(\w+)=$/ && defines_setting?($1))
+      def respond_to?(method, include_private = false)
+        super || defines_setting?(method) || (method =~ /^(\w+)=$/ && defines_setting?(Regexp.last_match(1)))
       end
 
       # Does this configuration manager know about the setting identified by key?
@@ -71,12 +73,12 @@ module Middleman
       # @param [String] description A human-readable description of what the option does
       # @param [Hash] options Additional options.
       # @return [ConfigSetting]
-      def define_setting(key, default=nil, description=nil, options={})
+      def define_setting(key, default = nil, description = nil, options_hash = ::Middleman::EMPTY_HASH)
         raise "Setting #{key} doesn't exist" if @finalized
         raise "Setting #{key} already defined" if @settings.key?(key)
         raise 'Setting key must be a Symbol' unless key.is_a? Symbol
 
-        @settings[key] = ConfigSetting.new(key, default, description, options)
+        @settings[key] = ConfigSetting.new(key, default, description, options_hash)
       end
 
       # Switch the configuration manager is finalized, it switches to read-only
@@ -127,25 +129,35 @@ module Middleman
       # Additional config.
       attr_accessor :options
 
-      def initialize(key, default, description, options={})
+      def initialize(key, default, description, options_hash = ::Middleman::EMPTY_HASH)
         @value_set = false
+        @array_wrapped_value = nil
+        @array_wrapped_default = nil
         self.key = key
         self.default = default
         self.description = description
-        self.options = options
+        self.options = options_hash
+
+        @array_wrapped_default = (Set.new(self.default) if self.default && options_hash[:set] && self.default.is_a?(Array))
       end
 
       # The user-supplied value for this setting, overriding the default
       def value=(value)
         @value = value
         @value_set = true
+
+        @array_wrapped_value = (Set.new(@value) if @value && options[:set] && @value.is_a?(Array))
       end
 
       # The effective value of the setting, which may be the default
       # if the user has not set a value themselves. Note that even if the
       # user sets the value to nil it will override the default.
       def value
-        value_set? ? @value : default
+        if value_set?
+          @array_wrapped_value || @value
+        else
+          @array_wrapped_default || default
+        end
       end
 
       # Whether or not there has been a value set beyond the default

data/lib/middleman-core/contracts.rb

@@ -19,7 +19,33 @@ if ENV['CONTRACTS'] != 'false'
     end
 
     VectorOf = Contracts::CollectionOf::Factory.new(::Hamster::Vector)
-    ResourceList = Contracts::ArrayOf[IsA['Middleman::Sitemap::Resource']]
+
+    class ImmutableHashOf < Contracts::CallableClass
+      INVALID_KEY_VALUE_PAIR = 'You should provide only one key-value pair to HashOf contract'.freeze
+
+      def initialize(key, value)
+        @key   = key
+        @value = value
+      end
+
+      def valid?(hash)
+        return false unless hash.is_a?(::Hamster::Hash)
+
+        keys_match = hash.keys.map { |k| Contract.valid?(k, @key) }.all?
+        vals_match = hash.values.map { |v| Contract.valid?(v, @value) }.all?
+
+        [keys_match, vals_match].all?
+      end
+
+      def to_s
+        "ImmutableHash<#{@key}, #{@value}>"
+      end
+    end
+
+    ImmutableSetOf = Contracts::CollectionOf::Factory.new(::Hamster::Set)
+    ImmutableSortedSetOf = Contracts::CollectionOf::Factory.new(::Hamster::SortedSet)
+    OldResourceList = Contracts::ArrayOf[IsA['Middleman::Sitemap::Resource']]
+    ResourceList = Contracts::Or[ImmutableSetOf[IsA['Middleman::Sitemap::Resource']], ImmutableSortedSetOf[IsA['Middleman::Sitemap::Resource']], Contracts::ArrayOf[IsA['Middleman::Sitemap::Resource']]]
   end
 else
   module Contracts
@@ -29,10 +55,10 @@ else
 
     # rubocop:disable MethodName
     def Contract(*); end
+    # rubocop:enable MethodName
 
     class Callable
-      def self.[](*)
-      end
+      def self.[](*); end
     end
 
     class Bool
@@ -80,6 +106,9 @@ else
     class ResourceList < Callable
     end
 
+    class OldResourceList < Callable
+    end
+
     class Args < Callable
     end
 
@@ -103,6 +132,12 @@ else
 
     class VectorOf < Callable
     end
+
+    class ImmutableHashOf < Callable
+    end
+
+    class ImmutableSetOf < Callable
+    end
   end
 end
 

data/lib/middleman-core/core_extensions/collections/lazy_root.rb

@@ -13,7 +13,7 @@ module Middleman
           @data = data
         end
 
-        def value(_ctx=nil)
+        def value(_ctx = nil)
           @data
         end
 

data/lib/middleman-core/core_extensions/collections/lazy_step.rb

@@ -2,9 +2,9 @@ module Middleman
   module CoreExtensions
     module Collections
       class LazyCollectorStep < BasicObject
-        DELEGATE = [:hash, :eql?].freeze
+        DELEGATE = %i[hash eql?].freeze
 
-        def initialize(name, args, block, parent=nil)
+        def initialize(name, args, block, parent = nil)
           @name = name
           @args = args
           @block = block
@@ -19,19 +19,19 @@ module Middleman
           @parent.leaves
         end
 
-        def value(ctx=nil)
+        def value(ctx = nil)
           data = @parent.value(ctx)
 
           original_block = @block
 
           if original_block
             b = if ctx
-              ::Proc.new do |*args|
-                ctx.instance_exec(*args, &original_block)
-              end
-            else
-              original_block
-            end
+                  ::Proc.new do |*args|
+                    ctx.instance_exec(*args, &original_block)
+                  end
+                else
+                  original_block
+                end
           end
 
           data.send(@name, *@args.deep_dup, &b)

data/lib/middleman-core/core_extensions/collections/pagination.rb

@@ -1,4 +1,3 @@
-require 'active_support/core_ext/object/deep_dup'
 require 'middleman-core/util'
 
 module Middleman
@@ -8,12 +7,12 @@ module Middleman
         return to_enum(__method__, per_page) unless block_given?
 
         parts = if per_page.respond_to? :call
-          per_page.call(dup)
-        else
-          each_slice(per_page).reduce([]) do |sum, items|
-            sum << items
-          end
-        end
+                  per_page.call(dup)
+                else
+                  each_slice(per_page).reduce([]) do |sum, items|
+                    sum << items
+                  end
+                end
 
         num_pages = parts.length
         collection = self

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

@@ -34,7 +34,7 @@ module Middleman
           end
         end
 
-        def initialize(app, options_hash={}, &block)
+        def initialize(app, options_hash = ::Middleman::EMPTY_HASH, &block)
           super
 
           @leaves = Set.new
@@ -57,7 +57,7 @@ module Middleman
 
         Contract LazyCollectorRoot
         def sitemap_collector
-          live_collector { |_, resources| resources }
+          live_collector { |_, resources| resources.to_a }
         end
 
         Contract LazyCollectorRoot
@@ -82,11 +82,11 @@ module Middleman
           @values_by_name[label]
         end
 
-        Contract ResourceList => ResourceList
-        def manipulate_resource_list(resources)
+        Contract IsA['Middleman::Sitemap::ResourceListContainer'] => Any
+        def manipulate_resource_list_container!(resource_list)
           @lock.synchronize do
             @collector_roots.each do |pair|
-              dataset = pair[:block].call(app, resources)
+              dataset = pair[:block].call(app, resource_list)
               pair[:root].realize!(dataset)
             end
 
@@ -106,13 +106,11 @@ module Middleman
             end
 
             # Inject descriptors
-            results = ctx.descriptors.reduce(resources) do |sum, d|
-              d.execute_descriptor(app, sum)
+            ctx.descriptors.each do |d|
+              d.execute_descriptor(app, resource_list)
             end
 
             StepContext.current = nil
-
-            results
           end
         end
       end

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

@@ -0,0 +1,109 @@
+require 'hamster'
+require 'middleman-core/util/data'
+require 'middleman-core/core_extensions/data/stores/local_file'
+require 'middleman-core/core_extensions/data/stores/in_memory'
+require 'middleman-core/core_extensions/data/proxies/array'
+require 'middleman-core/core_extensions/data/proxies/hash'
+
+module Middleman
+  module CoreExtensions
+    module Data
+      # The core logic behind the data extension.
+      class DataStoreController
+        extend Forwardable
+
+        def_delegator :@local_file_data_store, :update_files
+        def_delegators :@in_memory_data_store, :store, :callbacks
+
+        def initialize(app, track_data_access)
+          @data_collection_depth = app.config[:data_collection_depth]
+          @track_data_access = track_data_access
+
+          @local_file_data_store = Data::Stores::LocalFileDataStore.new(app)
+          @in_memory_data_store = Data::Stores::InMemoryDataStore.new
+
+          # Sorted in order of access precedence.
+          @data_stores = [
+            @local_file_data_store,
+            @in_memory_data_store
+          ]
+
+          @enhanced_cache = {}
+        end
+
+        def key?(k)
+          @data_stores.any? { |s| s.key?(k) }
+        end
+        alias has_key? key?
+
+        def key(k)
+          source = @data_stores.find { |s| s.key?(k) }
+          source[k] unless source.nil?
+        end
+        alias [] key
+
+        def vertices
+          @data_stores.reduce(::Hamster::Set.empty) do |sum, s|
+            sum | s.vertices
+          end
+        end
+
+        def enhanced_data(k)
+          value = key(k)
+
+          if @enhanced_cache.key?(k)
+            cached_id, cached_value = @enhanced_cache[k]
+
+            return cached_value if cached_id == value.object_id
+
+            @enhanced_cache.delete(k)
+          end
+
+          enhanced = ::Middleman::Util.recursively_enhance(value)
+
+          @enhanced_cache[k] = [value.object_id, enhanced]
+
+          enhanced
+        end
+
+        def proxied_data(k, parent = nil)
+          data = enhanced_data(k)
+
+          return data unless @track_data_access
+
+          if data.is_a? ::Middleman::Util::EnhancedHash
+            Data::Proxies::HashProxy.new(k, data, @data_collection_depth, parent)
+          elsif data.is_a? ::Array
+            Data::Proxies::ArrayProxy.new(k, data, @data_collection_depth, parent)
+          else
+            raise 'Invalid data to wrap'
+          end
+        end
+
+        # "Magically" find namespaces of data if they exist
+        #
+        # @param [String] path The namespace to search for
+        # @return [Hash, nil]
+        def method_missing(method)
+          return proxied_data(method) if key?(method)
+
+          super
+        end
+
+        # Needed so that method_missing makes sense
+        def respond_to?(method, include_private = false)
+          super || key?(method)
+        end
+
+        # Convert all the data into a static hash
+        #
+        # @return [Hash]
+        def to_h
+          @data_stores.reduce({}) do |sum, store|
+            sum.merge(store.to_h)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/middleman-core/core_extensions/data/proxies/array.rb

@@ -0,0 +1,74 @@
+require 'set'
+require 'middleman-core/core_extensions/data/proxies/base'
+
+module Middleman
+  module CoreExtensions
+    module Data
+      module Proxies
+        class ArrayProxy < BaseProxy
+          WRAPPED_LIST_METHODS = Set.new %i[each each_with_index select sort shuffle reverse rotate sample]
+
+          def respond_to_missing?(name, *)
+            self.class.const_get(:WRAPPED_LIST_METHODS).include?(name) || super
+          end
+
+          def method_missing(name, *args, &block)
+            if self.class.const_get(:WRAPPED_LIST_METHODS).include?(name)
+              log_access(:__full_access__)
+              return wrapped_array.send(name, *args, &block)
+            end
+
+            super
+          end
+
+          def fetch(index, default = (_missing_default = true), &block)
+            wrap_data index, @data.fetch(index, default, &block)
+          end
+
+          def slice(arg, length = (missing_length = true))
+            if missing_length
+              if arg.is_a?(Range)
+                log_access(:__full_access__)
+                @data.slice(arg)
+              else
+                relative_index = (@data.size + arg) % @data.size
+                wrap_data(relative_index, @data[relative_index])
+              end
+            else
+              log_access(:__full_access__)
+              @data.slice(arg, length)
+            end
+          end
+          alias [] slice
+
+          def first(length = (missing_length = true))
+            if missing_length || length == 1
+              slice(0)
+            else
+              slice(0, length)
+            end
+          end
+
+          def last(length = (missing_length = true))
+            if missing_length || length == 1
+              slice(-1)
+            else
+              slice(size - length, length)
+            end
+          end
+
+          private
+
+          def wrapped_array
+            @wrapped_array ||= begin
+              i = 0
+              @data.map do |d|
+                wrap_data(i, d).tap { i += 1 }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/middleman-core/core_extensions/data/proxies/base.rb

@@ -0,0 +1,82 @@
+require 'hamster'
+require 'middleman-core/util/data'
+
+module Middleman
+  module CoreExtensions
+    module Data
+      module Proxies
+        class BaseProxy
+          attr_reader :accessed_keys
+          attr_reader :depth
+
+          def initialize(key, data, data_collection_depth, parent = nil)
+            @key = key
+            @data = data
+            @parent = parent
+
+            @data_collection_depth = data_collection_depth
+            @depth = @parent.nil? || !@parent.is_a?(BaseProxy) ? 0 : @parent.depth + 1
+
+            @accessed_keys = ::Hamster::Set.new
+          end
+
+          def respond_to_missing?(name, *)
+            @data.respond_to?(name) || super
+          end
+
+          def method_missing(name, *args, &block)
+            if @data.respond_to?(name)
+              log_access(:__full_access__)
+
+              return @data.send(name, *args, &block)
+            end
+
+            super
+          end
+
+          def _top
+            return @parent._top if @parent.is_a?(BaseProxy)
+
+            self
+          end
+
+          def _replace_parent(new_parent)
+            @parent = new_parent
+          end
+
+          def as_json(*args)
+            log_access(:__full_access__)
+            @data.as_json(*args)
+          end
+
+          protected
+
+          def log_access(key)
+            access_key = [@key, key].flatten
+            access_key_vector = ::Hamster::Vector.new(access_key)
+
+            return if @accessed_keys.include?(access_key_vector)
+
+            @accessed_keys <<= access_key_vector
+
+            @parent&.log_access(access_key)
+          end
+
+          def wrap_data(key, data)
+            if @depth >= @data_collection_depth
+              log_access(:__full_access__)
+              ::Middleman::Util.recursively_enhance(data)
+            elsif data.is_a? ::Middleman::Util::EnhancedHash
+              HashProxy.new(key, data, @data_collection_depth, self)
+            elsif data.is_a? ::Array
+              ArrayProxy.new(key, data, @data_collection_depth, self)
+            else
+              log_access(key)
+              data
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/middleman-core/core_extensions/data/proxies/hash.rb

@@ -0,0 +1,32 @@
+require 'middleman-core/core_extensions/data/proxies/base'
+
+module Middleman
+  module CoreExtensions
+    module Data
+      module Proxies
+        class HashProxy < BaseProxy
+          def fetch(key, default = Undefined, &block)
+            wrap_data key.to_sym, @data.fetch(key, default, &block)
+          end
+
+          def [](key)
+            wrap_data key.to_sym, @data[key]
+          end
+          alias get []
+
+          def respond_to_missing?(name, *)
+            @data.key?(name) || super
+          end
+
+          def method_missing(name, *_args)
+            return self[name] if @data.key?(name)
+
+            super
+          rescue NoMethodError
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/middleman-core/core_extensions/data/stores/base.rb

@@ -0,0 +1,42 @@
+require 'hamster'
+require 'middleman-core/dependencies/vertices/vertex'
+require 'middleman-core/contracts'
+
+module Middleman
+  module CoreExtensions
+    module Data
+      module Stores
+        class BaseDataStore
+          include Contracts
+
+          Contract Symbol => Bool
+          def key?(_k)
+            raise NotImplementedError
+          end
+
+          Contract Symbol => Or[Array, Hash]
+          def [](_k)
+            raise NotImplementedError
+          end
+
+          Contract ArrayOf[Symbol]
+          def keys
+            raise NotImplementedError
+          end
+
+          Contract ImmutableSetOf[::Middleman::Dependencies::Vertex]
+          def vertices
+            Hamster::Set.empty
+          end
+
+          Contract Hash
+          def to_h
+            keys.each_with_object({}) do |k, sum|
+              sum[k] = self[k]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/middleman-core/core_extensions/data/stores/in_memory.rb

@@ -0,0 +1,52 @@
+require 'middleman-core/contracts'
+require 'middleman-core/core_extensions/data/stores/base'
+require 'middleman-core/dependencies/vertices/vertex'
+require 'middleman-core/dependencies/vertices/data_collection_vertex'
+
+module Middleman
+  module CoreExtensions
+    module Data
+      module Stores
+        # Static data, passed in via config.rb
+        class InMemoryDataStore < BaseDataStore
+          extend Forwardable
+          include Contracts
+
+          def_delegators :@sources, :key?, :keys, :[]
+
+          Contract Any
+          def initialize
+            super()
+
+            @sources = {}
+            @keys_to_vertex = {}
+          end
+
+          Contract ImmutableSetOf[::Middleman::Dependencies::Vertex]
+          def vertices
+            Hamster::Set.new(@keys_to_vertex.values.flatten(1))
+          end
+
+          # Store static data hash
+          #
+          # @param [Symbol] name Name of the data, used for namespacing
+          # @param [Hash] content The content for this data
+          # @return [Hash]
+          Contract Symbol, Or[Hash, Array] => Any
+          def store(name, content)
+            @sources[name] = content
+
+            @keys_to_vertex[name] = ::Hamster::Set.empty
+            @keys_to_vertex[name] <<= ::Middleman::Dependencies::DataCollectionVertex.from_data(name, content)
+          end
+
+          # Store callback-based data
+          Contract Symbol, Proc => Any
+          def callbacks(name, callback)
+            store(name, callback.call)
+          end
+        end
+      end
+    end
+  end
+end