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

data/lib/middleman-core/renderers/coffee_script.rb

@@ -0,0 +1,42 @@
+# Require gem
+require 'coffee_script'
+
+module Middleman
+  module Renderers
+    # CoffeeScript Renderer
+    class CoffeeScript < ::Middleman::Extension
+      # Setup extension
+      def initialize(app, options={}, &block)
+        super
+
+        # Tell Tilt to use it as well (for inline scss blocks)
+        ::Tilt.register 'coffee', DebuggingCoffeeScriptTemplate
+        ::Tilt.prefer(DebuggingCoffeeScriptTemplate)
+
+        DebuggingCoffeeScriptTemplate.middleman_app = app
+      end
+
+      # A Template for Tilt which outputs debug messages
+      class DebuggingCoffeeScriptTemplate < ::Tilt::CoffeeScriptTemplate
+        # Make the current Middleman app accessible to the template
+        cattr_accessor :middleman_app
+
+        # Add exception messaging
+        # @param [Class] context
+        # @param [Hash] locals
+        # @return [String]
+        def evaluate(context, locals, &block)
+          return super unless middleman_app.server?
+
+          begin
+            super
+          rescue ::ExecJS::RuntimeError => e
+            e.to_s
+          rescue => e
+            e.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/middleman-core/renderers/erb.rb

@@ -0,0 +1,21 @@
+# ERb renderer
+module Middleman
+  module Renderers
+    class ERb < ::Middleman::Extension
+      def after_configuration
+        ::Tilt.prefer(Template, :erb)
+      end
+
+      class Template < ::Tilt::ErubisTemplate
+        ##
+        # In preamble we need a flag `__in_erb_template` and SafeBuffer for padrino apps.
+        #
+        def precompiled_preamble(locals)
+          original = super
+          "__in_erb_template = true\n" << original
+          # .rpartition("\n").first << "#{@outvar} = _buf = ActiveSupport::SafeBuffer.new\n"
+        end
+      end
+    end
+  end
+end

data/lib/middleman-core/renderers/haml.rb

@@ -0,0 +1,76 @@
+# Require gem
+require 'haml'
+
+# Require padrino-helpers now so that we get a chance to replace their renderer with ours in Tilt.
+require 'padrino-helpers'
+
+module SafeTemplate
+  def render(*)
+    super.html_safe
+  end
+end
+
+class Tilt::HamlTemplate
+  include SafeTemplate
+end
+
+module Middleman
+  module Renderers
+    # Haml precompiles filters before the scope is even available,
+    # thus making it impossible to pass our Middleman instance
+    # in. So we have to resort to heavy hackery :(
+    class HamlTemplate < ::Tilt::HamlTemplate
+      def initialize(*args, &block)
+        super
+
+        @context = @options[:context] if @options.key?(:context)
+      end
+
+      def prepare
+      end
+
+      def evaluate(scope, locals, &block)
+        options = {}.merge!(@options).merge!(filename: eval_file, line: line, context: @context || scope)
+        @engine = ::Haml::Engine.new(data, options)
+        output = @engine.render(scope, locals, &block)
+
+        output
+      end
+    end
+
+    # Haml Renderer
+    class Haml < ::Middleman::Extension
+      def initialize(app, options={}, &block)
+        super
+
+        ::Haml::Options.defaults[:context] = nil
+        ::Haml::Options.send :attr_accessor, :context
+
+        # rubocop:disable NestedMethodDefinition
+        [::Haml::Filters::Sass, ::Haml::Filters::Scss, ::Haml::Filters::Markdown].each do |f|
+          f.class_exec do
+            def self.render_with_options(text, compiler_options)
+              modified_options = options.dup
+              modified_options[:context] = compiler_options[:context]
+
+              text = template_class.new(nil, 1, modified_options) { text }.render
+              super(text, compiler_options)
+            end
+          end
+        end
+        # rubocop:enable NestedMethodDefinition
+
+        ::Tilt.prefer(::Middleman::Renderers::HamlTemplate, :haml)
+
+        # Add haml helpers to context
+        ::Middleman::TemplateContext.send :include, ::Haml::Helpers
+      end
+
+      def add_exposed_to_context(context)
+        super
+
+        context.init_haml_helpers if context.respond_to?(:init_haml_helpers)
+      end
+    end
+  end
+end

data/lib/middleman-core/renderers/kramdown.rb

@@ -0,0 +1,52 @@
+require 'kramdown'
+
+module Middleman
+  module Renderers
+    # Our own Kramdown Tilt template that simply uses our custom renderer.
+    class KramdownTemplate < ::Tilt::KramdownTemplate
+      def initialize(*args, &block)
+        super
+
+        @context = @options[:context] if @options.key?(:context)
+      end
+
+      def evaluate(context, *)
+        MiddlemanKramdownHTML.scope = @context || context
+
+        @output ||= begin
+          output, warnings = MiddlemanKramdownHTML.convert(@engine.root, @engine.options)
+          @engine.warnings.concat(warnings)
+          output
+        end
+      end
+    end
+
+    # Custom Kramdown renderer that uses our helpers for images and links
+    class MiddlemanKramdownHTML < ::Kramdown::Converter::Html
+      cattr_accessor :scope
+
+      def convert_img(el, _)
+        attrs = el.attr.dup
+
+        link = attrs.delete('src')
+        scope.image_tag(link, attrs)
+      end
+
+      def convert_a(el, indent)
+        content = inner(el, indent)
+
+        if el.attr['href'].start_with?('mailto:')
+          mail_addr = el.attr['href'].sub(/\Amailto:/, '')
+          href = obfuscate('mailto') << ':' << obfuscate(mail_addr)
+          content = obfuscate(content) if content == mail_addr
+          return %(<a href="#{href}">#{content}</a>)
+        end
+
+        attr = el.attr.dup
+        link = attr.delete('href')
+
+        scope.link_to(content, link, attr)
+      end
+    end
+  end
+end

data/lib/middleman-core/renderers/less.rb

@@ -0,0 +1,36 @@
+require 'less'
+
+module Middleman
+  module Renderers
+    # Sass renderer
+    class Less < ::Middleman::Extension
+      define_setting :less, {}, 'LESS compiler options'
+
+      def initialize(app, options={}, &block)
+        super
+
+        # Tell Tilt to use it as well (for inline sass blocks)
+        ::Tilt.register 'less', LocalLoadingLessTemplate
+        ::Tilt.prefer(LocalLoadingLessTemplate)
+      end
+
+      def after_configuration
+        app.files.by_type(:source).watchers.each do |source|
+          ::Less.paths << (source.directory + app.config[:css_dir]).to_s
+        end
+      end
+
+      # A SassTemplate for Tilt which outputs debug messages
+      class LocalLoadingLessTemplate < ::Tilt::LessTemplate
+        def prepare
+          if ::Less.const_defined? :Engine
+            @engine = ::Less::Engine.new(data)
+          else
+            parser = ::Less::Parser.new({}.merge!(options).merge!(filename: eval_file, line: line, paths: ['.', File.dirname(eval_file)]))
+            @engine = parser.parse(data)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/middleman-core/renderers/liquid.rb

@@ -0,0 +1,54 @@
+# Require Gem
+require 'liquid'
+
+module Middleman
+  module Renderers
+    # Liquid Renderer
+    class Liquid < Middleman::Extension
+      # After config, setup liquid partial paths
+      def after_configuration
+        ::Liquid::Template.file_system = self
+      end
+
+      # Called by Liquid to retrieve a template file
+      def read_template_file(template_path, _)
+        file = app.files.find(:source, "_#{template_path}.liquid")
+        raise ::Liquid::FileSystemError, "No such template '#{template_path}'" unless file
+        file.read
+      end
+
+      # @return Array<Middleman::Sitemap::Resource>
+      Contract ResourceList => ResourceList
+      def manipulate_resource_list(resources)
+        return resources unless app.extensions[:data]
+
+        resources.each do |resource|
+          next if resource.file_descriptor.nil?
+          next unless resource.file_descriptor[:full_path].to_s =~ %r{\.liquid$}
+
+          # Convert data object into a hash for liquid
+          resource.add_metadata locals: {
+            data: stringify_recursive(app.extensions[:data].data_store.to_h)
+          }
+        end
+      end
+
+      def stringify_recursive(hash)
+        {}.tap do |h|
+          hash.each { |key, value| h[key.to_s] = map_value(value) }
+        end
+      end
+
+      def map_value(thing)
+        case thing
+        when Hash
+          stringify_recursive(thing)
+        when Array
+          thing.map { |v| map_value(v) }
+        else
+          thing
+        end
+      end
+    end
+  end
+end

data/lib/middleman-core/renderers/markdown.rb

@@ -0,0 +1,43 @@
+module Middleman
+  module Renderers
+    # Markdown renderer
+    class Markdown < ::Middleman::Extension
+      define_setting :markdown_engine, :kramdown, 'Preferred markdown engine'
+      define_setting :markdown_engine_prefix, ::Tilt, 'The parent module for markdown template engines'
+
+      # Once configuration is parsed
+      def after_configuration
+        markdown_exts = %w(markdown mdown md mkd mkdn)
+
+        begin
+          # Look for the user's preferred engine
+          if app.config[:markdown_engine] == :redcarpet
+            require 'middleman-core/renderers/redcarpet'
+            ::Tilt.prefer(::Middleman::Renderers::RedcarpetTemplate, *markdown_exts)
+          elsif app.config[:markdown_engine] == :kramdown
+            require 'middleman-core/renderers/kramdown'
+            ::Tilt.prefer(::Middleman::Renderers::KramdownTemplate, *markdown_exts)
+          elsif app.config[:markdown_engine]
+            # Map symbols to classes
+            markdown_engine_klass = if app.config[:markdown_engine].is_a? Symbol
+              engine = app.config[:markdown_engine].to_s
+              engine = engine == 'rdiscount' ? 'RDiscount' : engine.camelize
+              app.config[:markdown_engine_prefix].const_get("#{engine}Template")
+            else
+              app.config[:markdown_engine_prefix]
+            end
+
+            # Tell tilt to use that engine
+            ::Tilt.prefer(markdown_engine_klass, *markdown_exts)
+          end
+        rescue LoadError
+          # If they just left it at the default engine and don't happen to have it,
+          # then they're using middleman-core bare and we shouldn't bother them.
+          if app.config.setting(:markdown_engine).value_set?
+            logger.warn "Requested Markdown engine (#{app.config[:markdown_engine]}) not found. Maybe the gem needs to be installed and required?"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/middleman-core/renderers/redcarpet.rb

@@ -0,0 +1,100 @@
+require 'redcarpet'
+require 'active_support/core_ext/module/attribute_accessors'
+
+module Middleman
+  module Renderers
+    class RedcarpetTemplate < ::Tilt::RedcarpetTemplate::Redcarpet2
+      # because tilt has decided to convert these
+      # in the wrong direction
+      ALIASES = {
+        escape_html: :filter_html
+      }.freeze
+
+      def initialize(*args, &block)
+        super
+
+        @context = @options[:context] if @options.key?(:context)
+      end
+
+      # Overwrite built-in Tilt version.
+      # Don't overload :renderer option with smartypants
+      # Support renderer-level options
+      def generate_renderer
+        return options.delete(:renderer) if options.key?(:renderer)
+
+        covert_options_to_aliases!
+
+        # Pick a renderer
+        renderer = MiddlemanRedcarpetHTML
+
+        if options.delete(:smartypants)
+          # Support SmartyPants
+          renderer = Class.new(renderer) do
+            include ::Redcarpet::Render::SmartyPants
+          end
+        end
+
+        # Renderer Options
+        possible_render_opts = [:filter_html, :no_images, :no_links, :no_styles, :safe_links_only, :with_toc_data, :hard_wrap, :xhtml, :prettify, :link_attributes]
+
+        render_options = possible_render_opts.each_with_object({}) do |opt, sum|
+          sum[opt] = options.delete(opt) if options.key?(opt)
+        end
+
+        renderer.new(render_options)
+      end
+
+      def evaluate(scope, _)
+        @output ||= begin
+          MiddlemanRedcarpetHTML.scope = @context || scope
+
+          @engine.render(data)
+        end
+      end
+
+      private
+
+      def covert_options_to_aliases!
+        ALIASES.each do |aka, actual|
+          options[actual] = options.delete(aka) if options.key? aka
+        end
+      end
+    end
+
+    # Custom Redcarpet renderer that uses our helpers for images and links
+    class MiddlemanRedcarpetHTML < ::Redcarpet::Render::HTML
+      cattr_accessor :scope
+
+      def initialize(options={})
+        @local_options = options.dup
+
+        super
+      end
+
+      def image(link, title, alt_text)
+        if !@local_options[:no_images]
+          scope.image_tag(link, title: title, alt: alt_text)
+        else
+          link_string = link.dup
+          link_string << %("#{title}") if title && title.length > 0 && title != alt_text
+          "![#{alt_text}](#{link_string})"
+        end
+      end
+
+      def link(link, title, content)
+        if !@local_options[:no_links]
+          attributes = { title: title }
+          attributes.merge!(@local_options[:link_attributes]) if @local_options[:link_attributes]
+
+          scope.link_to(content, link, attributes)
+        else
+          link_string = link.dup
+          link_string << %("#{title}") if title && title.length > 0 && title != alt_text
+          "[#{content}](#{link_string})"
+        end
+      end
+    end
+
+    ::Tilt.register RedcarpetTemplate, 'markdown', 'mkd', 'md'
+  end
+end

data/lib/middleman-core/renderers/sass.rb

@@ -0,0 +1,114 @@
+require 'sass'
+
+begin
+  require 'sassc'
+rescue LoadError
+end
+
+module Middleman
+  module Renderers
+    # Sass renderer
+    class Sass < ::Middleman::Extension
+      opts = { output_style: :nested }
+      opts[:line_comments] = false if ENV['TEST']
+      define_setting :sass, opts, 'Sass engine options'
+      define_setting :sass_assets_paths, [], 'Paths to extra SASS/SCSS files'
+      define_setting :sass_source_maps, nil, 'Whether to inline sourcemap into Sass'
+
+      # Setup extension
+      def initialize(app, options={}, &block)
+        super
+
+        logger.info '== Preferring use of LibSass' if defined?(::SassC)
+
+        app.files.ignore :sass_cache, :source, /(^|\/)\.sass-cache\//
+
+        # Tell Tilt to use it as well (for inline sass blocks)
+        ::Tilt.register 'sass', SassPlusCSSFilenameTemplate
+        ::Tilt.prefer(SassPlusCSSFilenameTemplate)
+
+        # Tell Tilt to use it as well (for inline scss blocks)
+        ::Tilt.register 'scss', ScssPlusCSSFilenameTemplate
+        ::Tilt.prefer(ScssPlusCSSFilenameTemplate)
+
+        require 'middleman-core/renderers/sass_functions'
+      end
+
+      # A SassTemplate for Tilt which outputs debug messages
+      class SassPlusCSSFilenameTemplate < ::Tilt::SassTemplate
+        def initialize(*args, &block)
+          super
+
+          @context = @options[:context] if @options.key?(:context)
+        end
+
+        # Define the expected syntax for the template
+        # @return [Symbol]
+        def syntax
+          :sass
+        end
+
+        def prepare; end
+
+        # Add exception messaging
+        # @param [Class] context
+        # @return [String]
+        def evaluate(context, _)
+          @context ||= context
+
+          sass_module = if defined?(::SassC)
+            ::SassC
+          else
+            ::Sass
+          end
+
+          @engine = sass_module::Engine.new(data, sass_options)
+
+          begin
+            @engine.render
+          rescue sass_module::SyntaxError => e
+            ::Sass::SyntaxError.exception_to_css(e)
+          end
+        end
+
+        # Change Sass path, for url functions, to the build folder if we're building
+        # @return [Hash]
+        def sass_options
+          ctx = @context
+
+          more_opts = {
+            load_paths: ::Sass.load_paths | ctx.app.config[:sass_assets_paths],
+            filename: eval_file,
+            line: line,
+            syntax: syntax,
+            custom: {}.merge!(options[:custom] || {}).merge!(
+              middleman_context: ctx.app,
+              current_resource: ctx.current_resource
+            )
+          }
+
+          if ctx.app.config[:sass_source_maps] || (ctx.app.config[:sass_source_maps].nil? && ctx.app.development?)
+            more_opts[:source_map_file] = '.'
+            more_opts[:source_map_embed] = true
+            more_opts[:source_map_contents] = true
+          end
+
+          if ctx.is_a?(::Middleman::TemplateContext) && file
+            more_opts[:css_filename] = file.sub(/\.s[ac]ss$/, '')
+          end
+
+          {}.merge!(options).merge!(more_opts)
+        end
+      end
+
+      # SCSS version of the above template
+      class ScssPlusCSSFilenameTemplate < SassPlusCSSFilenameTemplate
+        # Define the expected syntax for the template
+        # @return [Symbol]
+        def syntax
+          :scss
+        end
+      end
+    end
+  end
+end