bunto 1.0.0

data/lib/bunto/converters/markdown.rb

@@ -0,0 +1,92 @@
+module Bunto
+  module Converters
+    class Markdown < Converter
+      highlighter_prefix "\n"
+      highlighter_suffix "\n"
+      safe true
+
+      def setup
+        return if @setup
+        unless (@parser = get_processor)
+          Bunto.logger.error "Invalid Markdown processor given:", @config["markdown"]
+          Bunto.logger.info  "", "Custom processors are not loaded in safe mode" if @config["safe"]
+          Bunto.logger.error "", "Available processors are: #{valid_processors.join(", ")}"
+          raise Errors::FatalException, "Bailing out; invalid Markdown processor."
+        end
+
+        @setup = true
+      end
+
+      def get_processor
+        case @config["markdown"].downcase
+        when "redcarpet" then return RedcarpetParser.new(@config)
+        when "kramdown"  then return KramdownParser.new(@config)
+        when "rdiscount" then return RDiscountParser.new(@config)
+        else
+          get_custom_processor
+        end
+      end
+
+      # Public: Provides you with a list of processors, the ones we
+      # support internally and the ones that you have provided to us (if you
+      # are not in safe mode.)
+
+      def valid_processors
+        %W(rdiscount kramdown redcarpet) + third_party_processors
+      end
+
+      # Public: A list of processors that you provide via plugins.
+      # This is really only available if you are not in safe mode, if you are
+      # in safe mode (re: GitHub) then there will be none.
+
+      def third_party_processors
+        self.class.constants - \
+        %w(KramdownParser RDiscountParser RedcarpetParser PRIORITIES).map(
+          &:to_sym
+        )
+      end
+
+      def extname_list
+        @extname_list ||= @config['markdown_ext'].split(',').map do |e|
+          ".#{e.downcase}"
+        end
+      end
+
+      def matches(ext)
+        extname_list.include?(ext.downcase)
+      end
+
+      def output_ext(_ext)
+        ".html"
+      end
+
+      def convert(content)
+        setup
+        @parser.convert(content)
+      end
+
+      private
+      def get_custom_processor
+        converter_name = @config["markdown"]
+        if custom_class_allowed?(converter_name)
+          self.class.const_get(converter_name).new(@config)
+        end
+      end
+
+      # Private: Determine whether a class name is an allowed custom
+      #   markdown class name.
+      #
+      # parser_name - the name of the parser class
+      #
+      # Returns true if the parser name contains only alphanumeric
+      # characters and is defined within Bunto::Converters::Markdown
+
+      private
+      def custom_class_allowed?(parser_name)
+        parser_name !~ /[^A-Za-z0-9_]/ && self.class.constants.include?(
+          parser_name.to_sym
+        )
+      end
+    end
+  end
+end

data/lib/bunto/converters/markdown/kramdown_parser.rb

@@ -0,0 +1,117 @@
+# Frozen-string-literal: true
+# Encoding: utf-8
+
+module Bunto
+  module Converters
+    class Markdown
+      class KramdownParser
+        CODERAY_DEFAULTS = {
+          "css"               => "style",
+          "bold_every"        => 10,
+          "line_numbers"      => "inline",
+          "line_number_start" => 1,
+          "tab_width"         => 4,
+          "wrap"              => "div"
+        }.freeze
+
+        def initialize(config)
+          Bunto::External.require_with_graceful_fail "kramdown"
+          @main_fallback_highlighter = config["highlighter"] || "rouge"
+          @config = config["kramdown"] || {}
+          setup
+        end
+
+        # Setup and normalize the configuration:
+        #   * Create Kramdown if it doesn't exist.
+        #   * Set syntax_highlighter, detecting enable_coderay and merging highlighter if none.
+        #   * Merge kramdown[coderay] into syntax_highlighter_opts stripping coderay_.
+        #   * Make sure `syntax_highlighter_opts` exists.
+
+        def setup
+          @config["syntax_highlighter"] ||= highlighter
+          @config["syntax_highlighter_opts"] ||= {}
+          @config["coderay"] ||= {} # XXX: Legacy.
+          modernize_coderay_config
+          make_accessible
+        end
+
+        def convert(content)
+          Kramdown::Document.new(content, @config).to_html
+        end
+
+        private
+        def make_accessible(hash = @config)
+          proc_ = proc { |hash_, key| hash_[key.to_s] if key.is_a?(Symbol) }
+          hash.default_proc = proc_
+
+          hash.each do |_, val|
+            make_accessible val if val.is_a?(
+              Hash
+            )
+          end
+        end
+
+        # config[kramdown][syntax_higlighter] > config[kramdown][enable_coderay] > config[highlighter]
+        # Where `enable_coderay` is now deprecated because Kramdown
+        # supports Rouge now too.
+
+        private
+        def highlighter
+          return @highlighter if @highlighter
+
+          if @config["syntax_highlighter"]
+            return @highlighter = @config[
+              "syntax_highlighter"
+            ]
+          end
+
+          @highlighter = begin
+            if @config.key?("enable_coderay") && @config["enable_coderay"]
+              Bunto::Deprecator.deprecation_message "You are using 'enable_coderay', " \
+                "use syntax_highlighter: coderay in your configuration file."
+
+              "coderay"
+            else
+              @main_fallback_highlighter
+            end
+          end
+        end
+
+        private
+        def strip_coderay_prefix(hash)
+          hash.each_with_object({}) do |(key, val), hsh|
+            cleaned_key = key.gsub(/\Acoderay_/, "")
+
+            if key != cleaned_key
+              Bunto::Deprecator.deprecation_message(
+                "You are using '#{key}'. Normalizing to #{cleaned_key}."
+              )
+            end
+
+            hsh[cleaned_key] = val
+          end
+        end
+
+        # If our highlighter is CodeRay we go in to merge the CodeRay defaults
+        # with your "coderay" key if it's there, deprecating it in the
+        # process of you using it.
+
+        private
+        def modernize_coderay_config
+          if highlighter == "coderay"
+            Bunto::Deprecator.deprecation_message "You are using 'kramdown.coderay' in your configuration, " \
+              "please use 'syntax_highlighter_opts' instead."
+
+            @config["syntax_highlighter_opts"] = begin
+              strip_coderay_prefix(
+                @config["syntax_highlighter_opts"] \
+                  .merge(CODERAY_DEFAULTS) \
+                  .merge(@config["coderay"])
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bunto/converters/markdown/rdiscount_parser.rb

@@ -0,0 +1,33 @@
+module Bunto
+  module Converters
+    class Markdown
+      class RDiscountParser
+        def initialize(config)
+          Bunto::External.require_with_graceful_fail "rdiscount"
+          @config = config
+          @rdiscount_extensions = @config['rdiscount']['extensions'].map(&:to_sym)
+        end
+
+        def convert(content)
+          rd = RDiscount.new(content, *@rdiscount_extensions)
+          html = rd.to_html
+          if @config['rdiscount']['toc_token']
+            html = replace_generated_toc(rd, html, @config['rdiscount']['toc_token'])
+          end
+          html
+        end
+
+        private
+        def replace_generated_toc(rd, html, toc_token)
+          if rd.generate_toc && html.include?(toc_token)
+            utf8_toc = rd.toc_content
+            utf8_toc.force_encoding('utf-8') if utf8_toc.respond_to?(:force_encoding)
+            html.gsub(toc_token, utf8_toc)
+          else
+            html
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bunto/converters/markdown/redcarpet_parser.rb

@@ -0,0 +1,102 @@
+module Bunto
+  module Converters
+    class Markdown
+      class RedcarpetParser
+        module CommonMethods
+          def add_code_tags(code, lang)
+            code = code.to_s
+            code = code.sub(/<pre>/, "<pre><code class=\"language-#{lang}\" data-lang=\"#{lang}\">")
+            code = code.sub(/<\/pre>/, "</code></pre>")
+            code
+          end
+        end
+
+        module WithPygments
+          include CommonMethods
+          def block_code(code, lang)
+            Bunto::External.require_with_graceful_fail("pygments")
+            lang = lang && lang.split.first || "text"
+            add_code_tags(
+              Pygments.highlight(code, :lexer => lang, :options => { :encoding => 'utf-8' }),
+              lang
+            )
+          end
+        end
+
+        module WithoutHighlighting
+          require 'cgi'
+
+          include CommonMethods
+
+          def code_wrap(code)
+            "<figure class=\"highlight\"><pre>#{CGI::escapeHTML(code)}</pre></figure>"
+          end
+
+          def block_code(code, lang)
+            lang = lang && lang.split.first || "text"
+            add_code_tags(code_wrap(code), lang)
+          end
+        end
+
+        module WithRouge
+          def block_code(code, lang)
+            code = "<pre>#{super}</pre>"
+
+            output = "<div class=\"highlight\">"
+            output << add_code_tags(code, lang)
+            output << "</div>"
+          end
+
+          protected
+          def rouge_formatter(_lexer)
+            Rouge::Formatters::HTML.new(:wrap => false)
+          end
+        end
+
+        def initialize(config)
+          External.require_with_graceful_fail("redcarpet")
+          @config = config
+          @redcarpet_extensions = {}
+          @config['redcarpet']['extensions'].each { |e| @redcarpet_extensions[e.to_sym] = true }
+
+          @renderer ||= class_with_proper_highlighter(@config['highlighter'])
+        end
+
+        def class_with_proper_highlighter(highlighter)
+          case highlighter
+          when "pygments"
+            Class.new(Redcarpet::Render::HTML) do
+              include WithPygments
+            end
+          when "rouge"
+            Class.new(Redcarpet::Render::HTML) do
+              Bunto::External.require_with_graceful_fail(%w(
+                rouge
+                rouge/plugins/redcarpet
+              ))
+
+              unless Gem::Version.new(Rouge.version) > Gem::Version.new("1.3.0")
+                abort "Please install Rouge 1.3.0 or greater and try running Bunto again."
+              end
+
+              include Rouge::Plugins::Redcarpet
+              include CommonMethods
+              include WithRouge
+            end
+          else
+            Class.new(Redcarpet::Render::HTML) do
+              include WithoutHighlighting
+            end
+          end
+        end
+
+        def convert(content)
+          @redcarpet_extensions[:fenced_code_blocks] = !@redcarpet_extensions[:no_fenced_code_blocks]
+          @renderer.send :include, Redcarpet::Render::SmartyPants if @redcarpet_extensions[:smart]
+          markdown = Redcarpet::Markdown.new(@renderer.new(@redcarpet_extensions), @redcarpet_extensions)
+          markdown.render(content)
+        end
+      end
+    end
+  end
+end

data/lib/bunto/converters/smartypants.rb

@@ -0,0 +1,34 @@
+class Kramdown::Parser::SmartyPants < Kramdown::Parser::Kramdown
+  def initialize(source, options)
+    super
+    @block_parsers = [:block_html]
+    @span_parsers =  [:smart_quotes, :html_entity, :typographic_syms, :span_html]
+  end
+end
+
+module Bunto
+  module Converters
+    class SmartyPants < Converter
+      safe true
+      priority :low
+
+      def initialize(config)
+        Bunto::External.require_with_graceful_fail "kramdown"
+        @config = config["kramdown"].dup || {}
+        @config[:input] = :SmartyPants
+      end
+
+      def matches(_)
+        false
+      end
+
+      def output_ext(_)
+        nil
+      end
+
+      def convert(content)
+        Kramdown::Document.new(content, @config).to_html.chomp
+      end
+    end
+  end
+end

data/lib/bunto/convertible.rb

@@ -0,0 +1,297 @@
+# encoding: UTF-8
+
+require 'set'
+
+# Convertible provides methods for converting a pagelike item
+# from a certain type of markup into actual content
+#
+# Requires
+#   self.site -> Bunto::Site
+#   self.content
+#   self.content=
+#   self.data=
+#   self.ext=
+#   self.output=
+#   self.name
+#   self.path
+#   self.type -> :page, :post or :draft
+
+module Bunto
+  module Convertible
+    # Returns the contents as a String.
+    def to_s
+      content || ''
+    end
+
+    # Whether the file is published or not, as indicated in YAML front-matter
+    def published?
+      !(data.key?('published') && data['published'] == false)
+    end
+
+    # Read the YAML frontmatter.
+    #
+    # base - The String path to the dir containing the file.
+    # name - The String filename of the file.
+    # opts - optional parameter to File.read, default at site configs
+    #
+    # Returns nothing.
+    def read_yaml(base, name, opts = {})
+      filename = File.join(base, name)
+
+      begin
+        self.content = File.read(site.in_source_dir(base, name),
+                                 Utils.merged_file_read_opts(site, opts))
+        if content =~ /\A(---\s*\n.*?\n?)^((---|\.\.\.)\s*$\n?)/m
+          self.content = $POSTMATCH
+          self.data = SafeYAML.load(Regexp.last_match(1))
+        end
+      rescue SyntaxError => e
+        Bunto.logger.warn "YAML Exception reading #{filename}: #{e.message}"
+      rescue Exception => e
+        Bunto.logger.warn "Error reading file #{filename}: #{e.message}"
+      end
+
+      self.data ||= {}
+
+      validate_data! filename
+      validate_permalink! filename
+
+      self.data
+    end
+
+    def validate_data!(filename)
+      unless self.data.is_a?(Hash)
+        raise Errors::InvalidYAMLFrontMatterError, "Invalid YAML front matter in #{filename}"
+      end
+    end
+
+    def validate_permalink!(filename)
+      if self.data['permalink'] && self.data['permalink'].size == 0
+        raise Errors::InvalidPermalinkError, "Invalid permalink in #{filename}"
+      end
+    end
+
+    # Transform the contents based on the content type.
+    #
+    # Returns the transformed contents.
+    def transform
+      converters.reduce(content) do |output, converter|
+        begin
+          converter.convert output
+        rescue => e
+          Bunto.logger.error "Conversion error:", "#{converter.class} encountered an error while converting '#{path}':"
+          Bunto.logger.error("", e.to_s)
+          raise e
+        end
+      end
+    end
+
+    # Determine the extension depending on content_type.
+    #
+    # Returns the String extension for the output file.
+    #   e.g. ".html" for an HTML output file.
+    def output_ext
+      Bunto::Renderer.new(site, self).output_ext
+    end
+
+    # Determine which converter to use based on this convertible's
+    # extension.
+    #
+    # Returns the Converter instance.
+    def converters
+      @converters ||= site.converters.select { |c| c.matches(ext) }.sort
+    end
+
+    # Render Liquid in the content
+    #
+    # content - the raw Liquid content to render
+    # payload - the payload for Liquid
+    # info    - the info for Liquid
+    #
+    # Returns the converted content
+    def render_liquid(content, payload, info, path)
+      site.liquid_renderer.file(path).parse(content).render!(payload, info)
+    rescue Tags::IncludeTagError => e
+      Bunto.logger.error "Liquid Exception:", "#{e.message} in #{e.path}, included in #{path || self.path}"
+      raise e
+    rescue Exception => e
+      Bunto.logger.error "Liquid Exception:", "#{e.message} in #{path || self.path}"
+      raise e
+    end
+
+    # Convert this Convertible's data to a Hash suitable for use by Liquid.
+    #
+    # Returns the Hash representation of this Convertible.
+    def to_liquid(attrs = nil)
+      further_data = Hash[(attrs || self.class::ATTRIBUTES_FOR_LIQUID).map do |attribute|
+        [attribute, send(attribute)]
+      end]
+
+      defaults = site.frontmatter_defaults.all(relative_path, type)
+      Utils.deep_merge_hashes defaults, Utils.deep_merge_hashes(data, further_data)
+    end
+
+    # The type of a document,
+    #   i.e., its classname downcase'd and to_sym'd.
+    #
+    # Returns the type of self.
+    def type
+      if is_a?(Page)
+        :pages
+      end
+    end
+
+    # returns the owner symbol for hook triggering
+    def hook_owner
+      if is_a?(Page)
+        :pages
+      end
+    end
+
+    # Determine whether the document is an asset file.
+    # Asset files include CoffeeScript files and Sass/SCSS files.
+    #
+    # Returns true if the extname belongs to the set of extensions
+    #   that asset files use.
+    def asset_file?
+      sass_file? || coffeescript_file?
+    end
+
+    # Determine whether the document is a Sass file.
+    #
+    # Returns true if extname == .sass or .scss, false otherwise.
+    def sass_file?
+      %w(.sass .scss).include?(ext)
+    end
+
+    # Determine whether the document is a CoffeeScript file.
+    #
+    # Returns true if extname == .coffee, false otherwise.
+    def coffeescript_file?
+      '.coffee'.eql?(ext)
+    end
+
+    # Determine whether the file should be rendered with Liquid.
+    #
+    # Always returns true.
+    def render_with_liquid?
+      true
+    end
+
+    # Determine whether the file should be placed into layouts.
+    #
+    # Returns false if the document is an asset file.
+    def place_in_layout?
+      !asset_file?
+    end
+
+    # Checks if the layout specified in the document actually exists
+    #
+    # layout - the layout to check
+    #
+    # Returns true if the layout is invalid, false if otherwise
+    def invalid_layout?(layout)
+      !data["layout"].nil? && layout.nil? && !(self.is_a? Bunto::Excerpt)
+    end
+
+    # Recursively render layouts
+    #
+    # layouts - a list of the layouts
+    # payload - the payload for Liquid
+    # info    - the info for Liquid
+    #
+    # Returns nothing
+    def render_all_layouts(layouts, payload, info)
+      # recursively render layouts
+      layout = layouts[data["layout"]]
+
+      Bunto.logger.warn("Build Warning:", "Layout '#{data["layout"]}' requested in #{path} does not exist.") if invalid_layout? layout
+
+      used = Set.new([layout])
+
+      while layout
+        Bunto.logger.debug "Rendering Layout:", path
+        payload["content"] = output
+        payload["layout"]  = Utils.deep_merge_hashes(payload["layout"] || {}, layout.data)
+
+        self.output = render_liquid(layout.content,
+                                         payload,
+                                         info,
+                                         File.join(site.config['layouts_dir'], layout.name))
+
+        # Add layout to dependency tree
+        site.regenerator.add_dependency(
+          site.in_source_dir(path),
+          site.in_source_dir(layout.path)
+        )
+
+        if layout = layouts[layout.data["layout"]]
+          if used.include?(layout)
+            layout = nil # avoid recursive chain
+          else
+            used << layout
+          end
+        end
+      end
+    end
+
+    # Add any necessary layouts to this convertible document.
+    #
+    # payload - The site payload Drop or Hash.
+    # layouts - A Hash of {"name" => "layout"}.
+    #
+    # Returns nothing.
+    def do_layout(payload, layouts)
+      Bunto.logger.debug "Rendering:", self.relative_path
+
+      Bunto.logger.debug "Pre-Render Hooks:", self.relative_path
+      Bunto::Hooks.trigger hook_owner, :pre_render, self, payload
+      info = { :filters => [Bunto::Filters], :registers => { :site => site, :page => payload["page"] } }
+
+      # render and transform content (this becomes the final content of the object)
+      payload["highlighter_prefix"] = converters.first.highlighter_prefix
+      payload["highlighter_suffix"] = converters.first.highlighter_suffix
+
+      if render_with_liquid?
+        Bunto.logger.debug "Rendering Liquid:", self.relative_path
+        self.content = render_liquid(content, payload, info, path)
+      end
+      Bunto.logger.debug "Rendering Markup:", self.relative_path
+      self.content = transform
+
+      # output keeps track of what will finally be written
+      self.output = content
+
+      render_all_layouts(layouts, payload, info) if place_in_layout?
+      Bunto.logger.debug "Post-Render Hooks:", self.relative_path
+      Bunto::Hooks.trigger hook_owner, :post_render, self
+    end
+
+    # Write the generated page file to the destination directory.
+    #
+    # dest - The String path to the destination dir.
+    #
+    # Returns nothing.
+    def write(dest)
+      path = destination(dest)
+      FileUtils.mkdir_p(File.dirname(path))
+      File.open(path, 'wb') do |f|
+        f.write(output)
+      end
+      Bunto::Hooks.trigger hook_owner, :post_write, self
+    end
+
+    # Accessor for data properties by Liquid.
+    #
+    # property - The String name of the property to retrieve.
+    #
+    # Returns the String value or nil if the property isn't included.
+    def [](property)
+      if self.class::ATTRIBUTES_FOR_LIQUID.include?(property)
+        send(property)
+      else
+        data[property]
+      end
+    end
+  end
+end