middleman-core 4.5.1 → 5.0.0.rc.1

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

@@ -0,0 +1,92 @@
+require 'hamster'
+require 'set'
+require 'middleman-core/contracts'
+require 'middleman-core/core_extensions/data/stores/base'
+require 'middleman-core/dependencies/vertices/vertex'
+require 'middleman-core/dependencies/vertices/file_vertex'
+
+module Middleman
+  module CoreExtensions
+    module Data
+      module Stores
+        # JSON and YAML files in the data/ directory
+        class LocalFileDataStore < BaseDataStore
+          extend Forwardable
+          include Contracts
+
+          YAML_EXTS = Set.new %w[.yaml .yml]
+          JSON_EXTS = Set.new %w[.json]
+          ALL_EXTS = YAML_EXTS | JSON_EXTS
+
+          def_delegators :@local_data, :keys, :key?, :[]
+
+          # Contract IsA['::Middleman::Application'] => Any
+          def initialize(app)
+            super()
+
+            @app = app
+            @local_data = {}
+          end
+
+          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)
+            data_path = file[:relative_path]
+            extension = File.extname(data_path)
+            basename  = File.basename(data_path, extension)
+
+            return unless ALL_EXTS.include?(extension)
+
+            if YAML_EXTS.include?(extension)
+              data, postscript = ::Middleman::Util::Data.parse(file, @app.config[:frontmatter_delims], :yaml)
+              data[:postscript] = postscript if !postscript.nil? && data.is_a?(Hash)
+            elsif JSON_EXTS.include?(extension)
+              data, _postscript = ::Middleman::Util::Data.parse(file, @app.config[:frontmatter_delims], :json)
+            end
+
+            data_branch = @local_data
+
+            paths = data_path.to_s.split(File::SEPARATOR)[0..-2]
+            paths.each do |dir|
+              data_branch[dir.to_sym] ||= {}
+              data_branch = data_branch[dir.to_sym]
+            end
+
+            data_branch[basename.to_sym] = data
+          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)
+            data_path = file[:relative_path]
+            extension = File.extname(data_path)
+            basename  = File.basename(data_path, extension)
+
+            data_branch = @local_data
+
+            path = data_path.to_s.split(File::SEPARATOR)[0..-2]
+            path.each do |dir|
+              data_branch = data_branch[dir.to_sym]
+            end
+
+            data_branch.delete(basename.to_sym) if data_branch.key?(basename.to_sym)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,225 +1,54 @@
 require 'middleman-core/contracts'
-require 'middleman-core/util/data'
+require 'middleman-core/core_extensions/data/controller'
 
 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
-    class Data < Extension
-      attr_reader :data_store
+    module Data
+      # The data extension parses YAML and JSON files in the `data/` directory
+      # and makes them available to `config.rb`, templates and extensions
+      class DataExtension < Extension
+        attr_reader :data_store
 
-      define_setting :data_dir, ENV['MM_DATA_DIR'] || 'data', 'The directory data files are stored in'
+        define_setting :data_dir, ENV['MM_DATA_DIR'] || 'data', 'The directory data files are stored in'
+        define_setting :track_data_access, false, 'If we should track data accesses'
 
-      # Make the internal `data_store` method available as `app.data`
-      expose_to_application data: :data_store
+        # 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
+        # Exposes `internal_data_store` to templates, to be wrapped by `data` in the context
+        expose_to_template internal_data_store: :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
-
-      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
-        app.files.on_change(:data, &@data_store.method(:update_files))
-      end
-
-      def after_configuration
-        return unless @original_data_dir != app.config[:data_dir]
-
-        @watcher.update_path(app.config[:data_dir])
-      end
-
-      # The core logic behind the data extension.
-      class DataStore
-        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
-        #
-        # @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[name.to_s] = content unless name.nil? || content.nil?
-          @local_sources
-        end
-
-        # Store callback-based data
-        #
-        # @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[name.to_s] = proc unless name.nil? || proc.nil?
-          @callback_sources
-        end
-
-        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)
-          data_path = file[:relative_path]
-          extension = File.extname(data_path)
-          basename  = File.basename(data_path, extension)
-
-          return unless %w(.yaml .yml .json .toml).include?(extension)
-
-          if %w(.yaml .yml).include?(extension)
-            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, _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] ||= {}
-            data_branch = data_branch[dir]
-          end
-
-          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)
-          data_path = file[:relative_path]
-          extension = File.extname(data_path)
-          basename  = File.basename(data_path, extension)
-
-          data_branch = @local_data
-
-          path = data_path.to_s.split(File::SEPARATOR)[0..-2]
-          path.each do |dir|
-            data_branch = data_branch[dir]
-          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 = if store.key?(path.to_s)
-            store[path.to_s]
-          elsif callbacks.key?(path.to_s)
-            callbacks[path.to_s].call
-          end
-
-          ::Middleman::Util.recursively_enhance(response)
-        end
-
-        # "Magically" find namespaces of data if they exist
-        #
-        # @param [String] path The namespace to search for
-        # @return [Hash, nil]
-        def method_missing(path)
-          if @local_data.key?(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 result if result
-          end
+        # The regex which tells Middleman which files are for data
+        DATA_FILE_MATCHER = /^(.*?)[\w-]+\.(yml|yaml|json)$/.freeze
 
+        Contract IsA['::Middleman::Application'], Hash => Any
+        def initialize(app, options_hash = ::Middleman::EMPTY_HASH, &block)
           super
-        end
 
-        # Needed so that method_missing makes sense
-        def respond_to?(method, include_private=false)
-          super || key?(method)
-        end
-
-        # Make DataStore act like a hash. Return requested data, or
-        # nil if data does not exist
-        #
-        # @param [String, Symbol] key The name of the data namespace
-        # @return [Hash, nil]
-        def [](key)
-          __send__(key) if key?(key)
-        end
+          @data_store = DataStoreController.new(app, app.config[:track_data_access])
 
-        def key?(key)
-          (@local_data.keys + @local_sources.keys + @callback_sources.keys).include?(key.to_s)
+          start_watching(app.config[:data_dir])
         end
 
-        alias has_key? key?
+        Contract String => Any
+        def start_watching(dir)
+          @original_data_dir = dir
 
-        # Convert all the data into a static hash
-        #
-        # @return [Hash]
-        Contract Hash
-        def to_h
-          data = {}
+          # Tell the file watcher to observe the :data_dir
+          @watcher = app.files.watch :data,
+                                     path: File.expand_path(dir, app.root),
+                                     only: DATA_FILE_MATCHER
 
-          store.each_key do |k|
-            data[k] = data_for_path(k)
-          end
-
-          callbacks.each_key do |k|
-            data[k] = data_for_path(k)
-          end
+          # Setup data files before anything else so they are available when
+          # parsing config.rb
+          app.files.on_change(:data, &@data_store.method(:update_files))
+        end
 
-          (@local_data || {}).each do |k, v|
-            data[k] = v
-          end
+        Contract Any
+        def after_configuration
+          return unless @original_data_dir != app.config[:data_dir]
 
-          data
+          @watcher.update_path(app.config[:data_dir])
         end
       end
     end

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

@@ -1,12 +1,4 @@
 require 'padrino-helpers'
-require 'padrino-helpers/output_helpers'
-require 'padrino-helpers/asset_tag_helpers'
-require 'padrino-helpers/form_helpers'
-require 'padrino-helpers/format_helpers'
-require 'padrino-helpers/number_helpers'
-require 'padrino-helpers/output_helpers'
-require 'padrino-helpers/render_helpers'
-require 'active_support/core_ext/array/extract_options'
 require 'middleman-core/contracts'
 
 # Don't fail on invalid locale, that's not what our current
@@ -28,11 +20,9 @@ end
 class Middleman::CoreExtensions::DefaultHelpers < ::Middleman::Extension
   define_setting :relative_links, false, 'Whether to generate relative links instead of absolute ones'
 
-  def initialize(app, options_hash={}, &block)
+  def initialize(app, options_hash = ::Middleman::EMPTY_HASH, &block)
     super
 
-    require 'active_support/core_ext/object/to_query'
-
     ::Middleman::TemplateContext.send :include, ::Padrino::Helpers::OutputHelpers
     ::Middleman::TemplateContext.send :include, ::Padrino::Helpers::TagHelpers
     ::Middleman::TemplateContext.send :include, ::Padrino::Helpers::AssetTagHelpers
@@ -46,7 +36,7 @@ class Middleman::CoreExtensions::DefaultHelpers < ::Middleman::Extension
   # The helpers
   helpers do
     # Make all block content html_safe
-    def content_tag(name, content=nil, options=nil, &block)
+    def content_tag(name, content = nil, options = nil, &block)
       # safe_content_tag(name, content, options, &block)
       if block_given?
         options = content if content.is_a?(Hash)
@@ -55,7 +45,7 @@ class Middleman::CoreExtensions::DefaultHelpers < ::Middleman::Extension
 
       options    = parse_data_options(name, options)
       attributes = tag_attributes(options)
-      output = ActiveSupport::SafeBuffer.new
+      output = ::ActiveSupport::SafeBuffer.new
       output.safe_concat "<#{name}#{attributes}>"
 
       if content.respond_to?(:each) && !content.is_a?(String)
@@ -72,11 +62,13 @@ class Middleman::CoreExtensions::DefaultHelpers < ::Middleman::Extension
     end
 
     def capture_html(*args, &block)
-      result = if handler = auto_find_proper_handler(&block)
-        handler.capture_from_template(*args, &block)
-      else
-        yield(*args)
-      end
+      handler = auto_find_proper_handler(&block)
+
+      result = if handler
+                 handler.capture_from_template(*args, &block)
+               else
+                 yield(*args)
+               end
 
       ::ActiveSupport::SafeBuffer.new.safe_concat(result)
     end
@@ -148,14 +140,14 @@ class Middleman::CoreExtensions::DefaultHelpers < ::Middleman::Extension
     # @param [Symbol] asset_ext The type of asset
     # @param [String] asset_dir Where to look for assets
     # @return [void]
-    def auto_tag(asset_ext, asset_dir=nil)
+    def auto_tag(asset_ext, asset_dir = nil)
       if asset_dir.nil?
         asset_dir = case asset_ext
-        when :js
-          config[:js_dir]
-        when :css
-          config[:css_dir]
-        end
+                    when :js
+                      config[:js_dir]
+                    when :css
+                      config[:css_dir]
+                    end
       end
 
       # If the basename of the request as no extension, assume we are serving a
@@ -163,13 +155,15 @@ class Middleman::CoreExtensions::DefaultHelpers < ::Middleman::Extension
       path = File.join(asset_dir, current_resource.path)
       path = path[0..-(File.extname(path).length + 1)] + ".#{asset_ext}"
 
-      yield path if sitemap.find_resource_by_path(path)
+      yield path if sitemap.by_path(path)
     end
 
     # Generate body css classes based on the current path
     #
     # @return [String]
-    def page_classes(path=current_path.dup, options={})
+    def page_classes(path = current_path.dup, options_hash = ::Middleman::EMPTY_HASH)
+      options = options_hash
+
       if path.is_a? Hash
         options = path
         path = current_path.dup
@@ -199,8 +193,8 @@ class Middleman::CoreExtensions::DefaultHelpers < ::Middleman::Extension
     # @param [String] source The path to the file
     # @param [Hash] options Data to pass through.
     # @return [String]
-    def asset_path(kind, source, options={})
-      options_with_resource = {}.merge!(options).merge!(current_resource: current_resource)
+    def asset_path(kind, source, options_hash = ::Middleman::EMPTY_HASH)
+      options_with_resource = {}.merge!(options_hash).merge!(current_resource: current_resource)
       ::Middleman::Util.asset_path(app, kind, source, options_with_resource)
     end
 
@@ -210,19 +204,16 @@ class Middleman::CoreExtensions::DefaultHelpers < ::Middleman::Extension
     # @param [String] prefix The type prefix (such as "images")
     # @param [Hash] options Additional options.
     # @return [String] The fully qualified asset url
-    def asset_url(path, prefix='', options={})
-      options_with_resource = {}.merge!(options).merge!(current_resource: current_resource)
+    def asset_url(path, prefix = '', options_hash = ::Middleman::EMPTY_HASH)
+      options_with_resource = {}.merge!(options_hash).merge!(current_resource: current_resource)
       ::Middleman::Util.asset_url(app, path, prefix, options_with_resource)
     end
 
     # Given a source path (referenced either absolutely or relatively)
     # or a Resource, this will produce the nice URL configured for that
     # path, respecting :relative_links, directory indexes, etc.
-    #
-    # Relative routes will be relative the the current_resource. Pass the
-    # `:current_resource` option to customize.
-    def url_for(path_or_resource, options={})
-      options_with_resource = {}.merge!(current_resource: current_resource).merge!(options)
+    def url_for(path_or_resource, options_hash = ::Middleman::EMPTY_HASH)
+      options_with_resource = {}.merge!(options_hash).merge!(current_resource: current_resource)
       ::Middleman::Util.url_for(app, path_or_resource, options_with_resource)
     end
 
@@ -243,11 +234,11 @@ class Middleman::CoreExtensions::DefaultHelpers < ::Middleman::Extension
       url_arg_index = block_given? ? 0 : 1
       options_index = block_given? ? 1 : 2
 
-      if block_given? && args.size > 2
-        raise ArgumentError, 'Too many arguments to link_to(url, options={}, &block)'
-      end
+      raise ArgumentError, 'Too many arguments to link_to(url, options={}, &block)' if block_given? && args.size > 2
+
+      url = args[url_arg_index]
 
-      if url = args[url_arg_index]
+      if url
         options = args[options_index] || {}
         raise ArgumentError, 'Options must be a hash' unless options.is_a?(Hash)
 
@@ -263,14 +254,14 @@ class Middleman::CoreExtensions::DefaultHelpers < ::Middleman::Extension
 
     # Modified Padrino form_for that uses Middleman's url_for
     # to transform the URL.
-    def form_tag(url, options={}, &block)
-      url = url_for(url, options)
+    def form_tag(url, options_hash = ::Middleman::EMPTY_HASH, &block)
+      url = url_for(url, options_hash)
       super
     end
 
     # Modified Padrino image_tag so that it finds the paths for srcset
     # using asset_path for the images listed in the srcset param
-    def image_tag(path, params={})
+    def image_tag(path, params = {})
       params.symbolize_keys!
 
       if params.key?(:srcset)
@@ -286,13 +277,13 @@ class Middleman::CoreExtensions::DefaultHelpers < ::Middleman::Extension
         params[:srcset] = images_sources.join(', ')
       end
 
-      params[:alt] ||= ''
-
       super(path, params)
     end
 
-    def partial(template, options={}, &block)
-      including_parent_locals = {}
+    def partial(template, options_hash = ::Middleman::EMPTY_HASH, &block)
+      options = options_hash.dup
+
+      including_parent_locals = Middleman::Util::EnhancedHash.new
       including_parent_locals.merge!(@locs || {})
       including_parent_locals.merge!(options[:locals] || {})
 

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

@@ -19,7 +19,7 @@ module Middleman
           module_name = app.config[:helpers_filename_to_module_name_proc].call(filename)
           next unless module_name
 
-          require filename
+          load filename
           next unless Object.const_defined?(module_name.to_sym)
 
           app.template_context_class.send :include, Object.const_get(module_name.to_sym)

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

@@ -24,7 +24,7 @@ module Middleman
       }.freeze
 
       # Setup the extension.
-      def initialize(app, config={}, &block)
+      def initialize(app, options_hash = ::Middleman::EMPTY_HASH, &block)
         super
 
         # Setup source collection.
@@ -59,9 +59,7 @@ module Middleman
           wait_for_delay: app.config[:watcher_wait_for_delay]
         )
 
-        if @original_source_dir != app.config[:source]
-          @watcher.update_path(app.config[:source])
-        end
+        @watcher.update_path(app.config[:source]) if @original_source_dir != app.config[:source]
 
         @sources.start!
         @sources.poll_once!

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

@@ -4,8 +4,6 @@ require 'pathname'
 # DbC
 require 'middleman-core/contracts'
 
-require 'active_support/core_ext/hash/keys'
-
 require 'middleman-core/util/data'
 
 # Extensions namespace
@@ -16,12 +14,11 @@ module Middleman::CoreExtensions
 
     # Set textual delimiters that denote the start and end of frontmatter
     define_setting :frontmatter_delims, {
-      json: [%w(;;; ;;;)],
-      toml: [%w(+++ +++)],
-      yaml: [%w(--- ---), %w(--- ...)]
+      json: [%w[;;; ;;;]],
+      yaml: [%w[--- ---], %w[--- ...]]
     }, 'Allowed frontmatter delimiters'
 
-    def initialize(app, options_hash={}, &block)
+    def initialize(app, options_hash = ::Middleman::EMPTY_HASH, &block)
       super
 
       @cache = {}
@@ -31,11 +28,9 @@ module Middleman::CoreExtensions
       app.files.on_change(:source, &method(:clear_data))
     end
 
-    # @return Array<Middleman::Sitemap::Resource>
-    Contract ResourceList => ResourceList
-    def manipulate_resource_list(resources)
-      resources.each do |resource|
-        next if resource.binary?
+    Contract IsA['Middleman::Sitemap::ResourceListContainer'] => Any
+    def manipulate_resource_list_container!(resource_list)
+      resource_list.by_binary(false).each do |resource|
         next if resource.file_descriptor.nil?
         next if resource.file_descriptor[:types].include?(:no_frontmatter)
 
@@ -52,9 +47,21 @@ module Middleman::CoreExtensions
         # TODO: Enhance data? NOOOO
         # TODO: stringify-keys? immutable/freeze?
 
-        resource.add_metadata options: opts, page: fmdata
+        resource.add_metadata_options opts
+
+        if fmdata.key?(:id)
+          resource_list.update!(resource, :page_id) do
+            resource.add_metadata_page fmdata
+          end
+        else
+          resource.add_metadata_page fmdata
+        end
+
+        next unless ignored == true && !resource.is_a?(::Middleman::Sitemap::ProxyResource)
 
-        resource.ignore! if ignored == true && !resource.is_a?(::Middleman::Sitemap::ProxyResource)
+        resource_list.update!(resource, :ignored) do
+          resource.ignore!
+        end
 
         # TODO: Save new template here somewhere?
       end
@@ -77,10 +84,14 @@ module Middleman::CoreExtensions
       file_path = file[:full_path].to_s
 
       @cache[file_path] ||= begin
-        ::Middleman::Util::Data.parse(
-          file,
-          app.config[:frontmatter_delims]
-        )
+        if ::Middleman::Util.contains_frontmatter?(file_path, app.config[:frontmatter_delims])
+          ::Middleman::Util::Data.parse(
+            file,
+            app.config[:frontmatter_delims]
+          )
+        else
+          [{}, nil]
+        end
       end
     end