middleman-core 3.3.12 → 4.4.2

data/lib/middleman-core/contracts.rb

@@ -0,0 +1,111 @@
+if ENV['CONTRACTS'] != 'false'
+  require 'contracts'
+  require 'hamster'
+
+  module Contracts
+    class IsA
+      def self.[](val)
+        @lookup ||= {}
+        @lookup[val] ||= new(val)
+      end
+
+      def initialize(val)
+        @val = val
+      end
+
+      def valid?(val)
+        val.is_a? @val.constantize
+      end
+    end
+
+    VectorOf = Contracts::CollectionOf::Factory.new(::Hamster::Vector)
+    ResourceList = Contracts::ArrayOf[IsA['Middleman::Sitemap::Resource']]
+  end
+else
+  module Contracts
+    def self.included(base)
+      base.extend self
+    end
+
+    # rubocop:disable MethodName
+    def Contract(*); end
+
+    class Callable
+      def self.[](*)
+      end
+    end
+
+    class Bool
+    end
+
+    class Num
+    end
+
+    class Pos
+    end
+
+    class Neg
+    end
+
+    class Any
+    end
+
+    class None
+    end
+
+    class Or < Callable
+    end
+
+    class Xor < Callable
+    end
+
+    class And < Callable
+    end
+
+    class Not < Callable
+    end
+
+    class RespondTo < Callable
+    end
+
+    class Send < Callable
+    end
+
+    class Exactly < Callable
+    end
+
+    class ArrayOf < Callable
+    end
+
+    class ResourceList < Callable
+    end
+
+    class Args < Callable
+    end
+
+    class HashOf < Callable
+    end
+
+    class Bool
+    end
+
+    class Maybe < Callable
+    end
+
+    class IsA < Callable
+    end
+
+    class SetOf < Callable
+    end
+
+    class Frozen < Callable
+    end
+
+    class VectorOf < Callable
+    end
+  end
+end
+
+module Contracts
+  PATH_MATCHER = Or[String, RespondTo[:match], RespondTo[:call], RespondTo[:to_s]]
+end

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

@@ -0,0 +1,30 @@
+require 'middleman-core/core_extensions/collections/lazy_step'
+
+module Middleman
+  module CoreExtensions
+    module Collections
+      class LazyCollectorRoot < BasicObject
+        def initialize(parent)
+          @data = nil
+          @parent = parent
+        end
+
+        def realize!(data)
+          @data = data
+        end
+
+        def value(_ctx=nil)
+          @data
+        end
+
+        def leaves
+          @parent.leaves
+        end
+
+        def method_missing(name, *args, &block)
+          LazyCollectorStep.new(name, args, block, self)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module Middleman
+  module CoreExtensions
+    module Collections
+      class LazyCollectorStep < BasicObject
+        DELEGATE = [:hash, :eql?].freeze
+
+        def initialize(name, args, block, parent=nil)
+          @name = name
+          @args = args
+          @block = block
+
+          @parent = parent
+          @result = nil
+
+          leaves << self
+        end
+
+        def leaves
+          @parent.leaves
+        end
+
+        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
+          end
+
+          data.send(@name, *@args.deep_dup, &b)
+        end
+
+        def method_missing(name, *args, &block)
+          return ::Kernel.send(name, *args, &block) if DELEGATE.include? name
+
+          leaves.delete self
+
+          LazyCollectorStep.new(name, args, block, self)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+require 'active_support/core_ext/object/deep_dup'
+require 'middleman-core/util'
+
+module Middleman
+  module Pagination
+    module ArrayHelpers
+      def per_page(per_page)
+        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
+
+        num_pages = parts.length
+        collection = self
+
+        current_start_i = 0
+        parts.each_with_index do |items, i|
+          num = i + 1
+
+          meta = ::Middleman::Pagination.page_locals(
+            num,
+            num_pages,
+            collection,
+            items,
+            current_start_i
+          )
+
+          yield items, num, meta, num >= num_pages
+
+          current_start_i += items.length
+        end
+      end
+    end
+
+    def self.page_locals(page_num, num_pages, collection, items, page_start)
+      per_page = items.length
+
+      # Index into collection of the last item of this page
+      page_end = (page_start + per_page) - 1
+
+      ::Middleman::Util.recursively_enhance(page_number: page_num,
+                                            num_pages: num_pages,
+                                            per_page: per_page,
+
+                                            # The range of item numbers on this page
+                                            # (1-based, for showing "Items X to Y of Z")
+                                            page_start: page_start + 1,
+                                            page_end: [page_end + 1, collection.length].min,
+
+                                            # Use "collection" in templates.
+                                            collection: collection)
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Middleman
+  module CoreExtensions
+    module Collections
+      class StepContext
+        class << self
+          attr_accessor :current
+
+          def add_to_context(name, &func)
+            send(:define_method, :"_internal_#{name}", &func)
+          end
+        end
+
+        attr_reader :descriptors
+
+        def initialize(app)
+          @app = app
+          @descriptors = []
+        end
+
+        def method_missing(name, *args, &block)
+          internal = :"_internal_#{name}"
+
+          if respond_to?(internal)
+            send(internal, *args, &block).tap do |r|
+              @descriptors << r if r.respond_to?(:execute_descriptor)
+            end
+          else
+            @app.config_context.send(name, *args, &block)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+require 'monitor'
+require 'middleman-core/core_extensions/collections/pagination'
+require 'middleman-core/core_extensions/collections/step_context'
+require 'middleman-core/core_extensions/collections/lazy_root'
+require 'middleman-core/core_extensions/collections/lazy_step'
+
+# Super "class-y" injection of array helpers
+class Array
+  include Middleman::Pagination::ArrayHelpers
+end
+
+module Middleman
+  module CoreExtensions
+    module Collections
+      class CollectionsExtension < Extension
+        # This should run after most other sitemap manipulators so that it
+        # gets a chance to modify any new resources that get added.
+        self.resource_list_manipulator_priority = 110
+
+        attr_accessor :leaves
+
+        # Expose `resources`, `data`, and `collection` to config.
+        expose_to_config resources: :sitemap_collector,
+                         data: :data_collector,
+                         collection: :register_collector,
+                         live: :live_collector
+
+        # Exposes `collection` to templates
+        expose_to_template collection: :collector_value
+
+        helpers do
+          def pagination
+            current_resource.data.pagination
+          end
+        end
+
+        def initialize(app, options_hash={}, &block)
+          super
+
+          @leaves = Set.new
+          @collectors_by_name = {}
+          @values_by_name = {}
+
+          @collector_roots = []
+
+          @lock = Monitor.new
+        end
+
+        def before_configuration
+          @leaves.clear
+        end
+
+        Contract Symbol, LazyCollectorStep => Any
+        def register_collector(label, endpoint)
+          @collectors_by_name[label] = endpoint
+        end
+
+        Contract LazyCollectorRoot
+        def sitemap_collector
+          live_collector { |_, resources| resources }
+        end
+
+        Contract LazyCollectorRoot
+        def data_collector
+          live_collector { |app, _| app.data }
+        end
+
+        Contract Proc => LazyCollectorRoot
+        def live_collector(&block)
+          root = LazyCollectorRoot.new(self)
+
+          @collector_roots << {
+            root: root,
+            block: block
+          }
+
+          root
+        end
+
+        Contract Symbol => Any
+        def collector_value(label)
+          @values_by_name[label]
+        end
+
+        Contract ResourceList => ResourceList
+        def manipulate_resource_list(resources)
+          @lock.synchronize do
+            @collector_roots.each do |pair|
+              dataset = pair[:block].call(app, resources)
+              pair[:root].realize!(dataset)
+            end
+
+            ctx = StepContext.new(app)
+            StepContext.current = ctx
+
+            leaves = @leaves.dup
+
+            @collectors_by_name.each do |k, v|
+              @values_by_name[k] = v.value(ctx)
+              leaves.delete v
+            end
+
+            # Execute code paths
+            leaves.each do |v|
+              v.value(ctx)
+            end
+
+            # Inject descriptors
+            results = ctx.descriptors.reduce(resources) do |sum, d|
+              d.execute_descriptor(app, sum)
+            end
+
+            StepContext.current = nil
+
+            results
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,56 +1,65 @@
+require 'middleman-core/contracts'
+require 'middleman-core/util/data'
+
 module Middleman
   module CoreExtensions
-    # The data extension parses YAML and JSON files in the data/ directory
-    # and makes them available to config.rb, templates and extensions
-    module Data
-      # Extension registered
-      class << self
-        # @private
-        def registered(app)
-          # Data formats
-          require 'yaml'
-          require 'active_support/json'
-
-          app.config.define_setting :data_dir, 'data', 'The directory data files are stored in'
-          app.send :include, InstanceMethods
-        end
-        alias_method :included, :registered
+    # The data extension parses YAML and JSON files in the `data/` directory
+    # and makes them available to `config.rb`, templates and extensions
+    class Data < Extension
+      attr_reader :data_store
+
+      define_setting :data_dir, ENV['MM_DATA_DIR'] || 'data', 'The directory data files are stored in'
+
+      # Make the internal `data_store` method available as `app.data`
+      expose_to_application data: :data_store
+
+      # Exposes `data` to templates
+      expose_to_template data: :data_store
+
+      # The regex which tells Middleman which files are for data
+      DATA_FILE_MATCHER = /^(.*?)[\w-]+\.(yml|yaml|json|toml)$/
+
+      def initialize(app, config={}, &block)
+        super
+
+        @data_store = DataStore.new(app, DATA_FILE_MATCHER)
+
+        start_watching(app.config[:data_dir])
       end
 
-      # Instance methods
-      module InstanceMethods
+      def start_watching(dir)
+        @original_data_dir = dir
+
+        # Tell the file watcher to observe the :data_dir
+        @watcher = app.files.watch :data,
+                                   path: File.join(app.root, dir),
+                                   only: DATA_FILE_MATCHER
+
         # Setup data files before anything else so they are available when
         # parsing config.rb
-        def initialize
-          files.changed DataStore.matcher do |file|
-            data.touch_file(file) if file.start_with?("#{config[:data_dir]}/")
-          end
+        app.files.on_change(:data, &@data_store.method(:update_files))
+      end
 
-          files.deleted DataStore.matcher do |file|
-            data.remove_file(file) if file.start_with?("#{config[:data_dir]}/")
-          end
+      def after_configuration
+        return unless @original_data_dir != app.config[:data_dir]
 
-          super
-        end
-
-        # The data object
-        #
-        # @return [DataStore]
-        def data
-          @_data ||= DataStore.new(self)
-        end
+        @watcher.update_path(app.config[:data_dir])
       end
 
       # The core logic behind the data extension.
       class DataStore
-        # Static methods
-        class << self
-          # The regex which tells Middleman which files are for data
-          #
-          # @return [Regexp]
-          def matcher
-            %r{[\w-]+\.(yml|yaml|json)$}
-          end
+        include Contracts
+
+        # Setup data store
+        #
+        # @param [Middleman::Application] app The current instance of Middleman
+        def initialize(app, data_file_matcher)
+          @app = app
+          @data_file_matcher = data_file_matcher
+          @local_data = {}
+          @local_data_enhanced = nil
+          @local_sources = {}
+          @callback_sources = {}
         end
 
         # Store static data hash
@@ -58,10 +67,10 @@ module Middleman
         # @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] => Hash
         def store(name=nil, content=nil)
-          @_local_sources ||= {}
-          @_local_sources[name.to_s] = content unless name.nil? || content.nil?
-          @_local_sources
+          @local_sources[name.to_s] = content unless name.nil? || content.nil?
+          @local_sources
         end
 
         # Store callback-based data
@@ -69,62 +78,63 @@ module Middleman
         # @param [Symbol] name Name of the data, used for namespacing
         # @param [Proc] proc The callback which will return data
         # @return [Hash]
+        Contract Maybe[Symbol], Maybe[Proc] => Hash
         def callbacks(name=nil, proc=nil)
-          @_callback_sources ||= {}
-          @_callback_sources[name.to_s] = proc unless name.nil? || proc.nil?
-          @_callback_sources
+          @callback_sources[name.to_s] = proc unless name.nil? || proc.nil?
+          @callback_sources
         end
 
-        # Setup data store
-        #
-        # @param [Middleman::Application] app The current instance of Middleman
-        def initialize(app)
-          @app = app
-          @local_data = {}
+        Contract ArrayOf[IsA['Middleman::SourceFile']], ArrayOf[IsA['Middleman::SourceFile']] => Any
+        def update_files(updated_files, removed_files)
+          updated_files.each(&method(:touch_file))
+          removed_files.each(&method(:remove_file))
+
+          @app.sitemap.rebuild_resource_list!(:touched_data_file)
         end
 
         # Update the internal cache for a given file path
         #
         # @param [String] file The file to be re-parsed
         # @return [void]
+        Contract IsA['Middleman::SourceFile'] => Any
         def touch_file(file)
-          root = Pathname(@app.root)
-          full_path = root + file
-          extension = File.extname(file)
-          basename  = File.basename(file, extension)
+          data_path = file[:relative_path]
+          extension = File.extname(data_path)
+          basename  = File.basename(data_path, extension)
 
-          data_path = full_path.relative_path_from(root + @app.config[:data_dir])
+          return unless %w(.yaml .yml .json .toml).include?(extension)
 
           if %w(.yaml .yml).include?(extension)
-            data = YAML.load_file(full_path)
+            data, postscript = ::Middleman::Util::Data.parse(file, @app.config[:frontmatter_delims], :yaml)
+            data[:postscript] = postscript if !postscript.nil? && data.is_a?(Hash)
           elsif extension == '.json'
-            data = ActiveSupport::JSON.decode(full_path.read)
-          else
-            return
+            data, _postscript = ::Middleman::Util::Data.parse(file, @app.config[:frontmatter_delims], :json)
+          elsif extension == '.toml'
+            data, _postscript = ::Middleman::Util::Data.parse(file, @app.config[:frontmatter_delims], :toml)
           end
 
           data_branch = @local_data
 
           path = data_path.to_s.split(File::SEPARATOR)[0..-2]
           path.each do |dir|
-            data_branch[dir] ||= ::Middleman::Util.recursively_enhance({})
+            data_branch[dir] ||= {}
             data_branch = data_branch[dir]
           end
 
-          data_branch[basename] = ::Middleman::Util.recursively_enhance(data)
+          data_branch[basename] = data
+
+          @local_data_enhanced = nil
         end
 
         # Remove a given file from the internal cache
         #
         # @param [String] file The file to be cleared
         # @return [void]
+        Contract IsA['Middleman::SourceFile'] => Any
         def remove_file(file)
-          root = Pathname(@app.root)
-          full_path = root + file
-          extension = File.extname(file)
-          basename  = File.basename(file, extension)
-
-          data_path = full_path.relative_path_from(root + @app.config[:data_dir])
+          data_path = file[:relative_path]
+          extension = File.extname(data_path)
+          basename  = File.basename(data_path, extension)
 
           data_branch = @local_data
 
@@ -134,22 +144,23 @@ module Middleman
           end
 
           data_branch.delete(basename) if data_branch.key?(basename)
+
+          @local_data_enhanced = nil
         end
 
         # Get a hash from either internal static data or a callback
         #
         # @param [String, Symbol] path The name of the data namespace
         # @return [Hash, nil]
+        Contract Or[String, Symbol] => Maybe[Or[Array, IsA['Middleman::Util::EnhancedHash']]]
         def data_for_path(path)
-          response = nil
-
-          if store.key?(path.to_s)
-            response = store[path.to_s]
+          response = if store.key?(path.to_s)
+            store[path.to_s]
           elsif callbacks.key?(path.to_s)
-            response = callbacks[path.to_s].call
+            callbacks[path.to_s].call
           end
 
-          response
+          ::Middleman::Util.recursively_enhance(response)
         end
 
         # "Magically" find namespaces of data if they exist
@@ -158,10 +169,12 @@ module Middleman
         # @return [Hash, nil]
         def method_missing(path)
           if @local_data.key?(path.to_s)
-            return @local_data[path.to_s]
+            # Any way to cache this?
+            @local_data_enhanced ||= ::Middleman::Util.recursively_enhance(@local_data)
+            return @local_data_enhanced[path.to_s]
           else
             result = data_for_path(path)
-            return ::Middleman::Util.recursively_enhance(result) if result
+            return result if result
           end
 
           super
@@ -182,22 +195,23 @@ module Middleman
         end
 
         def key?(key)
-          @local_data.key?(key.to_s) || data_for_path(key)
+          (@local_data.keys + @local_sources.keys + @callback_sources.keys).include?(key.to_s)
         end
 
-        alias_method :has_key?, :key?
+        alias has_key? key?
 
         # Convert all the data into a static hash
         #
         # @return [Hash]
+        Contract Hash
         def to_h
           data = {}
 
-          store.each do |k, _|
+          store.each_key do |k|
             data[k] = data_for_path(k)
           end
 
-          callbacks.each do |k, _|
+          callbacks.each_key do |k|
             data[k] = data_for_path(k)
           end