middleman-core 3.3.12 → 4.4.2

data/lib/{middleman-more → middleman-core}/core_extensions/default_helpers.rb

@@ -1,4 +1,13 @@
 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
 # users expect.
@@ -6,39 +15,39 @@ require 'padrino-helpers'
 
 class Padrino::Helpers::OutputHelpers::ErbHandler
   # Force Erb capture not to use safebuffer
-  # rubocop:disable UnderscorePrefixedVariableName
   def capture_from_template(*args, &block)
-    self.output_buffer, _buf_was = '', output_buffer
-    raw = block.call(*args)
+    self.output_buffer = ''
+    buf_was = output_buffer
+    raw = yield(*args)
     captured = template.instance_variable_get(:@_out_buf)
-    self.output_buffer = _buf_was
+    self.output_buffer = buf_was
     engine_matches?(block) && !captured.empty? ? captured : raw
   end
 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)
     super
 
     require 'active_support/core_ext/object/to_query'
 
-    app.helpers ::Padrino::Helpers::OutputHelpers
-    app.helpers ::Padrino::Helpers::TagHelpers
-    app.helpers ::Padrino::Helpers::AssetTagHelpers
-    app.helpers ::Padrino::Helpers::FormHelpers
-    app.helpers ::Padrino::Helpers::FormatHelpers
-    app.helpers ::Padrino::Helpers::RenderHelpers
-    app.helpers ::Padrino::Helpers::NumberHelpers
-    # app.helpers ::Padrino::Helpers::TranslationHelpers
-
-    app.config.define_setting :relative_links, false, 'Whether to generate relative links instead of absolute ones'
+    ::Middleman::TemplateContext.send :include, ::Padrino::Helpers::OutputHelpers
+    ::Middleman::TemplateContext.send :include, ::Padrino::Helpers::TagHelpers
+    ::Middleman::TemplateContext.send :include, ::Padrino::Helpers::AssetTagHelpers
+    ::Middleman::TemplateContext.send :include, ::Padrino::Helpers::FormHelpers
+    ::Middleman::TemplateContext.send :include, ::Padrino::Helpers::FormatHelpers
+    ::Middleman::TemplateContext.send :include, ::Padrino::Helpers::RenderHelpers
+    ::Middleman::TemplateContext.send :include, ::Padrino::Helpers::NumberHelpers
+    # ::Middleman::TemplateContext.send :include, ::Padrino::Helpers::TranslationHelpers
   end
 
   # The helpers
   helpers do
     # Make all block content html_safe
-    # rubocop:disable Semicolon
     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)
         content = capture_html(&block)
@@ -50,9 +59,12 @@ class Middleman::CoreExtensions::DefaultHelpers < ::Middleman::Extension
       output.safe_concat "<#{name}#{attributes}>"
 
       if content.respond_to?(:each) && !content.is_a?(String)
-        content.each { |c| output.safe_concat c; output.safe_concat ::Padrino::Helpers::TagHelpers::NEWLINE }
+        content.each do |c|
+          output.safe_concat c
+          output.safe_concat ::Padrino::Helpers::TagHelpers::NEWLINE
+        end
       else
-        output.safe_concat "#{content}"
+        output.safe_concat content.to_s
       end
       output.safe_concat "</#{name}>"
 
@@ -63,16 +75,19 @@ class Middleman::CoreExtensions::DefaultHelpers < ::Middleman::Extension
       result = if handler = auto_find_proper_handler(&block)
         handler.capture_from_template(*args, &block)
       else
-        block.call(*args)
+        yield(*args)
       end
 
-      ActiveSupport::SafeBuffer.new.safe_concat(result)
+      ::ActiveSupport::SafeBuffer.new.safe_concat(result)
     end
 
     def auto_find_proper_handler(&block)
-      engine = block_given? ? File.extname(block.source_location[0])[1..-1].to_sym : current_engine
-      handler_class = ::Padrino::Helpers::OutputHelpers.handlers[engine]
-      handler_class && handler_class.new(self)
+      if block_given?
+        engine = File.extname(block.source_location[0])[1..-1].to_sym
+        ::Padrino::Helpers::OutputHelpers.handlers.select { |e, _| e == engine }.values.map { |h| h.new(self) }.find { |h| h.engine_matches?(block) }
+      else
+        find_proper_handler
+      end
     end
 
     # Disable Padrino cache buster
@@ -98,6 +113,36 @@ class Middleman::CoreExtensions::DefaultHelpers < ::Middleman::Extension
       end
     end
 
+    # Override helper to add `relative` opt-out.
+    def stylesheet_link_tag(*sources)
+      options = {
+        rel: 'stylesheet'
+      }.update(sources.extract_options!.symbolize_keys)
+
+      path_options = {}
+      path_options[:relative] = options.delete(:relative) if options.key?(:relative)
+
+      sources.flatten.reduce(::ActiveSupport::SafeBuffer.new) do |all, source|
+        all << tag(:link, {
+          href: asset_path(:css, source, path_options)
+        }.update(options))
+      end
+    end
+
+    # Override helper to add `relative` opt-out.
+    def javascript_include_tag(*sources)
+      options = sources.extract_options!.symbolize_keys
+
+      path_options = {}
+      path_options[:relative] = options.delete(:relative) if options.key?(:relative)
+
+      sources.flatten.reduce(::ActiveSupport::SafeBuffer.new) do |all, source|
+        all << content_tag(:script, nil, {
+          src: asset_path(:js, source, path_options)
+        }.update(options))
+      end
+    end
+
     # Output a stylesheet link tag based on the current path
     #
     # @param [Symbol] asset_ext The type of asset
@@ -107,16 +152,16 @@ class Middleman::CoreExtensions::DefaultHelpers < ::Middleman::Extension
       if asset_dir.nil?
         asset_dir = case asset_ext
         when :js
-          js_dir
+          config[:js_dir]
         when :css
-          css_dir
+          config[:css_dir]
         end
       end
 
       # If the basename of the request as no extension, assume we are serving a
       # directory and join index_file to the path.
       path = File.join(asset_dir, current_resource.path)
-      path = path.sub(/#{Regexp.escape(File.extname(path))}$/, ".#{asset_ext}")
+      path = path[0..-(File.extname(path).length + 1)] + ".#{asset_ext}"
 
       yield path if sitemap.find_resource_by_path(path)
     end
@@ -133,7 +178,7 @@ class Middleman::CoreExtensions::DefaultHelpers < ::Middleman::Extension
       path << index_file if path.end_with?('/')
       path = ::Middleman::Util.strip_leading_slash(path)
 
-      classes = []
+      classes = Set.new
       parts = path.split('.').first.split('/')
       parts.each_with_index { |_, i| classes << parts.first(i + 1).join('_') }
 
@@ -152,61 +197,30 @@ class Middleman::CoreExtensions::DefaultHelpers < ::Middleman::Extension
     #
     # @param [Symbol] kind The type of file
     # @param [String] source The path to the file
+    # @param [Hash] options Data to pass through.
     # @return [String]
-    def asset_path(kind, source)
-      return source if source.to_s.include?('//') || source.to_s.start_with?('data:')
-      asset_folder = case kind
-      when :css
-        css_dir
-      when :js
-        js_dir
-      when :images
-        images_dir
-      when :fonts
-        fonts_dir
-      else
-        kind.to_s
-      end
-
-      source = source.to_s.tr(' ', '')
-      ignore_extension = (kind == :images || kind == :fonts) # don't append extension
-      source << ".#{kind}" unless ignore_extension || source.end_with?(".#{kind}")
-      asset_folder = '' if source.start_with?('/') # absolute path
-
-      asset_url(source, asset_folder)
+    def asset_path(kind, source, options={})
+      options_with_resource = {}.merge!(options).merge!(current_resource: current_resource)
+      ::Middleman::Util.asset_path(app, kind, source, options_with_resource)
     end
 
     # Get the URL of an asset given a type/prefix
     #
     # @param [String] path The path (such as "photo.jpg")
     # @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='')
-      # Don't touch assets which already have a full path
-      if path.include?('//') || path.start_with?('data:')
-        path
-      else # rewrite paths to use their destination path
-        if resource = sitemap.find_resource_by_destination_path(url_for(path))
-          resource.url
-        else
-          path = File.join(prefix, path)
-          if resource = sitemap.find_resource_by_path(path)
-            resource.url
-          else
-            File.join(config[:http_prefix], path)
-          end
-        end
-      end
+    def asset_url(path, prefix='', options={})
+      options_with_resource = {}.merge!(options).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.
     def url_for(path_or_resource, options={})
-      options_with_resource = options.dup
-      options_with_resource[:current_resource] ||= current_resource
-
-      ::Middleman::Util.url_for(self, path_or_resource, options_with_resource)
+      options_with_resource = {}.merge!(options).merge!(current_resource: current_resource)
+      ::Middleman::Util.url_for(app, path_or_resource, options_with_resource)
     end
 
     # Overload the regular link_to to be sitemap-aware - if you
@@ -238,12 +252,7 @@ class Middleman::CoreExtensions::DefaultHelpers < ::Middleman::Extension
         args[url_arg_index] = url_for(url, options)
 
         # Cleanup before passing to Padrino
-        options.delete(:relative)
-        options.delete(:current_resource)
-        options.delete(:find_resource)
-        options.delete(:query)
-        options.delete(:anchor)
-        options.delete(:fragment)
+        options.except!(:relative, :current_resource, :find_resource, :query, :anchor, :fragment)
       end
 
       super(*args, &block)
@@ -255,12 +264,12 @@ 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?('//')
@@ -274,7 +283,18 @@ 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 = {}
+      including_parent_locals.merge!(@locs || {})
+      including_parent_locals.merge!(options[:locals] || {})
+
+      options[:locals] = including_parent_locals
+      super(template, options, &block)
+    end
   end
 end

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

@@ -1,36 +1,29 @@
-# Load helpers in helpers/
 module Middleman
   module CoreExtensions
-    module ExternalHelpers
-      # Setup extension
-      class << self
-        # once registered
-        def registered(app)
-          # Setup a default helpers paths
-          app.config.define_setting :helpers_dir, 'helpers', 'Directory to autoload helper modules from'
-          app.config.define_setting :helpers_filename_glob, '**.rb', 'Glob pattern for matching helper ruby files'
-          app.config.define_setting :helpers_filename_to_module_name_proc, proc { |filename|
-            basename = File.basename(filename, File.extname(filename))
-            basename.camelcase
-          }, 'Proc implementing the conversion from helper filename to module name'
+    # Load helpers in `helpers/`
+    class ExternalHelpers < Extension
+      define_setting :helpers_dir, 'helpers', 'Directory to autoload helper modules from'
+      define_setting :helpers_filename_glob, '**.rb', 'Glob pattern for matching helper ruby files'
+      define_setting :helpers_filename_to_module_name_proc, proc { |filename|
+        basename = File.basename(filename, File.extname(filename))
+        basename.camelcase
+      }, 'Proc implementing the conversion from helper filename to module name'
 
-          # After config
-          app.after_configuration do
-            helpers_path = File.join(root, config[:helpers_dir])
-            next unless File.exist?(helpers_path)
+      def after_configuration
+        helpers_path = File.join(app.root, app.config[:helpers_dir])
 
-            Dir[File.join(helpers_path, config[:helpers_filename_glob])].each do |filename|
-              module_name = config[:helpers_filename_to_module_name_proc].call(filename)
-              next unless module_name
+        return unless File.exist?(helpers_path)
 
-              require filename
-              next unless Object.const_defined?(module_name.to_sym)
+        glob = File.join(helpers_path, app.config[:helpers_filename_glob])
+        ::Middleman::Util.glob_directory(glob).each do |filename|
+          module_name = app.config[:helpers_filename_to_module_name_proc].call(filename)
+          next unless module_name
 
-              helpers Object.const_get(module_name.to_sym)
-            end
-          end
+          require filename
+          next unless Object.const_defined?(module_name.to_sym)
+
+          app.template_context_class.send :include, Object.const_get(module_name.to_sym)
         end
-        alias_method :included, :registered
       end
     end
   end

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

@@ -1,178 +1,81 @@
-require 'pathname'
-require 'set'
+require 'middleman-core/contracts'
+require 'middleman-core/sources'
 
-# API for watching file change events
 module Middleman
   module CoreExtensions
-    module FileWatcher
-      IGNORE_LIST = [
-        /^bin(\/|$)/,
-        /^\.bundle(\/|$)/,
-        /^vendor(\/|$)/,
-        /^node_modules(\/|$)/,
-        /^\.sass-cache(\/|$)/,
-        /^\.cache(\/|$)/,
-        /^\.git(\/|$)/,
-        /^\.gitignore$/,
-        /\.DS_Store/,
-        /^\.rbenv-.*$/,
-        /^Gemfile$/,
-        /^Gemfile\.lock$/,
-        /~$/,
-        /(^|\/)\.?#/,
-        /^tmp\//
-      ]
-
-      # Setup extension
-      class << self
-        # Once registered
-        def registered(app)
-          app.send :include, InstanceMethods
-
-          app.config.define_setting :file_watcher_ignore, IGNORE_LIST, 'Regexes for paths that should be ignored when they change.'
-
-          # Before parsing config, load the data/ directory
-          app.before_configuration do
-            files.reload_path(config[:data_dir])
-          end
-
-          app.after_configuration do
-            config[:file_watcher_ignore] << %r{^#{config[:build_dir]}(\/|$)}
-          end
-
-          # After config, load everything else
-          app.ready do
-            files.reload_path('.')
-          end
+    # API for watching file change events
+    class FileWatcher < Extension
+      # All defined 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: /(^|\/)\.?#/,
+        tilde_files: /~$/,
+        ds_store: /\.DS_Store$/,
+        git: /(^|\/)\.git(ignore|modules|\/)/
+      }.freeze
+
+      # Setup the extension.
+      def initialize(app, config={}, &block)
+        super
+
+        # Setup source collection.
+        @sources = ::Middleman::Sources.new(app)
+
+        # Add default ignores.
+        IGNORES.each do |key, value|
+          @sources.ignore key, :all, value
         end
-        alias_method :included, :registered
-      end
 
-      # Instance methods
-      module InstanceMethods
-        # Access the file api
-        # @return [Middleman::CoreExtensions::FileWatcher::API]
-        def files
-          @_files_api ||= API.new(self)
-        end
+        # Watch current source.
+        start_watching(app.config[:source])
       end
 
-      # Core File Change API class
-      class API
-        attr_reader :app
-        attr_reader :known_paths
-        delegate :logger, to: :app
-
-        # Initialize api and internal path cache
-        def initialize(app)
-          @app = app
-          @known_paths = Set.new
-
-          @_changed = []
-          @_deleted = []
-        end
-
-        # Add callback to be run on file change
-        #
-        # @param [nil,Regexp] matcher A Regexp to match the change path against
-        # @return [Array<Proc>]
-        def changed(matcher=nil, &block)
-          @_changed << [block, matcher] if block_given?
-          @_changed
-        end
-
-        # Add callback to be run on file deletion
-        #
-        # @param [nil,Regexp] matcher A Regexp to match the deleted path against
-        # @return [Array<Proc>]
-        def deleted(matcher=nil, &block)
-          @_deleted << [block, matcher] if block_given?
-          @_deleted
-        end
-
-        # Notify callbacks that a file changed
-        #
-        # @param [Pathname] path The file that changed
-        # @return [void]
-        def did_change(path)
-          path = Pathname(path)
-          logger.debug "== File Change: #{path}"
-          @known_paths << path
-          run_callbacks(path, :changed)
-        end
-
-        # Notify callbacks that a file was deleted
-        #
-        # @param [Pathname] path The file that was deleted
-        # @return [void]
-        def did_delete(path)
-          path = Pathname(path)
-          logger.debug "== File Deletion: #{path}"
-          @known_paths.delete(path)
-          run_callbacks(path, :deleted)
-        end
-
-        # Manually trigger update events
-        #
-        # @param [Pathname] path The path to reload
-        # @param [Boolean] only_new Whether we only look for new files
-        # @return [void]
-        def reload_path(path, only_new=false)
-          # chdir into the root directory so Pathname can work with relative paths
-          Dir.chdir @app.root_path do
-            path = Pathname(path)
-            return unless path.exist?
-
-            glob = (path + '**').to_s
-            subset = @known_paths.select { |p| p.fnmatch(glob) }
-
-            ::Middleman::Util.all_files_under(path, &method(:ignored?)).each do |filepath|
-              next if only_new && subset.include?(filepath)
-
-              subset.delete(filepath)
-              did_change(filepath)
-            end
-
-            subset.each(&method(:did_delete)) unless only_new
-          end
-        end
-
-        # Like reload_path, but only triggers events on new files
-        #
-        # @param [Pathname] path The path to reload
-        # @return [void]
-        def find_new_files(path)
-          reload_path(path, true)
-        end
+      # Before we config, find initial files.
+      #
+      # @return [void]
+      Contract Any
+      def before_configuration
+        @sources.poll_once!
+      end
 
-        def exists?(path)
-          p = Pathname(path)
-          p = p.relative_path_from(Pathname(@app.root)) unless p.relative?
-          @known_paths.include?(p)
+      # After we config, find new files since config can change paths.
+      #
+      # @return [void]
+      Contract Any
+      def after_configuration
+        @watcher.update_config(
+          disable_watcher: app.config[:watcher_disable],
+          force_polling: app.config[:watcher_force_polling],
+          latency: app.config[:watcher_latency],
+          wait_for_delay: app.config[:watcher_wait_for_delay]
+        )
+
+        if @original_source_dir != app.config[:source]
+          @watcher.update_path(app.config[:source])
         end
 
-        # Whether this path is ignored
-        # @param [Pathname] path
-        # @return [Boolean]
-        def ignored?(path)
-          path = path.to_s
-          app.config[:file_watcher_ignore].any? { |r| path =~ r }
-        end
+        @sources.start!
+        @sources.poll_once!
+      end
 
-        protected
+      protected
 
-        # Notify callbacks for a file given an array of callbacks
-        #
-        # @param [Pathname] path The file that was changed
-        # @param [Symbol] callbacks_name The name of the callbacks method
-        # @return [void]
-        def run_callbacks(path, callbacks_name)
-          path = path.to_s
-          send(callbacks_name).each do |callback, matcher|
-            next unless matcher.nil? || path.match(matcher)
-            @app.instance_exec(path, &callback)
-          end
-        end
+      # Watch the source directory.
+      #
+      # @return [void]
+      Contract String => Any
+      def start_watching(dir)
+        @original_source_dir = dir
+        @watcher = @sources.watch :source, path: File.join(app.root, dir)
       end
     end
   end