middleman-core 4.0.0.alpha.6 → 4.0.0.beta.1

data/lib/middleman-core/cli/server.rb

@@ -0,0 +1,86 @@
+# CLI Module
+module Middleman::Cli
+  # Server thor task
+  class Server < Thor
+    check_unknown_options!
+
+    namespace :server
+
+    desc 'server [options]', 'Start the preview server'
+    method_option :environment,
+                  aliases: '-e',
+                  default: ENV['MM_ENV'] || ENV['RACK_ENV'] || 'development',
+                  desc: 'The environment Middleman will run under'
+    method_option :host,
+                  type: :string,
+                  aliases: '-h',
+                  desc: 'Bind to HOST address'
+    method_option :port,
+                  aliases: '-p',
+                  desc: 'The port Middleman will listen on'
+    method_option :verbose,
+                  type: :boolean,
+                  default: false,
+                  desc: 'Print debug messages'
+    method_option :instrument,
+                  type: :string,
+                  default: false,
+                  desc: 'Print instrument messages'
+    method_option :disable_watcher,
+                  type: :boolean,
+                  default: false,
+                  desc: 'Disable the file change and delete watcher process'
+    method_option :profile,
+                  type: :boolean,
+                  default: false,
+                  desc: 'Generate profiling report for server startup'
+    method_option :reload_paths,
+                  type: :string,
+                  default: false,
+                  desc: 'Additional paths to auto-reload when files change'
+    method_option :force_polling,
+                  type: :boolean,
+                  default: false,
+                  desc: 'Force file watcher into polling mode'
+    method_option :latency,
+                  type: :numeric,
+                  aliases: '-l',
+                  default: 0.25,
+                  desc: 'Set file watcher latency, in seconds'
+
+    # Start the server
+    def server
+      require 'middleman-core'
+      require 'middleman-core/preview_server'
+
+      unless ENV['MM_ROOT']
+        puts '== Could not find a Middleman project config.rb'
+        puts '== Treating directory as a static site to be served'
+        ENV['MM_ROOT'] = Dir.pwd
+        ENV['MM_SOURCE'] = ''
+      end
+
+      params = {
+        port: options['port'],
+        host: options['host'],
+        environment: options['environment'],
+        debug: options['verbose'],
+        instrumenting: options['instrument'],
+        disable_watcher: options['disable_watcher'],
+        reload_paths: options['reload_paths'],
+        force_polling: options['force_polling'],
+        latency: options['latency']
+      }
+
+      puts '== The Middleman is loading'
+      ::Middleman::PreviewServer.start(params)
+    end
+  end
+
+  def self.exit_on_failure?
+    true
+  end
+
+  # Map "s" to "server"
+  Base.map('s' => 'server')
+end

data/lib/middleman-core/config_context.rb

@@ -7,7 +7,7 @@ module Middleman
     attr_reader :app
 
     # Whitelist methods that can reach out.
-    def_delegators :@app, :config, :logger, :use, :map, :mime_type, :data, :files, :root, :build?, :server?, :environment?
+    def_delegators :@app, :config, :logger, :use, :map, :mime_type, :files, :root, :build?, :server?, :environment?
     def_delegator :"@app.extensions", :activate
 
     def initialize(app, template_context_class)

data/lib/middleman-core/contracts.rb

@@ -27,38 +27,6 @@ if ENV['TEST'] || ENV['CONTRACTS'] == 'true'
       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
-
     # class MethodDefined
     #   def self.[](val)
     #     @lookup ||= {}

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

@@ -16,7 +16,21 @@ module Middleman
         # gets a chance to modify any new resources that get added.
         self.resource_list_manipulator_priority = 110
 
-        attr_accessor :root_collector, :leaves
+        attr_accessor :sitemap_collector, :data_collector, :leaves
+
+        # Expose `resources`, `data`, and `collection` to config.
+        expose_to_config resources: :sitemap_collector,
+                         data: :data_collector,
+                         collection: :register_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
@@ -25,15 +39,12 @@ module Middleman
           @collectors_by_name = {}
           @values_by_name = {}
 
-          @root_collector = LazyCollectorRoot.new(self)
+          @sitemap_collector = LazyCollectorRoot.new(self)
+          @data_collector = LazyCollectorRoot.new(self)
         end
 
-        Contract None => Any
         def before_configuration
           @leaves.clear
-
-          app.add_to_config_context :resources, &method(:root_collector)
-          app.add_to_config_context :collection, &method(:register_collector)
         end
 
         Contract Symbol, LazyCollectorStep => Any
@@ -48,7 +59,8 @@ module Middleman
 
         Contract ResourceList => ResourceList
         def manipulate_resource_list(resources)
-          @root_collector.realize!(resources)
+          @sitemap_collector.realize!(resources)
+          @data_collector.realize!(app.data)
 
           ctx = StepContext.new
           leaves = @leaves.dup
@@ -66,16 +78,6 @@ module Middleman
           # Inject descriptors
           resources + ctx.descriptors.map { |d| d.to_resource(app) }
         end
-
-        helpers do
-          def collection(label)
-            extensions[:collections].collector_value(label)
-          end
-
-          def pagination
-            current_resource.data.pagination
-          end
-        end
       end
     end
   end

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

@@ -9,17 +9,21 @@ module Middleman
     class Data < Extension
       attr_reader :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
+
       # 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
 
@@ -29,7 +33,7 @@ module Middleman
         # 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]) }
+                                   only: DATA_FILE_MATCHER
 
         # Setup data files before anything else so they are available when
         # parsing config.rb
@@ -42,12 +46,6 @@ module Middleman
         @watcher.update_path(app.config[:data_dir])
       end
 
-      helpers do
-        def data
-          extensions[:data].data_store
-        end
-      end
-
       # The core logic behind the data extension.
       class DataStore
         include Contracts
@@ -79,7 +77,7 @@ 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
+        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
@@ -102,9 +100,9 @@ module Middleman
           basename  = File.basename(data_path, extension)
 
           if %w(.yaml .yml).include?(extension)
-            data = YAML.load_file(file[:full_path])
+            data = ::YAML.load_file(file[:full_path])
           elsif extension == '.json'
-            data = ActiveSupport::JSON.decode(file[:full_path].read)
+            data = ::ActiveSupport::JSON.decode(file[:full_path].read)
           else
             return
           end
@@ -162,8 +160,8 @@ 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]
+            # Any way to cache this?
+            return ::Middleman::Util.recursively_enhance(@local_data[path.to_s])
           else
             result = data_for_path(path)
             return result if result
@@ -187,7 +185,7 @@ 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?
@@ -195,7 +193,7 @@ module Middleman
         # Convert all the data into a static hash
         #
         # @return [Hash]
-        Contract None => Hash
+        Contract Hash
         def to_h
           data = {}
 

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

@@ -68,7 +68,7 @@ class Middleman::CoreExtensions::DefaultHelpers < ::Middleman::Extension
         block.call(*args)
       end
 
-      ActiveSupport::SafeBuffer.new.safe_concat(result)
+      ::ActiveSupport::SafeBuffer.new.safe_concat(result)
     end
 
     def auto_find_proper_handler(&block)
@@ -221,5 +221,26 @@ class Middleman::CoreExtensions::DefaultHelpers < ::Middleman::Extension
       url = url_for(url, options)
       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={})
+      params.symbolize_keys!
+
+      if params.key?(:srcset)
+        images_sources = params[:srcset].split(',').map do |src_def|
+          if src_def.include?('//')
+            src_def
+          else
+            image_def, size_def = src_def.strip.split(/\s+/)
+            asset_path(:images, image_def) + ' ' + size_def
+          end
+        end
+
+        params[:srcset] = images_sources.join(', ')
+      end
+
+      super(path, params)
+    end
   end
 end

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

@@ -6,9 +6,15 @@ module Middleman
     # API for watching file change events
     class FileWatcher < Extension
       # All defined sources.
-      Contract None => IsA['Middleman::Sources']
+      Contract IsA['Middleman::Sources']
       attr_reader :sources
 
+      # Make the internal `sources` method available as `app.files`
+      expose_to_application files: :sources
+
+      # Make the internal `sources` method available in config as `files`
+      expose_to_config files: :sources
+
       # The default list of ignores.
       IGNORES = {
         emacs_files: /(^|\/)\.?#/,
@@ -34,16 +40,12 @@ module Middleman
 
         # Watch current source.
         start_watching(app.config[:source])
-
-        # Expose API to app and config.
-        app.add_to_instance(:files, &method(:sources))
-        app.add_to_config_context(:files, &method(:sources))
       end
 
       # Before we config, find initial files.
       #
       # @return [void]
-      Contract None => Any
+      Contract Any
       def before_configuration
         @sources.find_new_files!
       end
@@ -51,7 +53,7 @@ module Middleman
       # After we config, find new files since config can change paths.
       #
       # @return [void]
-      Contract None => Any
+      Contract Any
       def after_configuration
         if @original_source_dir != app.config[:source]
           @watcher.update_path(app.config[:source])

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

@@ -83,7 +83,7 @@ module Middleman::CoreExtensions
 
     # Get the frontmatter and plain content from a file
     # @param [String] path
-    # @return [Array<Middleman::Util::HashWithIndifferentAccess, String>]
+    # @return [Array<Middleman::Util::IndifferentHash, String>]
     Contract Pathname => [Hash, Maybe[String]]
     def frontmatter_and_content(full_path)
       data = {}
@@ -154,7 +154,7 @@ module Middleman::CoreExtensions
 
         begin
           json = ($1 + $2).sub(';;;', '{').sub(';;;', '}')
-          data = ActiveSupport::JSON.decode(json).symbolize_keys
+          data = ::ActiveSupport::JSON.decode(json).symbolize_keys
         rescue => e
           app.logger.error "JSON Exception parsing #{full_path}: #{e.message}"
           return nil

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

@@ -7,6 +7,9 @@ class Middleman::CoreExtensions::Internationalization < ::Middleman::Extension
   option :mount_at_root, nil, 'Mount a specific language at the root of the site'
   option :data, 'locales', 'The directory holding your locale configurations'
 
+  # Exposes `langs` to templates
+  expose_to_template :langs
+
   def after_configuration
     # See https://github.com/svenfuchs/i18n/wiki/Fallbacks
     unless options[:no_fallbacks]
@@ -19,7 +22,7 @@ class Middleman::CoreExtensions::Internationalization < ::Middleman::Extension
     # Tell the file watcher to observe the :data_dir
     app.files.watch :locales,
                     path: File.join(app.root, locales_file_path),
-                    ignore: proc { |f| !(/.*(rb|yml|yaml)$/.match(f[:relative_path])) }
+                    only: /.*(rb|yml|yaml)$/
 
     # Setup data files before anything else so they are available when
     # parsing config.rb
@@ -41,7 +44,7 @@ class Middleman::CoreExtensions::Internationalization < ::Middleman::Extension
       ::I18n.t(*args)
     end
 
-    def locate_partial(partial_name)
+    def locate_partial(partial_name, try_static=false)
       locals_dir = extensions[:i18n].options[:templates_dir]
 
       # Try /localizable
@@ -58,18 +61,18 @@ class Middleman::CoreExtensions::Internationalization < ::Middleman::Extension
       end
 
       if lang_suffix
-        super(suffixed_partial_name) ||
-          super(File.join(locals_dir, suffixed_partial_name)) ||
-          super(partials_path) ||
+        super(suffixed_partial_name, maybe_static) ||
+          super(File.join(locals_dir, suffixed_partial_name), maybe_static) ||
+          super(partials_path, try_static) ||
           super
       else
-        super(partials_path) ||
+        super(partials_path, try_static) ||
           super
       end
     end
   end
 
-  Contract None => ArrayOf[Symbol]
+  Contract ArrayOf[Symbol]
   def langs
     @langs ||= known_languages
   end
@@ -107,7 +110,6 @@ class Middleman::CoreExtensions::Internationalization < ::Middleman::Extension
 
   private
 
-  Contract Any, Any => Any
   def on_file_changed(_updated_files, _removed_files)
     @_langs = nil # Clear langs cache
 
@@ -125,7 +127,7 @@ class Middleman::CoreExtensions::Internationalization < ::Middleman::Extension
     ::I18n.fallbacks = ::I18n::Locale::Fallbacks.new if ::I18n.respond_to?(:fallbacks)
   end
 
-  Contract None => ArrayOf[Symbol]
+  Contract ArrayOf[Symbol]
   def known_languages
     if options[:langs]
       Array(options[:langs]).map(&:to_sym)

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

@@ -6,16 +6,15 @@ module Middleman
       # so it can add metadata to any pages generated by other extensions
       self.resource_list_manipulator_priority = 80
 
+      # Expose the `page` method to config.
+      expose_to_config :page
+
       def initialize(app, options_hash={}, &block)
         super
 
         @page_configs = Set.new
       end
 
-      def before_configuration
-        app.add_to_config_context(:page, &method(:page))
-      end
-
       # @return Array<Middleman::Sitemap::Resource>
       Contract ResourceList => ResourceList
       def manipulate_resource_list(resources)