monad 0.0.1

data/lib/monad/converter.rb

@@ -0,0 +1,48 @@
+module Monad
+  class Converter < Plugin
+    # Public: Get or set the pygments prefix. When an argument is specified,
+    # the prefix will be set. If no argument is specified, the current prefix
+    # will be returned.
+    #
+    # pygments_prefix - The String prefix (default: nil).
+    #
+    # Returns the String prefix.
+    def self.pygments_prefix(pygments_prefix = nil)
+      @pygments_prefix = pygments_prefix if pygments_prefix
+      @pygments_prefix
+    end
+
+    # Public: Get or set the pygments suffix. When an argument is specified,
+    # the suffix will be set. If no argument is specified, the current suffix
+    # will be returned.
+    #
+    # pygments_suffix - The String suffix (default: nil).
+    #
+    # Returns the String suffix.
+    def self.pygments_suffix(pygments_suffix = nil)
+      @pygments_suffix = pygments_suffix if pygments_suffix
+      @pygments_suffix
+    end
+
+    # Initialize the converter.
+    #
+    # Returns an initialized Converter.
+    def initialize(config = {})
+      @config = config
+    end
+
+    # Get the pygments prefix.
+    #
+    # Returns the String prefix.
+    def pygments_prefix
+      self.class.pygments_prefix
+    end
+
+    # Get the pygments suffix.
+    #
+    # Returns the String suffix.
+    def pygments_suffix
+      self.class.pygments_suffix
+    end
+  end
+end

data/lib/monad/converters/identity.rb

@@ -0,0 +1,21 @@
+module Monad
+  module Converters
+    class Identity < Converter
+      safe true
+
+      priority :lowest
+
+      def matches(ext)
+        true
+      end
+
+      def output_ext(ext)
+        ext
+      end
+
+      def convert(content)
+        content
+      end
+    end
+  end
+end

data/lib/monad/converters/markdown.rb

@@ -0,0 +1,43 @@
+module Monad
+  module Converters
+    class Markdown < Converter
+      safe true
+
+      pygments_prefix "\n"
+      pygments_suffix "\n"
+
+      def setup
+        return if @setup
+        @parser = case @config['markdown']
+          when 'redcarpet'
+            RedcarpetParser.new @config
+          when 'kramdown'
+            KramdownParser.new @config
+          when 'rdiscount'
+            RDiscountParser.new @config
+          when 'maruku'
+            MarukuParser.new @config
+          else
+            STDERR.puts "Invalid Markdown processor: #{@config['markdown']}"
+            STDERR.puts "  Valid options are [ maruku | rdiscount | kramdown | redcarpet ]"
+            raise FatalException.new("Invalid Markdown process: #{@config['markdown']}")
+        end
+        @setup = true
+      end
+
+      def matches(ext)
+        rgx = '(' + @config['markdown_ext'].gsub(',','|') +')'
+        ext =~ Regexp.new(rgx, Regexp::IGNORECASE)
+      end
+
+      def output_ext(ext)
+        ".html"
+      end
+
+      def convert(content)
+        setup
+        @parser.convert(content)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module Monad
+  module Converters
+    class Markdown
+      class KramdownParser
+        def initialize(config)
+          require 'kramdown'
+          @config = config
+        rescue LoadError
+          STDERR.puts 'You are missing a library required for Markdown. Please run:'
+          STDERR.puts '  $ [sudo] gem install kramdown'
+          raise FatalException.new("Missing dependency: kramdown")
+        end
+
+        def convert(content)
+          # Check for use of coderay
+          kramdown_configs = if @config['kramdown']['use_coderay']
+            base_kramdown_configs.merge({
+              :coderay_wrap               => @config['kramdown']['coderay']['coderay_wrap'],
+              :coderay_line_numbers       => @config['kramdown']['coderay']['coderay_line_numbers'],
+              :coderay_line_number_start  => @config['kramdown']['coderay']['coderay_line_number_start'],
+              :coderay_tab_width          => @config['kramdown']['coderay']['coderay_tab_width'],
+              :coderay_bold_every         => @config['kramdown']['coderay']['coderay_bold_every'],
+              :coderay_css                => @config['kramdown']['coderay']['coderay_css']
+            })
+          else
+            # not using coderay
+            base_kramdown_configs
+          end
+          Kramdown::Document.new(content, kramdown_configs).to_html
+        end
+
+        def base_kramdown_configs
+          {
+            :auto_ids      => @config['kramdown']['auto_ids'],
+            :footnote_nr   => @config['kramdown']['footnote_nr'],
+            :entity_output => @config['kramdown']['entity_output'],
+            :toc_levels    => @config['kramdown']['toc_levels'],
+            :smart_quotes  => @config['kramdown']['smart_quotes']
+          }
+        end
+      end
+    end
+  end
+end

data/lib/monad/converters/markdown/maruku_parser.rb

@@ -0,0 +1,47 @@
+module Monad
+  module Converters
+    class Markdown
+      class MarukuParser
+        def initialize(config)
+          require 'maruku'
+          @config = config
+          if @config['maruku']['use_divs']
+            load_divs_library
+          end
+          if @config['maruku']['use_tex']
+            load_blahtext_library
+          end
+        rescue LoadError
+          STDERR.puts 'You are missing a library required for Markdown. Please run:'
+          STDERR.puts '  $ [sudo] gem install maruku'
+          raise FatalException.new("Missing dependency: maruku")
+        end
+
+        def load_divs_library
+          require 'maruku/ext/div'
+          STDERR.puts 'Maruku: Using extended syntax for div elements.'
+        end
+
+        def load_blahtext_library
+          require 'maruku/ext/math'
+          STDERR.puts "Maruku: Using LaTeX extension. Images in `#{@config['maruku']['png_dir']}`."
+
+          # Switch off MathML output
+          MaRuKu::Globals[:html_math_output_mathml] = false
+          MaRuKu::Globals[:html_math_engine] = 'none'
+
+          # Turn on math to PNG support with blahtex
+          # Resulting PNGs stored in `images/latex`
+          MaRuKu::Globals[:html_math_output_png] = true
+          MaRuKu::Globals[:html_png_engine] =  @config['maruku']['png_engine']
+          MaRuKu::Globals[:html_png_dir] = @config['maruku']['png_dir']
+          MaRuKu::Globals[:html_png_url] = @config['maruku']['png_url']
+        end
+
+        def convert(content)
+          Maruku.new(content).to_html
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module Monad
+  module Converters
+    class Markdown
+      class RDiscountParser
+        def initialize(config)
+          require 'rdiscount'
+          @config = config
+          @rdiscount_extensions = @config['rdiscount']['extensions'].map { |e| e.to_sym }
+        rescue LoadError
+          STDERR.puts 'You are missing a library required for Markdown. Please run:'
+          STDERR.puts '  $ [sudo] gem install rdiscount'
+          raise FatalException.new("Missing dependency: rdiscount")
+        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)
+            html.gsub(toc_token, rd.toc_content.force_encoding('utf-8'))
+          else
+            html
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+module Monad
+  module Converters
+    class Markdown
+      class RedcarpetParser
+
+        module CommonMethods
+          def add_code_tags(code, lang)
+            code = code.sub(/<pre>/, "<pre><code class=\"#{lang} language-#{lang}\" data-lang=\"#{lang}\">")
+            code = code.sub(/<\/pre>/,"</code></pre>")
+          end
+        end
+
+        module WithPygments
+          include CommonMethods
+          def block_code(code, lang)
+            require 'pygments'
+            lang = lang && lang.split.first || "text"
+            output = add_code_tags(
+              Pygments.highlight(code, :lexer => lang, :options => { :encoding => 'utf-8' }),
+              lang
+            )
+          end
+        end
+
+        module WithoutPygments
+          require 'cgi'
+
+          include CommonMethods
+
+          def code_wrap(code)
+            "<div class=\"highlight\"><pre>#{CGI::escapeHTML(code)}</pre></div>"
+          end
+
+          def block_code(code, lang)
+            lang = lang && lang.split.first || "text"
+            output = add_code_tags(code_wrap(code), lang)
+          end
+        end
+
+        def initialize(config)
+          require 'redcarpet'
+          @config = config
+          @redcarpet_extensions = {}
+          @config['redcarpet']['extensions'].each { |e| @redcarpet_extensions[e.to_sym] = true }
+
+          @renderer ||= if @config['pygments']
+                          Class.new(Redcarpet::Render::HTML) do
+                            include WithPygments
+                          end
+                        else
+                          Class.new(Redcarpet::Render::HTML) do
+                            include WithoutPygments
+                          end
+                        end
+        rescue LoadError
+          STDERR.puts 'You are missing a library required for Markdown. Please run:'
+          STDERR.puts '  $ [sudo] gem install redcarpet'
+          raise FatalException.new("Missing dependency: redcarpet")
+        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/monad/converters/textile.rb

@@ -0,0 +1,50 @@
+module Monad
+  module Converters
+    class Textile < Converter
+      safe true
+
+      pygments_prefix '<notextile>'
+      pygments_suffix '</notextile>'
+
+      def setup
+        return if @setup
+        require 'redcloth'
+        @setup = true
+      rescue LoadError
+        STDERR.puts 'You are missing a library required for Textile. Please run:'
+        STDERR.puts '  $ [sudo] gem install RedCloth'
+        raise FatalException.new("Missing dependency: RedCloth")
+      end
+
+      def matches(ext)
+        rgx = '(' + @config['textile_ext'].gsub(',','|') +')'
+        ext =~ Regexp.new(rgx, Regexp::IGNORECASE)
+      end
+
+      def output_ext(ext)
+        ".html"
+      end
+
+      def convert(content)
+        setup
+
+        # Shortcut if config doesn't contain RedCloth section
+        return RedCloth.new(content).to_html if @config['redcloth'].nil?
+
+        # List of attributes defined on RedCloth
+        # (from http://redcloth.rubyforge.org/classes/RedCloth/TextileDoc.html)
+        attrs = ['filter_classes', 'filter_html', 'filter_ids', 'filter_styles',
+                'hard_breaks', 'lite_mode', 'no_span_caps', 'sanitize_html']
+
+        r = RedCloth.new(content)
+
+        # Set attributes in r if they are NOT nil in the config
+        attrs.each do |attr|
+          r.instance_variable_set("@#{attr}".to_sym, @config['redcloth'][attr]) unless @config['redcloth'][attr].nil?
+        end
+
+        r.to_html
+      end
+    end
+  end
+end

data/lib/monad/convertible.rb

@@ -0,0 +1,152 @@
+# 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 -> Monad::Site
+#   self.content
+#   self.content=
+#   self.data=
+#   self.ext=
+#   self.output=
+#   self.name
+module Monad
+  module Convertible
+    # Returns the contents as a String.
+    def to_s
+      self.content || ''
+    end
+
+    # Read the YAML frontmatter.
+    #
+    # base - The String path to the dir containing the file.
+    # name - The String filename of the file.
+    #
+    # Returns nothing.
+    def read_yaml(base, name)
+      begin
+        self.content = File.read(File.join(base, name))
+
+        if self.content =~ /\A(---\s*\n.*?\n?)^(---\s*$\n?)/m
+          self.content = $POSTMATCH
+          self.data = YAML.safe_load($1)
+        end
+      rescue SyntaxError => e
+        puts "YAML Exception reading #{File.join(base, name)}: #{e.message}"        
+      rescue Exception => e
+        puts "Error reading file #{File.join(base, name)}: #{e.message}"
+      end
+
+      self.data ||= {}
+    end
+
+    # Transform the contents based on the content type.
+    #
+    # Returns nothing.
+    def transform
+      self.content = converter.convert(self.content)
+    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
+      converter.output_ext(self.ext)
+    end
+
+    # Determine which converter to use based on this convertible's
+    # extension.
+    #
+    # Returns the Converter instance.
+    def converter
+      @converter ||= self.site.converters.find { |c| c.matches(self.ext) }
+    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)
+      Liquid::Template.parse(content).render!(payload, info)
+    rescue Exception => e
+      Monad::Logger.error "Liquid Exception:", "#{e.message} in #{payload[:file]}"
+      e.backtrace.each do |backtrace|
+        puts backtrace
+      end
+      abort("Build Failed")
+    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[self.data["layout"]]
+      used = Set.new([layout])
+
+      while layout
+        payload = payload.deep_merge({"content" => self.output, "page" => layout.data})
+
+        self.output = self.render_liquid(layout.content,
+                                         payload.merge({:file => self.data["layout"]}),
+                                         info)
+
+        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 Hash.
+    # layouts - A Hash of {"name" => "layout"}.
+    #
+    # Returns nothing.
+    def do_layout(payload, layouts)
+      info = { :filters => [Monad::Filters], :registers => { :site => self.site, :page => payload['page'] } }
+
+      # render and transform content (this becomes the final content of the object)
+      payload["pygments_prefix"] = converter.pygments_prefix
+      payload["pygments_suffix"] = converter.pygments_suffix
+
+      self.content = self.render_liquid(self.content,
+                                        payload.merge({:file => self.name}),
+                                        info)
+      self.transform
+
+      # output keeps track of what will finally be written
+      self.output = self.content
+
+      self.render_all_layouts(layouts, payload, info)
+    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, 'w') do |f|
+        f.write(self.output)
+      end
+    end
+  end
+end