middleman-core-cj 3.3.4

data/lib/middleman-core/profiling.rb

@@ -0,0 +1,56 @@
+module Middleman
+  module Profiling
+    # The profiler instance. There can only be one!
+    # rubocop:disable TrivialAccessors
+    def self.profiler=(prof)
+      @profiler = prof
+    end
+    def self.profiler
+      @profiler ||= NullProfiler.new
+    end
+
+    # Start the profiler
+    def self.start
+      profiler.start
+    end
+
+    # Stop the profiler and generate a report. Make sure to call start first
+    def self.report(report_name)
+      profiler.report(report_name)
+    end
+
+    # A profiler that does nothing. The default.
+    class NullProfiler
+      def start
+      end
+
+      def report(_)
+      end
+    end
+
+    # A profiler that uses ruby-prof
+    class RubyProfProfiler
+      def initialize
+        require 'ruby-prof'
+      rescue LoadError
+        raise "To use the --profile option, you must add the 'ruby-prof' gem to your Gemfile"
+      end
+
+      def start
+        RubyProf.start
+      end
+
+      def report(report_name)
+        result = RubyProf.stop
+
+        printer = RubyProf::GraphHtmlPrinter.new(result)
+        outfile = File.join('profile', report_name)
+        outfile = (outfile + '.html') unless outfile.end_with? '.html'
+        FileUtils.mkdir_p(File.dirname(outfile))
+        File.open(outfile, 'w') do |f|
+          printer.print(f, min_percent: 1)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+require 'asciidoctor'
+
+module Middleman
+  module Renderers
+    module AsciiDoc
+      class << self
+        def registered(app)
+          app.config.define_setting :asciidoc, {
+            safe: :safe,
+            backend: :html5,
+            attributes: %W(showtitle env=middleman env-middleman middleman-version=#{::Middleman::VERSION})
+          }, 'AsciiDoc engine options (Hash)'
+          app.config.define_setting :asciidoc_attributes, [], 'AsciiDoc custom attributes (Array)'
+          app.before_configuration do
+            template_extensions adoc: :html
+          end
+
+          app.after_configuration do
+            # QUESTION should base_dir be equal to docdir instead?
+            config[:asciidoc][:base_dir] = source_dir
+            config[:asciidoc][:attributes].concat(config[:asciidoc_attributes] || [])
+            config[:asciidoc][:attributes] << %(imagesdir=#{File.join((config[:http_prefix] || '/').chomp('/'), config[:images_dir])})
+            sitemap.provides_metadata(/\.adoc$/) do |path|
+              # read the AsciiDoc header only to set page options and data
+              # header values can be accessed via app.data.page.<name> in the layout
+              doc = Asciidoctor.load_file path, safe: :safe, parse_header_only: true
+
+              opts = {}
+              if doc.attr? 'page-layout'
+                case (layout = (doc.attr 'page-layout'))
+                when '', 'false'
+                  opts[:layout] = false
+                else
+                  opts[:layout] = layout
+                end
+              end
+              opts[:layout_engine] = (doc.attr 'page-layout-engine') if doc.attr? 'page-layout-engine'
+              # TODO: override attributes to set docfile, docdir, docname, etc
+              # alternative is to set :renderer_options, which get merged into options by the rendering extension
+              # opts[:attributes] = config[:asciidoc][:attributes].dup
+              # opts[:attributes].concat %W(docfile=#{path} docdir=#{File.dirname path} docname=#{(File.basename path).sub(/\.adoc$/, '')})
+
+              page = {}
+              page[:title] = doc.doctitle
+              page[:date] = (doc.attr 'date') unless (doc.attr 'date').nil?
+              # TODO: grab all the author information
+              page[:author] = (doc.attr 'author') unless (doc.attr 'author').nil?
+
+              { options: opts, page: ::Middleman::Util.recursively_enhance(page) }
+            end
+          end
+        end
+
+        alias_method :included, :registered
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# Require gem
+require 'coffee_script'
+
+module Middleman
+  module Renderers
+    # CoffeeScript Renderer
+    module CoffeeScript
+      # Setup extension
+      class << self
+        # Once registered
+        def registered(app)
+          # Tell Tilt to use it as well (for inline scss blocks)
+          ::Tilt.register 'coffee', DebuggingCoffeeScriptTemplate
+          ::Tilt.prefer(DebuggingCoffeeScriptTemplate)
+
+          app.before_configuration do
+            template_extensions coffee: :js
+            DebuggingCoffeeScriptTemplate.middleman_app = self
+          end
+        end
+        alias_method :included, :registered
+      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 if middleman_app.build?
+
+          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,33 @@
+# ERb renderer
+module Middleman
+  module Renderers
+    module ERb
+      # Setup extension
+      class << self
+        # once registered
+        def registered(app)
+          app.before_configuration do
+            template_extensions erb: :html
+          end
+
+          # After config
+          app.after_configuration do
+            ::Tilt.prefer(Template, :erb)
+          end
+        end
+        alias_method :included, :registered
+      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,38 @@
+# Require gem
+require 'haml'
+
+module SafeTemplate
+  def render(*)
+    super.html_safe
+  end
+end
+
+class Tilt::HamlTemplate
+  include SafeTemplate
+end
+
+module Middleman
+  module Renderers
+    # Haml Renderer
+    module Haml
+      # Setup extension
+      class << self
+        # Once registered
+        def registered(app)
+          app.before_configuration do
+            template_extensions haml: :html
+          end
+
+          # Add haml helpers to context
+          app.send :include, ::Haml::Helpers
+
+          # Setup haml helper paths
+          app.ready do
+            init_haml_helpers
+          end
+        end
+        alias_method :included, :registered
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require 'kramdown'
+
+module Middleman
+  module Renderers
+    # Our own Kramdown Tilt template that simply uses our custom renderer.
+    class KramdownTemplate < ::Tilt::KramdownTemplate
+      def evaluate(*)
+        @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 :middleman_app
+
+      def convert_img(el, _)
+        attrs = el.attr.dup
+
+        link = attrs.delete('src')
+        middleman_app.image_tag(link, attrs)
+      end
+
+      def convert_a(el, indent)
+        content = inner(el, indent)
+
+        if el.attr['href'] =~ /\Amailto:/
+          mail_addr = el.attr['href'].sub(/\Amailto:/, '')
+          href = obfuscate('mailto') << ':' << obfuscate(mail_addr)
+          content = obfuscate(content) if content == mail_addr
+          return %Q(<a href="#{href}">#{content}</a>)
+        end
+
+        attr = el.attr.dup
+        link = attr.delete('href')
+        middleman_app.link_to(content, link, attr)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require 'less'
+
+module Middleman
+  module Renderers
+    # Sass renderer
+    module Less
+      # Setup extension
+      class << self
+        # Once registered
+        def registered(app)
+          # Default less options
+          app.config.define_setting :less, {}, 'LESS compiler options'
+
+          app.before_configuration do
+            template_extensions less: :css
+          end
+
+          app.after_configuration do
+            ::Less.paths << File.join(source_dir, config[:css_dir])
+          end
+
+          # Tell Tilt to use it as well (for inline sass blocks)
+          ::Tilt.register 'less', LocalLoadingLessTemplate
+          ::Tilt.prefer(LocalLoadingLessTemplate)
+        end
+
+        alias_method :included, :registered
+      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(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,31 @@
+# Require Gem
+require 'liquid'
+
+module Middleman
+  module Renderers
+    # Liquid Renderer
+    module Liquid
+      # Setup extension
+      class << self
+        # Once registerd
+        def registered(app)
+          app.before_configuration do
+            template_extensions liquid: :html
+          end
+
+          # After config, setup liquid partial paths
+          app.after_configuration do
+            ::Liquid::Template.file_system = ::Liquid::LocalFileSystem.new(source_dir)
+
+            # Convert data object into a hash for liquid
+            sitemap.provides_metadata %r{\.liquid$} do
+              { locals: { data: data.to_h } }
+            end
+          end
+        end
+
+        alias_method :included, :registered
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+module Middleman
+  module Renderers
+    # Markdown renderer
+    module Markdown
+      # Setup extension
+      class << self
+        # Once registered
+        def registered(app)
+          # Set our preference for a markdown engine
+          app.config.define_setting :markdown_engine, :kramdown, 'Preferred markdown engine'
+          app.config.define_setting :markdown_engine_prefix, ::Tilt, 'The parent module for markdown template engines'
+
+          app.before_configuration do
+            template_extensions markdown: :html,
+                                mdown: :html,
+                                md: :html,
+                                mkd: :html,
+                                mkdn: :html
+          end
+
+          # Once configuration is parsed
+          app.after_configuration do
+            markdown_exts = %w(markdown mdown md mkd mkdn)
+
+            begin
+              # Look for the user's preferred engine
+              if config[:markdown_engine] == :redcarpet
+                require 'middleman-core/renderers/redcarpet'
+                ::Tilt.prefer(::Middleman::Renderers::RedcarpetTemplate, *markdown_exts)
+                MiddlemanRedcarpetHTML.middleman_app = self
+              elsif config[:markdown_engine] == :kramdown
+                require 'middleman-core/renderers/kramdown'
+                ::Tilt.prefer(::Middleman::Renderers::KramdownTemplate, *markdown_exts)
+                MiddlemanKramdownHTML.middleman_app = self
+              elsif config[:markdown_engine]
+                # Map symbols to classes
+                markdown_engine_klass = if config[:markdown_engine].is_a? Symbol
+                  engine = config[:markdown_engine].to_s
+                  engine = engine == 'rdiscount' ? 'RDiscount' : engine.camelize
+                  config[:markdown_engine_prefix].const_get("#{engine}Template")
+                else
+                  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 config.setting(:markdown_engine).value_set?
+                logger.warn "Requested Markdown engine (#{config[:markdown_engine]}) not found. Maybe the gem needs to be installed and required?"
+              end
+            end
+          end
+        end
+
+        alias_method :included, :registered
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+require 'redcarpet'
+
+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
+      }
+
+      # 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
+
+      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 :middleman_app
+
+      def initialize(options={})
+        @local_options = options.dup
+
+        super
+      end
+
+      def image(link, title, alt_text)
+        if !@local_options[:no_images]
+          middleman_app.image_tag(link, title: title, alt: alt_text)
+        else
+          link_string = link.dup
+          link_string << %Q("#{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]
+
+          middleman_app.link_to(content, link, attributes)
+        else
+          link_string = link.dup
+          link_string << %Q("#{title}") if title && title.length > 0 && title != alt_text
+          "[#{content}](#{link_string})"
+        end
+      end
+    end
+
+    ::Tilt.register RedcarpetTemplate, 'markdown', 'mkd', 'md'
+  end
+end