middleman-core-cj 3.3.4

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

@@ -0,0 +1,201 @@
+require 'active_support/core_ext/hash/keys'
+require 'pathname'
+
+# Parsing YAML frontmatter
+require 'yaml'
+
+# Parsing JSON frontmatter
+require 'active_support/json'
+
+# Extensions namespace
+module Middleman::CoreExtensions
+  class FrontMatter < ::Middleman::Extension
+    YAML_ERRORS = [StandardError]
+
+    # https://github.com/tenderlove/psych/issues/23
+    if defined?(Psych) && defined?(Psych::SyntaxError)
+      YAML_ERRORS << Psych::SyntaxError
+    end
+
+    def initialize(app, options_hash={}, &block)
+      super
+
+      @cache = {}
+    end
+
+    def before_configuration
+      ext = self
+      app.files.changed { |file| ext.clear_data(file) }
+      app.files.deleted { |file| ext.clear_data(file) }
+    end
+
+    def after_configuration
+      app.extensions[:frontmatter] = self
+      app.ignore %r{\.frontmatter$}
+
+      ::Middleman::Sitemap::Resource.send :include, ResourceInstanceMethods
+
+      app.sitemap.provides_metadata do |path|
+        fmdata = data(path).first
+
+        data = {}
+        [:layout, :layout_engine].each do |opt|
+          data[opt] = fmdata[opt] unless fmdata[opt].nil?
+        end
+
+        { options: data, page: ::Middleman::Util.recursively_enhance(fmdata).freeze }
+      end
+    end
+
+    module ResourceInstanceMethods
+      def ignored?
+        if !proxy? && raw_data[:ignored] == true
+          true
+        else
+          super
+        end
+      end
+
+      # This page's frontmatter without being enhanced for access by either symbols or strings.
+      # Used internally
+      # @private
+      # @return [Hash]
+      def raw_data
+        app.extensions[:frontmatter].data(source_file).first
+      end
+
+      # This page's frontmatter
+      # @return [Hash]
+      def data
+        @enhanced_data ||= ::Middleman::Util.recursively_enhance(raw_data).freeze
+      end
+
+      # Override Resource#content_type to take into account frontmatter
+      def content_type
+        # Allow setting content type in frontmatter too
+        raw_data.fetch :content_type do
+          super
+        end
+      end
+    end
+
+    helpers do
+      # Get the template data from a path
+      # @param [String] path
+      # @return [String]
+      def template_data_for_file(path)
+        extensions[:frontmatter].data(path).last
+      end
+    end
+
+    def data(path)
+      p = normalize_path(path)
+      @cache[p] ||= begin
+        data, content = frontmatter_and_content(p)
+
+        if app.files.exists?("#{path}.frontmatter")
+          external_data, _ = frontmatter_and_content("#{p}.frontmatter")
+          data = external_data.deep_merge(data)
+        end
+
+        [data, content]
+      end
+    end
+
+    def clear_data(file)
+      # Copied from Sitemap::Store#file_to_path, but without
+      # removing the file extension
+      file = File.join(app.root, file)
+      prefix = app.source_dir.sub(/\/$/, '') + '/'
+      return unless file.include?(prefix)
+      path = file.sub(prefix, '').sub(/\.frontmatter$/, '')
+
+      @cache.delete(path)
+    end
+
+    private
+
+    # Parse YAML frontmatter out of a string
+    # @param [String] content
+    # @return [Array<Hash, String>]
+    def parse_yaml_front_matter(content, full_path)
+      yaml_regex = /\A(---\s*\n.*?\n?)^(---\s*$\n?)/m
+      if content =~ yaml_regex
+        content = content.sub(yaml_regex, '')
+
+        begin
+          data = YAML.load($1) || {}
+          data = data.symbolize_keys
+        rescue *YAML_ERRORS => e
+          app.logger.error "YAML Exception parsing #{full_path}: #{e.message}"
+          return false
+        end
+      else
+        return false
+      end
+
+      [data, content]
+    rescue
+      [{}, content]
+    end
+
+    def parse_json_front_matter(content, full_path)
+      json_regex = /\A(;;;\s*\n.*?\n?)^(;;;\s*$\n?)/m
+
+      if content =~ json_regex
+        content = content.sub(json_regex, '')
+
+        begin
+          json = ($1 + $2).sub(';;;', '{').sub(';;;', '}')
+          data = ActiveSupport::JSON.decode(json).symbolize_keys
+        rescue => e
+          app.logger.error "JSON Exception parsing #{full_path}: #{e.message}"
+          return false
+        end
+
+      else
+        return false
+      end
+
+      [data, content]
+    rescue
+      [{}, content]
+    end
+
+    # Get the frontmatter and plain content from a file
+    # @param [String] path
+    # @return [Array<Thor::CoreExt::HashWithIndifferentAccess, String>]
+    def frontmatter_and_content(path)
+      full_path = if Pathname(path).relative?
+        File.join(app.source_dir, path)
+      else
+        path
+      end
+
+      data = {}
+
+      return [data, nil] if !app.files.exists?(full_path) || ::Middleman::Util.binary?(full_path)
+
+      content = File.read(full_path)
+
+      begin
+        if content =~ /\A.*coding:/
+          lines = content.split(/\n/)
+          lines.shift
+          content = lines.join("\n")
+        end
+
+        result = parse_yaml_front_matter(content, full_path) || parse_json_front_matter(content, full_path)
+        return result if result
+      rescue
+        # Probably a binary file, move on
+      end
+
+      [data, content]
+    end
+
+    def normalize_path(path)
+      path.sub(%r{^#{Regexp.escape(app.source_dir)}\/}, '')
+    end
+  end
+end

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

@@ -0,0 +1,512 @@
+# Shutup Tilt Warnings
+# @private
+class Tilt::Template
+  def warn(*)
+  end
+end
+
+# Rendering extension
+# rubocop:disable UnderscorePrefixedVariableName
+module Middleman
+  module CoreExtensions
+    module Rendering
+      # Setup extension
+      class << self
+        # Once registered
+        def registered(app)
+          # Include methods
+          app.send :include, InstanceMethods
+
+          app.define_hook :before_render
+          app.define_hook :after_render
+
+          ::Tilt.mappings.delete('html') # WTF, Tilt?
+          ::Tilt.mappings.delete('csv')
+
+          require 'active_support/core_ext/string/output_safety'
+
+          # Activate custom renderers
+          require 'middleman-core/renderers/erb'
+          app.register Middleman::Renderers::ERb
+
+          # CoffeeScript Support
+          begin
+            require 'middleman-core/renderers/coffee_script'
+            app.register Middleman::Renderers::CoffeeScript
+          rescue LoadError
+          end
+
+          # Haml Support
+          begin
+            require 'middleman-core/renderers/haml'
+            app.register Middleman::Renderers::Haml
+          rescue LoadError
+          end
+
+          # Sass Support
+          begin
+            require 'middleman-core/renderers/sass'
+            app.register Middleman::Renderers::Sass
+          rescue LoadError
+          end
+
+          # Markdown Support
+          require 'middleman-core/renderers/markdown'
+          app.register Middleman::Renderers::Markdown
+
+          # AsciiDoc Support
+          begin
+            require 'middleman-core/renderers/asciidoc'
+            app.register Middleman::Renderers::AsciiDoc
+          rescue LoadError
+          end
+
+          # Liquid Support
+          begin
+            require 'middleman-core/renderers/liquid'
+            app.register Middleman::Renderers::Liquid
+          rescue LoadError
+          end
+
+          # Slim Support
+          begin
+            require 'middleman-core/renderers/slim'
+            app.register Middleman::Renderers::Slim
+          rescue LoadError
+          end
+
+          # Less Support
+          begin
+            require 'middleman-core/renderers/less'
+            app.register Middleman::Renderers::Less
+          rescue LoadError
+          end
+
+          # Stylus Support
+          begin
+            require 'middleman-core/renderers/stylus'
+            app.register Middleman::Renderers::Stylus
+          rescue LoadError
+          end
+
+          # Clean up missing Tilt exts
+          app.after_configuration do
+            Tilt.mappings.each do |key, _|
+              begin
+                Tilt[".#{key}"]
+              rescue LoadError, NameError
+                Tilt.mappings.delete(key)
+              end
+            end
+          end
+        end
+
+        alias_method :included, :registered
+      end
+
+      # Custom error class for handling
+      class TemplateNotFound < RuntimeError
+      end
+
+      # Rendering instance methods
+      module InstanceMethods
+        # Add or overwrite a default template extension
+        #
+        # @param [Hash] extension_map
+        # @return [Hash]
+        def template_extensions(extension_map=nil)
+          @_template_extensions ||= {}
+          @_template_extensions.merge!(extension_map) if extension_map
+          @_template_extensions
+        end
+
+        # Render a template, with layout, given a path
+        #
+        # @param [String] path
+        # @param [Hash] locs
+        # @param [Hash] opts
+        # @return [String]
+        def render_template(path, locs={}, opts={}, blocks=[])
+          extension = File.extname(path)
+          engine = extension[1..-1].to_sym
+
+          if defined?(::I18n)
+            old_locale = ::I18n.locale
+            ::I18n.locale = opts[:lang] if opts[:lang]
+          end
+
+          # Use a dup of self as a context so that instance variables set within
+          # the template don't persist for other templates.
+          context = dup
+          blocks.each do |block|
+            context.instance_eval(&block)
+          end
+
+          # Store current locs/opts for later
+          @current_locs = locs
+          @current_opts = opts
+
+          # Keep rendering template until we've used up all extensions. This
+          # handles cases like `style.css.sass.erb`
+          content = nil
+          while ::Tilt[path]
+            begin
+              opts[:template_body] = content if content
+              content = render_individual_file(path, locs, opts, context)
+              path = File.basename(path, File.extname(path))
+            rescue LocalJumpError
+              raise "Tried to render a layout (calls yield) at #{path} like it was a template. Non-default layouts need to be in #{source}/#{config[:layouts_dir]}."
+            end
+          end
+
+          # If we need a layout and have a layout, use it
+          if layout_path = fetch_layout(engine, opts)
+            content = render_individual_file(layout_path, locs, opts, context) { content }
+          end
+
+          # Return result
+          content
+        ensure
+          # Pop all the saved variables from earlier as we may be returning to a
+          # previous render (layouts, partials, nested layouts).
+          ::I18n.locale = old_locale if defined?(::I18n)
+          @content_blocks = nil
+          @current_locs = nil
+          @current_opts = nil
+        end
+
+        # Sinatra/Padrino compatible render method signature referenced by some view
+        # helpers. Especially partials.
+        #
+        # @param [String, Symbol] engine
+        # @param [String, Symbol] data
+        # @param [Hash] options
+        # @return [String]
+        def render(_, data, options={}, &block)
+          partial_name = data.to_s
+          found_partial = locate_partial(partial_name, false) || locate_partial(partial_name, true)
+
+          # Look in the partials_dir for the partial with the current engine
+          unless found_partial
+            partials_path = File.join(config[:partials_dir], partial_name)
+            found_partial = locate_partial(partials_path, false) || locate_partial(partials_path, true)
+          end
+
+          raise ::Middleman::CoreExtensions::Rendering::TemplateNotFound, "Could not locate partial: #{data}" unless found_partial
+
+          locals = options[:locals]
+
+          if ::Tilt[found_partial]
+            # Render the partial if found, otherwide throw exception
+            render_individual_file(found_partial, locals, options, self, &block)
+          else
+            File.read(found_partial)
+          end
+        end
+
+        # Partial locator.
+        #
+        # @param [String] partial_name
+        # @return [String]
+        def locate_partial(partial_name, try_static=true)
+          resolve_opts = { try_without_underscore: true, try_static: try_static }
+
+          # If the path is known to the sitemap
+          if resource = sitemap.find_resource_by_path(current_path)
+            current_dir = File.dirname(resource.source_file)
+            resolve_opts[:preferred_engine] = File.extname(resource.source_file)[1..-1].to_sym
+
+            # Look for partials relative to the current path
+            relative_dir = File.join(current_dir.sub(%r{^#{Regexp.escape(source_dir)}/?}, ''), partial_name)
+
+            resolve_template(relative_dir, resolve_opts) || resolve_template(partial_name, resolve_opts)
+          else
+            resolve_template(partial_name, resolve_opts)
+          end
+        end
+
+        # Render an on-disk file. Used for everything, including layouts.
+        #
+        # @param [String, Symbol] path
+        # @param [Hash] locs
+        # @param [Hash] opts
+        # @param [Class] context
+        # @return [String]
+        def render_individual_file(path, locs={}, opts={}, context=self, &block)
+          path = path.to_s
+
+          # Mutability is FUN!
+          # Try to work around: https://github.com/middleman/middleman/issues/501
+          locs = locs.dup
+
+          # Detect the remdering engine from the extension
+          extension = File.extname(path)
+          engine = extension[1..-1].to_sym
+
+          # Store last engine for later (could be inside nested renders)
+          context.current_engine, engine_was = engine, context.current_engine
+
+          # Save current buffer for later
+          @_out_buf, _buf_was = '', @_out_buf
+
+          # Read from disk or cache the contents of the file
+          body = if opts[:template_body]
+            opts.delete(:template_body)
+          else
+            template_data_for_file(path)
+          end
+
+          # Merge per-extension options from config
+          extension = File.extname(path)
+          options = opts.dup.merge(options_for_ext(extension))
+          options[:outvar] ||= '@_out_buf'
+          options.delete(:layout)
+
+          # Overwrite with frontmatter options
+          options = options.deep_merge(options[:renderer_options]) if options[:renderer_options]
+
+          template_class = ::Tilt[path]
+          # Allow hooks to manipulate the template before render
+          self.class.callbacks_for_hook(:before_render).each do |callback|
+            # Uber::Options::Value doesn't respond to call
+            newbody = if callback.respond_to?(:call)
+              callback.call(body, path, locs, template_class)
+            elsif callback.respond_to?(:evaluate)
+              callback.evaluate(self, body, path, locs, template_class)
+            end
+            body = newbody if newbody # Allow the callback to return nil to skip it
+          end
+
+          # Read compiled template from disk or cache
+          template = cache.fetch(:compiled_template, extension, options, body) do
+            ::Tilt.new(path, 1, options) { body }
+          end
+
+          # Render using Tilt
+          content = template.render(context, locs, &block)
+
+          # Allow hooks to manipulate the result after render
+          self.class.callbacks_for_hook(:after_render).each do |callback|
+            # Uber::Options::Value doesn't respond to call
+            newcontent = if callback.respond_to?(:call)
+              content = callback.call(content, path, locs, template_class)
+            elsif callback.respond_to?(:evaluate)
+              content = callback.evaluate(self, content, path, locs, template_class)
+            end
+            content = newcontent if newcontent # Allow the callback to return nil to skip it
+          end
+
+          output = ::ActiveSupport::SafeBuffer.new ''
+          output.safe_concat content
+          output
+        ensure
+          # Reset stored buffer
+          @_out_buf = _buf_was
+          context.current_engine = engine_was
+        end
+
+        # Get the template data from a path
+        # @param [String] path
+        # @return [String]
+        def template_data_for_file(path)
+          File.read(File.expand_path(path, source_dir))
+        end
+
+        # Get a hash of configuration options for a given file extension, from
+        # config.rb
+        #
+        # @param [String] ext
+        # @return [Hash]
+        def options_for_ext(ext)
+          # Read options for extension from config/Tilt or cache
+          cache.fetch(:options_for_ext, ext) do
+            options = {}
+
+            # Find all the engines which handle this extension in tilt. Look for
+            # config variables of that name and merge it
+            extension_class = ::Tilt[ext]
+            ::Tilt.mappings.each do |mapping_ext, engines|
+              next unless engines.include? extension_class
+              engine_options = config[mapping_ext.to_sym] || {}
+              options.merge!(engine_options)
+            end
+
+            options
+          end
+        end
+
+        # Find a layout for a given engine
+        #
+        # @param [Symbol] engine
+        # @param [Hash] opts
+        # @return [String]
+        def fetch_layout(engine, opts)
+          # The layout name comes from either the system default or the options
+          local_layout = opts.key?(:layout) ? opts[:layout] : config[:layout]
+          return false unless local_layout
+
+          # Look for engine-specific options
+          engine_options = respond_to?(engine) ? send(engine) : {}
+
+          # The engine for the layout can be set in options, engine_options or passed
+          # into this method
+          layout_engine = if opts.key?(:layout_engine)
+            opts[:layout_engine]
+          elsif engine_options.key?(:layout_engine)
+            engine_options[:layout_engine]
+          else
+            engine
+          end
+
+          # Automatic mode
+          if local_layout == :_auto_layout
+            # Look for :layout of any extension
+            # If found, use it. If not, continue
+            locate_layout(:layout, layout_engine) || false
+          else
+            # Look for specific layout
+            # If found, use it. If not, error.
+            if layout_path = locate_layout(local_layout, layout_engine)
+              layout_path
+            else
+              raise ::Middleman::CoreExtensions::Rendering::TemplateNotFound, "Could not locate layout: #{local_layout}"
+            end
+          end
+        end
+
+        # Find a layout on-disk, optionally using a specific engine
+        # @param [String] name
+        # @param [Symbol] preferred_engine
+        # @return [String]
+        def locate_layout(name, preferred_engine=nil)
+          resolve_opts = {}
+          resolve_opts[:preferred_engine] = preferred_engine unless preferred_engine.nil?
+
+          # Check layouts folder
+          layout_path = resolve_template(File.join(config[:layouts_dir], name.to_s), resolve_opts)
+
+          # If we didn't find it, check root
+          layout_path = resolve_template(name, resolve_opts) unless layout_path
+
+          # Return the path
+          layout_path
+        end
+
+        # Allow layouts to be wrapped in the contents of other layouts
+        # @param [String, Symbol] layout_name
+        # @return [void]
+        def wrap_layout(layout_name, &block)
+          # Save current buffer for later
+          @_out_buf, _buf_was = '', @_out_buf
+
+          layout_path = locate_layout(layout_name, current_engine)
+
+          extension = File.extname(layout_path)
+          engine = extension[1..-1].to_sym
+
+          # Store last engine for later (could be inside nested renders)
+          self.current_engine, engine_was = engine, current_engine
+
+          begin
+            content = if block_given?
+              capture_html(&block)
+            else
+              ''
+            end
+          ensure
+            # Reset stored buffer
+            @_out_buf = _buf_was
+          end
+
+          concat_safe_content render_individual_file(layout_path, @current_locs || {}, @current_opts || {}, self) { content }
+        ensure
+          self.current_engine = engine_was
+        end
+
+        # The currently rendering engine
+        # @return [Symbol, nil]
+        def current_engine
+          @_current_engine ||= nil
+        end
+
+        # The currently rendering engine
+        # rubocop:disable TrivialAccessors
+        # @return [Symbol, nil]
+        def current_engine=(v)
+          @_current_engine = v
+        end
+
+        # Find a template on disk given a output path
+        # @param [String] request_path
+        # @option options [Boolean] :preferred_engine If set, try this engine first, then fall back to any engine.
+        # @option options [Boolean] :try_without_underscore
+        # @option options [Boolean] :try_static
+        # @return [Array<String, Symbol>, Boolean]
+        def resolve_template(request_path, options={})
+          # Find the path by searching or using the cache
+          request_path = request_path.to_s
+          cache.fetch(:resolve_template, request_path, options) do
+            relative_path = Util.strip_leading_slash(request_path)
+            on_disk_path  = File.expand_path(relative_path, source_dir)
+
+            preferred_engines = if options[:try_static]
+              [nil]
+            else
+              possible_engines = ['*'] # By default, any engine will do
+
+              # If we're specifically looking for a preferred engine
+              if options.key?(:preferred_engine)
+                extension_class = ::Tilt[options[:preferred_engine]]
+
+                # Get a list of extensions for a preferred engine
+                matched_exts = ::Tilt.mappings.select do |_, engines|
+                  engines.include? extension_class
+                end.keys
+
+                # Prefer to look for the matched extensions
+                unless matched_exts.empty?
+                  possible_engines.unshift('{' + matched_exts.join(',') + '}')
+                end
+              end
+
+              possible_engines
+            end
+
+            search_paths = preferred_engines.flat_map do |preferred_engine|
+              path_with_ext = on_disk_path.dup
+              path_with_ext << ('.' + preferred_engine) unless preferred_engine.nil?
+
+              paths = [path_with_ext]
+              if options[:try_without_underscore]
+                paths << path_with_ext.sub(relative_path, relative_path.sub(/^_/, '').sub(/\/_/, '/'))
+              end
+              paths
+            end
+
+            found_path = nil
+            search_paths.each do |path_with_ext|
+              found_path = Dir[path_with_ext].find do |path|
+                ::Tilt[path]
+              end
+
+              unless found_path
+                found_path = path_with_ext if File.exist?(path_with_ext)
+              end
+
+              break if found_path
+            end
+
+            # If we found one, return it
+            if found_path
+              found_path
+            elsif File.exist?(on_disk_path)
+              on_disk_path
+            else
+              false
+            end
+          end
+        end
+      end
+    end
+  end
+end