middleman-core-with-external-sources-watch-fix 4.1.0

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,27 @@
+module Middleman
+  module CoreExtensions
+    module Collections
+      class StepContext
+        def self.add_to_context(name, &func)
+          send(:define_method, :"_internal_#{name}", &func)
+        end
+
+        attr_reader :descriptors
+
+        def initialize
+          @descriptors = []
+        end
+
+        def method_missing(name, *args, &block)
+          internal = :"_internal_#{name}"
+
+          return super unless respond_to?(internal)
+
+          send(internal, *args, &block).tap do |r|
+            @descriptors << r if r.respond_to?(:execute_descriptor)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,223 @@
+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
+    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)$/
+
+      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, Hash => 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))
+        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).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)
+          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[Hash]
+        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
+
+          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
+
+        def key?(key)
+          (@local_data.keys + @local_sources.keys + @callback_sources.keys).include?(key.to_s)
+        end
+
+        alias has_key? key?
+
+        # Convert all the data into a static hash
+        #
+        # @return [Hash]
+        Contract Hash
+        def to_h
+          data = {}
+
+          store.each_key do |k|
+            data[k] = data_for_path(k)
+          end
+
+          callbacks.each_key do |k|
+            data[k] = data_for_path(k)
+          end
+
+          (@local_data || {}).each do |k, v|
+            data[k] = v
+          end
+
+          data
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,289 @@
+require 'padrino-helpers'
+
+# Don't fail on invalid locale, that's not what our current
+# users expect.
+::I18n.enforce_available_locales = false
+
+class Padrino::Helpers::OutputHelpers::ErbHandler
+  # Force Erb capture not to use safebuffer
+  def capture_from_template(*args, &block)
+    self.output_buffer = ''
+    buf_was = output_buffer
+    raw = yield(*args)
+    captured = template.instance_variable_get(:@_out_buf)
+    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'
+
+    ::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
+    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)
+      end
+
+      options    = parse_data_options(name, options)
+      attributes = tag_attributes(options)
+      output = ActiveSupport::SafeBuffer.new
+      output.safe_concat "<#{name}#{attributes}>"
+
+      if content.respond_to?(:each) && !content.is_a?(String)
+        content.each do |c|
+          output.safe_concat c
+          output.safe_concat ::Padrino::Helpers::TagHelpers::NEWLINE
+        end
+      else
+        output.safe_concat content.to_s
+      end
+      output.safe_concat "</#{name}>"
+
+      block_is_template?(block) ? concat_content(output) : output
+    end
+
+    def capture_html(*args, &block)
+      result = if handler = auto_find_proper_handler(&block)
+        handler.capture_from_template(*args, &block)
+      else
+        yield(*args)
+      end
+
+      ::ActiveSupport::SafeBuffer.new.safe_concat(result)
+    end
+
+    def auto_find_proper_handler(&block)
+      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
+    def asset_stamp
+      false
+    end
+
+    # Output a stylesheet link tag based on the current path
+    #
+    # @return [String]
+    def auto_stylesheet_link_tag
+      auto_tag(:css) do |path|
+        stylesheet_link_tag path
+      end
+    end
+
+    # Output a javascript tag based on the current path
+    #
+    # @return [String]
+    def auto_javascript_include_tag
+      auto_tag(:js) do |path|
+        javascript_include_tag path
+      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
+    # @param [String] asset_dir Where to look for assets
+    # @return [void]
+    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
+      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[0..-(File.extname(path).length + 1)] + ".#{asset_ext}"
+
+      yield path if sitemap.find_resource_by_path(path)
+    end
+
+    # Generate body css classes based on the current path
+    #
+    # @return [String]
+    def page_classes(path=current_path.dup, options={})
+      if path.is_a? Hash
+        options = path
+        path = current_path.dup
+      end
+
+      path << index_file if path.end_with?('/')
+      path = ::Middleman::Util.strip_leading_slash(path)
+
+      classes = Set.new
+      parts = path.split('.').first.split('/')
+      parts.each_with_index { |_, i| classes << parts.first(i + 1).join('_') }
+
+      prefix = options[:numeric_prefix] || 'x'
+      classes.map do |c|
+        # Replace weird class name characters
+        c = c.gsub(/[^a-zA-Z0-9\-_]/, '-')
+
+        # Class names can't start with a digit
+        c = "#{prefix}#{c}" if c =~ /\A\d/
+        c
+      end.join(' ')
+    end
+
+    # Get the path of a file of a given type
+    #
+    # @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, 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='', 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 = {}.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
+    # reference a source path, either absolutely or relatively,
+    # you'll get that resource's nice URL. Also, there is a
+    # :relative option which, if set to true, will produce
+    # relative URLs instead of absolute URLs. You can also add
+    #
+    # config[:relative_links] = true
+    #
+    # to config.rb to have all links default to relative.
+    #
+    # There is also a :query option that can be used to append a
+    # query string, which can be expressed as either a String,
+    # or a Hash which will be turned into URL parameters.
+    def link_to(*args, &block)
+      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
+
+      if url = args[url_arg_index]
+        options = args[options_index] || {}
+        raise ArgumentError, 'Options must be a hash' unless options.is_a?(Hash)
+
+        # Transform the url through our magic url_for method
+        args[url_arg_index] = url_for(url, options)
+
+        # Cleanup before passing to Padrino
+        options.except!(:relative, :current_resource, :find_resource, :query, :anchor, :fragment)
+      end
+
+      super(*args, &block)
+    end
+
+    # 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)
+      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
+
+    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