middleman-core 3.4.1 → 4.0.0.alpha.2

data/lib/middleman-core/contracts.rb

@@ -0,0 +1,149 @@
+if ENV['TEST'] || ENV['CONTRACTS'] == 'true'
+  require 'contracts'
+
+  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
+
+    class Frozen < CallableClass
+      def initialize(contract)
+        @contract = contract
+      end
+
+      def valid?(val)
+        (val.frozen? || val.nil?) && Contract.valid?(val, @contract)
+      end
+    end
+
+    class ArrayOf
+      def initialize(contract)
+        @contract = contract.is_a?(String) ? IsA[contract] : contract
+      end
+    end
+
+    class SetOf < CallableClass
+      def initialize(contract)
+        @contract = contract.is_a?(String) ? IsA[contract] : contract
+      end
+
+      def valid?(vals)
+        return false unless vals.is_a?(Set)
+        vals.all? do |val|
+          res, _ = Contract.valid?(val, @contract)
+          res
+        end
+      end
+
+      def to_s
+        "a set of #{@contract}"
+      end
+
+      def testable?
+        Testable.testable? @contract
+      end
+
+      def test_data
+        Set.new([], [Testable.test_data(@contract)], [Testable.test_data(@contract), Testable.test_data(@contract)])
+      end
+    end
+
+    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
+  end
+end
+
+module Contracts
+  PATH_MATCHER = Or[String, RespondTo[:match], RespondTo[:call], RespondTo[:to_s]]
+end

data/lib/middleman-core/core_extensions.rb

@@ -1,94 +1,135 @@
-# Rack Request
-require 'middleman-core/core_extensions/request'
+require 'middleman-core/extensions'
 
 # File Change Notifier
-require 'middleman-core/core_extensions/file_watcher'
+Middleman::Extensions.register :file_watcher, auto_activate: :before_sitemap do
+  require 'middleman-core/core_extensions/file_watcher'
+  Middleman::CoreExtensions::FileWatcher
+end
 
-# Custom Feature API
-require 'middleman-core/core_extensions/extensions'
+# Parse YAML from templates
+Middleman::Extensions.register :front_matter, auto_activate: :before_sitemap do
+  require 'middleman-core/core_extensions/front_matter'
+  Middleman::CoreExtensions::FrontMatter
+end
 
 # Data looks at the data/ folder for YAML files and makes them available
 # to dynamic requests.
-require 'middleman-core/core_extensions/data'
+Middleman::Extensions.register :data, auto_activate: :before_sitemap do
+  require 'middleman-core/core_extensions/data'
+  Middleman::CoreExtensions::Data
+end
 
-# Parse YAML from templates
-require 'middleman-core/core_extensions/front_matter'
+# Catch and show exceptions at the Rack level
+Middleman::Extensions.register :show_exceptions, auto_activate: :before_configuration, modes: [:server] do
+  require 'middleman-core/core_extensions/show_exceptions'
+  Middleman::CoreExtensions::ShowExceptions
+end
 
 # External helpers looks in the helpers/ folder for helper modules
-require 'middleman-core/core_extensions/external_helpers'
+Middleman::Extensions.register :external_helpers, auto_activate: :before_configuration do
+  require 'middleman-core/core_extensions/external_helpers'
+  Middleman::CoreExtensions::ExternalHelpers
+end
 
 # Extended version of Padrino's rendering
 require 'middleman-core/core_extensions/rendering'
 
-# Pass custom options to views
-require 'middleman-core/core_extensions/routing'
-
-# Catch and show exceptions at the Rack level
-require 'middleman-core/core_extensions/show_exceptions'
-
 # Setup default helpers
-require 'middleman-more/core_extensions/default_helpers'
+Middleman::Extensions.register :default_helpers, auto_activate: :before_configuration do
+  require 'middleman-core/core_extensions/default_helpers'
+  Middleman::CoreExtensions::DefaultHelpers
+end
 
-require 'middleman-more/core_extensions/i18n'
+# Lorem provides a handful of helpful prototyping methods to generate
+# words, paragraphs, fake images, names and email addresses.
+Middleman::Extensions.register :lorem, auto_activate: :before_configuration do
+  require 'middleman-core/extensions/lorem'
+  Middleman::Extensions::Lorem
+end
 
-# Compass framework
-begin
-  require 'middleman-more/core_extensions/compass'
-rescue LoadError
+Middleman::Extensions.register :routing, auto_activate: :before_configuration do
+  require 'middleman-core/core_extensions/routing'
+  Middleman::CoreExtensions::Routing
 end
 
 ###
 # Setup Optional Extensions
 ###
 
+Middleman::Extensions.register :i18n do
+  require 'middleman-core/core_extensions/i18n'
+  Middleman::CoreExtensions::Internationalization
+end
+
 # CacheBuster adds a query string to assets in dynamic templates to
 # avoid browser caches failing to update to your new content.
-require 'middleman-more/extensions/cache_buster'
-Middleman::Extensions::CacheBuster.register
+Middleman::Extensions.register :cache_buster do
+  require 'middleman-core/extensions/cache_buster'
+  Middleman::Extensions::CacheBuster
+end
 
 # RelativeAssets allow any asset path in dynamic templates to be either
 # relative to the root of the project or use an absolute URL.
-require 'middleman-more/extensions/relative_assets'
-Middleman::Extensions::RelativeAssets.register
+Middleman::Extensions.register :relative_assets do
+  require 'middleman-core/extensions/relative_assets'
+  Middleman::Extensions::RelativeAssets
+end
 
 # AssetHost allows you to setup multiple domains to host your static
 # assets. Calls to asset paths in dynamic templates will then rotate
 # through each of the asset servers to better spread the load.
-require 'middleman-more/extensions/asset_host'
-Middleman::Extensions::AssetHost.register
+Middleman::Extensions.register :asset_host do
+  require 'middleman-core/extensions/asset_host'
+  Middleman::Extensions::AssetHost
+end
 
 # MinifyCss compresses CSS
-require 'middleman-more/extensions/minify_css'
-Middleman::Extensions::MinifyCss.register
+Middleman::Extensions.register :minify_css do
+  require 'middleman-core/extensions/minify_css'
+  Middleman::Extensions::MinifyCss
+end
 
 # MinifyJavascript compresses JS
-require 'middleman-more/extensions/minify_javascript'
-Middleman::Extensions::MinifyJavascript.register
+Middleman::Extensions.register :minify_javascript do
+  require 'middleman-core/extensions/minify_javascript'
+  Middleman::Extensions::MinifyJavascript
+end
 
 # GZIP assets and pages during build
-require 'middleman-more/extensions/gzip'
-Middleman::Extensions::Gzip.register
+Middleman::Extensions.register :gzip do
+  require 'middleman-core/extensions/gzip'
+  Middleman::Extensions::Gzip
+end
 
 # AssetHash appends a hash of the file contents to the assets filename
 # to avoid browser caches failing to update to your new content.
-require 'middleman-more/extensions/asset_hash'
-Middleman::Extensions::AssetHash.register
+Middleman::Extensions.register :asset_hash do
+  require 'middleman-core/extensions/asset_hash'
+  Middleman::Extensions::AssetHash
+end
 
 # Provide Apache-style index.html files for directories
-require 'middleman-more/extensions/directory_indexes'
-Middleman::Extensions::DirectoryIndexes.register
-
-# Lorem provides a handful of helpful prototyping methods to generate
-# words, paragraphs, fake images, names and email addresses.
-require 'middleman-more/extensions/lorem'
+Middleman::Extensions.register :directory_indexes do
+  require 'middleman-core/extensions/directory_indexes'
+  Middleman::Extensions::DirectoryIndexes
+end
 
 # AutomaticImageSizes inspects the images used in your dynamic templates
 # and automatically adds width and height attributes to their HTML
 # elements.
-require 'middleman-more/extensions/automatic_image_sizes'
-Middleman::Extensions::AutomaticImageSizes.register
+Middleman::Extensions.register :automatic_image_sizes do
+  require 'middleman-core/extensions/automatic_image_sizes'
+  Middleman::Extensions::AutomaticImageSizes
+end
 
 # AutomaticAltTags uses the file name of the `image_tag` to generate
 # a default `:alt` value.
-require 'middleman-more/extensions/automatic_alt_tags'
-Middleman::Extensions::AutomaticAltTags.register
+Middleman::Extensions.register :automatic_alt_tags do
+  require 'middleman-core/extensions/automatic_alt_tags'
+  Middleman::Extensions::AutomaticAltTags
+end
+
+Middleman::Extensions.register :external_pipeline do
+  require 'middleman-core/extensions/external_pipeline'
+  Middleman::Extensions::ExternalPipeline
+end

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

@@ -1,54 +1,66 @@
+require 'yaml'
+require 'active_support/json'
+require 'middleman-core/contracts'
+
 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)
-          require 'middleman-core/core_extensions/data/file_loader'
-
-          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
+
+      # The regex which tells Middleman which files are for data
+      DATA_FILE_MATCHER = /^(.*?)[\w-]+\.(yml|yaml|json)$/
+
+      def initialize(app, config={}, &block)
+        super
+        @data_store = DataStore.new(app, DATA_FILE_MATCHER)
+        app.config.define_setting :data_dir, 'data', 'The directory data files are stored in'
+
+        app.add_to_instance(:data, &method(:data_store))
+        app.add_to_config_context(:data, &method(:data_store))
+
+        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),
+                                   ignore: proc { |f| !DATA_FILE_MATCHER.match(f[:relative_path]) }
+
         # 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.changed(: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
+        @watcher.update_path(app.config[:data_dir])
+      end
 
-        # The data object
-        #
-        # @return [DataStore]
+      helpers do
         def data
-          @_data ||= DataStore.new(self)
+          extensions[:data].data_store
         end
       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_sources = {}
+          @callback_sources = {}
         end
 
         # Store static data hash
@@ -56,10 +68,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, Hash => 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
@@ -67,35 +79,33 @@ module Middleman
         # @param [Symbol] name Name of the data, used for namespacing
         # @param [Proc] proc The callback which will return data
         # @return [Hash]
+        Contract Symbol, 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))
         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 = full_path.relative_path_from(root + @app.config[:data_dir])
-
-          begin
-            data = FileLoader.new.load(full_path)
-          rescue FileLoader::NoFileLoaderFoundError
+          data_path = file[:relative_path]
+          extension = File.extname(data_path)
+          basename  = File.basename(data_path, extension)
+
+          if %w(.yaml .yml).include?(extension)
+            data = YAML.load_file(file[:full_path])
+          elsif extension == '.json'
+            data = ActiveSupport::JSON.decode(file[:full_path].read)
+          else
             return
           end
 
@@ -103,24 +113,22 @@ module Middleman
 
           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
         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
 
@@ -136,15 +144,15 @@ module Middleman
         #
         # @param [String, Symbol] path The name of the data namespace
         # @return [Hash, nil]
+        Contract Or[String, Symbol] => Maybe[Hash]
         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)
           response
         end
 
@@ -154,10 +162,11 @@ module Middleman
         # @return [Hash, nil]
         def method_missing(path)
           if @local_data.key?(path.to_s)
+            @local_data[path.to_s] = ::Middleman::Util.recursively_enhance(@local_data[path.to_s])
             return @local_data[path.to_s]
           else
             result = data_for_path(path)
-            return ::Middleman::Util.recursively_enhance(result) if result
+            return result if result
           end
 
           super
@@ -186,6 +195,7 @@ module Middleman
         # Convert all the data into a static hash
         #
         # @return [Hash]
+        Contract None => Hash
         def to_h
           data = {}