spirit 0.2 → 0.5

data/lib/spirit/render/processors/block_image_processor.rb

@@ -0,0 +1,49 @@
+module Spirit
+  module Render
+    module Processors
+
+      class BlockImageProcessor < Base
+
+        process :paragraph, :filter
+
+        # Paragraphs that only contain images are rendered with
+        # {Spirit::Render::Image}.
+        IMAGE_REGEX = /\A\s*<img[^<>]+>\s*\z/m
+
+        def initialize(*args)
+          @image = 0
+        end
+
+        # Detects block images and renders them as such.
+        # @return [String] rendered html
+        def filter(text)
+          case text
+          when IMAGE_REGEX then block_image(text)
+          else p(text) end
+        rescue RenderError => e # fall back to paragraph
+          Spirit.logger.warn e.message
+          p(text)
+        end
+
+        private
+
+        # Prepares a block image. Raises {RenderError} if the given text does
+        # not contain a valid image block.
+        # @param  [String] text           markdown text
+        # @return [String] rendered HTML
+        def block_image(text)
+          Image.parse(text).render(index: @image += 1)
+        end
+
+        # Wraps the given text with paragraph tags.
+        # @param [String] text            paragraph text
+        # @return [String] rendered html
+        def p(text)
+          '<p>' + text + '</p>'
+        end
+
+      end
+
+    end
+  end
+end

data/lib/spirit/render/processors/headers_processor.rb

@@ -0,0 +1,41 @@
+module Spirit
+  module Render
+    module Processors
+
+      # In-charge of headers, navigation bar, and nesting.
+      # Depends on renderer#navigation and renderer#nesting
+      class HeadersProcessor < Base
+
+        process :header, :header
+
+        def initialize(renderer, *args)
+          renderer.nesting = @nesting = []
+          renderer.navigation = @navigation = Navigation.new
+          @headers = Headers.new
+        end
+
+        # Increases all header levels by one and keeps a navigation bar.
+        # @return [String] rendered html
+        def header(text, level)
+          h = headers.add(text, level += 1)
+          navigation.append(text, h.name) if level == 2
+          nest h
+          h.render
+        end
+
+        private
+
+        attr_accessor :headers, :navigation, :nesting
+
+        # Maintains the +nesting+ array.
+        # @param [Header] h
+        def nest(h)
+          nesting.pop until nesting.empty? or h.level > nesting.last.level
+          nesting << h
+        end
+
+      end
+
+    end
+  end
+end

data/lib/spirit/render/processors/layout_processor.rb

@@ -0,0 +1,28 @@
+module Spirit
+  module Render
+    module Processors
+
+      # Post-processes a layout in HAML.
+      class LayoutProcessor < Base
+
+        TEMPLATE = File.join VIEWS, 'layout.haml'
+
+        attr_accessor :engine, :renderer
+        process :postprocess, :render
+
+        def initialize(renderer, *args)
+          template  = File.read TEMPLATE
+          @engine   = Haml::Engine.new template, HAML_CONFIG
+          @renderer = renderer
+        end
+
+        def render(document)
+          engine.render renderer,
+            content: document.force_encoding('utf-8')
+        end
+
+      end
+
+    end
+  end
+end

data/lib/spirit/render/processors/math_processor.rb

@@ -0,0 +1,102 @@
+module Spirit
+  module Render
+    module Processors
+
+      # Pre-processes math markup in latex.
+      # Adapted from
+      # http://www.math.union.edu/~dpvc/transfer/mathjax/mathjax-editing.js
+      class MathProcessor < Base
+
+        process :preprocess,  :filter
+        process :postprocess, :replace
+
+        # Pattern for delimiters and special symbols; used to search for math in
+        # the document.
+        SPLIT = /(\$\$?|                        (?# 1 or 2 dollars)
+                  \\(?:begin|end)\{[a-z]*\*?\}| (?# latex envs)
+                  \\[\\{}$]|                    (?# \\ \{ \})
+                  [{}]|                         (?# braces )
+                  (?:\n\s*)+|                   (?# newlines w. optional spaces)
+                  @@\d+@@)                      (?# @@digits@@)
+               /ix
+
+        def initialize(renderer, document)
+          reset_counters
+          @math   = []
+          @blocks = document.gsub(/\r\n?/, "\n").split SPLIT
+        end
+
+        # Replace math in document with +@@index@@+.
+        # @return [String] document
+        def filter(document)
+          blocks.each_with_index do |block, i|
+            case
+            when '@' == block[0]
+              process_pseudo_marker block, i
+            when @start
+              process_potential_close block, i
+            else
+              process_potential_start block, i
+            end
+          end
+          process_math if @last
+          blocks.join
+        end
+
+        def replace(document)
+          document.gsub(/@@(\d+)@@/) { math[$1.to_i] }
+        end
+
+        private
+
+        attr_reader :blocks, :math
+
+        def process_pseudo_marker(block, i)
+          blocks[i] = "@@#{math.length}@@"
+          math << block
+        end
+
+        def process_potential_start(block, i)
+          case block
+          when '$', '$$'
+            @start, @close, @braces = i, block, 0
+          when /\A\\begin\{([a-z]*\*?)\}/
+            @start, @close, @braces = i, "\\end{#{$1}}", 0
+          end
+        end
+
+        def process_potential_close(block, i)
+          case block
+          when @close     # process if braces match
+            @braces.zero? ? process_math(i) : @last = i
+          when /\n.*\n/   # don't go over double line breaks
+            process_math if @last
+            reset_counters
+          when '{' then @braces += 1 # balance braces
+          when '}' then @braces -= 1 if @braces > 0
+          end
+        end
+
+        # Collects the math from blocks +i+ through +j+, replaces &, <, and > by
+        # named entities, and resets that math positions.
+        def process_math(last = @last)
+          block = blocks[@start..last].join
+            .gsub(/&/, '&amp;')
+            .gsub(/</, '&lt;')
+            .gsub(/>/, '&gt;')
+          last.downto(@start+1) { |k| blocks[k] = '' }
+          blocks[@start] = "@@#{math.length}@@"
+          math << block
+          reset_counters
+        end
+
+        def reset_counters
+          @start = @close = @last = nil
+          @braces = 0
+        end
+
+      end
+
+    end
+  end
+end

data/lib/spirit/render/processors/problems_processor.rb

@@ -0,0 +1,76 @@
+module Spirit
+  module Render
+    module Processors
+
+      # Pre-processes problem markup in YAML.
+      # Dependent on renderer#problems and renderer#nesting.
+      class ProblemsProcessor < Base
+
+        # Paragraphs that start and end with +"""+ are treated as embedded YAML
+        # and are parsed for questions/answers.
+        REGEX = /^"""$(.*?)^"""$/m
+
+        MARKER = /\A<!-- %%(\d+)%% -->\z/
+
+        attr_reader :problems, :solutions
+        delegate :size, :count, :each, :each_with_index, to: :problems
+        process  :preprocess, :filter
+        process  :block_html, :replace
+
+        def initialize(renderer, *args)
+          @renderer  = renderer
+          @problems  = []
+          @solutions = []
+          renderer.problems = self
+        end
+
+        # Replaces YAML markup in document with <!-- %%index%% -->
+        # @return [String] document
+        def filter(document)
+          document.gsub(REGEX) { problem $1 }
+        end
+
+        def replace(html)
+          return html unless is_marker? html
+          replace_nesting html, renderer.nesting
+          ''
+        end
+
+        private
+
+        attr_reader :renderer
+
+        # Update associated problem with nesting information.
+        # @return [void]
+        def replace_nesting(html, nesting)
+          match = html.strip.match MARKER
+          prob  = problems[match[1].to_i]
+          prob.nesting = nesting.dup
+        end
+
+        # @return [Boolean] true iff the given html corresponds to a problem
+        #   marker
+        def is_marker?(html)
+          html.strip =~ MARKER and problems[$1.to_i]
+        end
+
+        # If the given text contains valid YAML, returns a marker. Otherwise,
+        # returns the original text.
+        # @param  [String] text            candidate YAML markup
+        # @return [String] text or marker
+        def problem(text)
+          p = Problem.parse(text)
+          p.id = problems.size
+          self.problems  << p
+          self.solutions << {digest: p.digest, solution: Marshal.dump(p.answer)}
+          Spirit.logger.record :problem, "ID: #{p.id}"
+        rescue RenderError
+          text
+        else "<!-- %%#{p.id}%% -->"
+        end
+
+      end
+
+    end
+  end
+end

data/lib/spirit/render/processors/pygments_processor.rb

@@ -0,0 +1,22 @@
+require 'pygments'
+module Spirit
+  module Render
+    module Processors
+
+      class PygmentsProcessor < Base
+
+        process :block_code, :highlight_code
+
+        # Pygmentizes code blocks.
+        # @param [String] code        code block contents
+        # @param [String] marker      name of language
+        # @return [String] highlighted code
+        def highlight_code(code, marker)
+          Pygments.highlight(code, lexer: marker || 'text')
+        end
+
+      end
+
+    end
+  end
+end

data/lib/spirit/render/processors/sanitize_processor.rb

@@ -0,0 +1,86 @@
+require 'sanitize'
+
+module Spirit
+  module Render
+    module Processors
+
+      # Encapsulates sanitization options.
+      # @see https://github.com/github/gollum/blob/master/lib/gollum/sanitization.rb
+      class SanitizeProcessor < Base
+
+        process :postprocess, :clean
+
+        # white-listed elements
+        ELEMENTS = [
+          'a', 'abbr', 'acronym', 'address', 'area', 'b', 'big',
+          'blockquote', 'br', 'button', 'caption', 'center', 'cite',
+          'code', 'col', 'colgroup', 'dd', 'del', 'dfn', 'dir',
+          'div', 'dl', 'dt', 'em', 'fieldset', 'font', 'form', 'h1',
+          'h2', 'h3', 'h4', 'h5', 'h6', 'hr', 'i', 'img', 'input',
+          'ins', 'kbd', 'label', 'legend', 'li', 'map', 'menu',
+          'ol', 'optgroup', 'option', 'p', 'pre', 'q', 's', 'samp',
+          'select', 'small', 'span', 'strike', 'strong', 'sub',
+          'sup', 'table', 'tbody', 'td', 'textarea', 'tfoot', 'th',
+          'thead', 'tr', 'tt', 'u', 'ul', 'var'
+        ].freeze
+
+        # white-listed attributes
+        ATTRIBUTES = {
+          'a'   => ['href', 'name', 'data-magellan-destination', 'data-action'],
+          'input' => ['data-max-page'],
+          'dd'  => ['data-magellan-arrival'],
+          'dl'  => ['data-magellan-expedition'],
+          'img' => ['src'],
+          :all  => ['abbr', 'accept', 'accept-charset',
+                    'accesskey', 'action', 'align', 'alt', 'axis',
+                    'border', 'cellpadding', 'cellspacing', 'char',
+                    'charoff', 'class', 'charset', 'checked', 'cite',
+                    'clear', 'cols', 'colspan', 'color',
+                    'compact', 'coords', 'datetime', 'dir',
+                    'disabled', 'enctype', 'for', 'frame',
+                    'headers', 'height', 'hreflang',
+                    'hspace', 'id', 'ismap', 'label', 'lang',
+                    'longdesc', 'maxlength', 'media', 'method',
+                    'multiple', 'name', 'nohref', 'noshade',
+                    'nowrap', 'prompt', 'readonly', 'rel', 'rev',
+                    'rows', 'rowspan', 'rules', 'scope',
+                    'selected', 'shape', 'size', 'span',
+                    'start', 'summary', 'tabindex', 'target',
+                    'title', 'type', 'usemap', 'valign', 'value',
+                    'vspace', 'width']
+        }.freeze
+
+        # white-listed protocols
+        PROTOCOLS = {
+          'a'   => {'href' => ['http', 'https', 'mailto', 'ftp', 'irc', 'apt', :relative]},
+          'img' => {'src'  => ['http', 'https', :relative]}
+        }.freeze
+
+        # elements to remove (incl. contents)
+        REMOVE_CONTENTS = %w[script style].freeze
+
+        # attributes to add to elements
+        ADD_ATTRIBUTES = { 'a' => {'rel' => 'nofollow'} }.freeze
+
+        def self.config
+          { elements:         ELEMENTS.dup,
+            attributes:       ATTRIBUTES.dup,
+            protocols:        PROTOCOLS.dup,
+            add_attributes:   ADD_ATTRIBUTES.dup,
+            remove_contents:  REMOVE_CONTENTS.dup,
+            allow_comments:   false
+          }
+        end
+
+        class_attribute :sanitizer
+        self.sanitizer = ::Sanitize.new config
+
+        def clean(document)
+          sanitizer.clean document
+        end
+
+      end
+
+    end
+  end
+end

data/lib/spirit/render/templates.rb

@@ -1,6 +1,4 @@
-# ~*~ encoding: utf-8 ~*~
-
 # require all template types
-%w(template header image problem multi short table navigation).each do |type|
+%w[template header image problem multi short table navigation].each do |type|
   require File.join 'spirit', 'render', 'templates', type
 end

data/lib/spirit/render/templates/header.rb

@@ -29,9 +29,8 @@ module Spirit
     class Header < Template
 
       # Name of template file for rendering headers.
-      TEMPLATE = 'header.haml'
-
-      attr_reader :name
+      self.template = 'header.haml'
+      attr_reader :name, :text, :level
 
       # Creates a new header.
       # @param [String] text          header text

data/lib/spirit/render/templates/image.rb

@@ -1,26 +1,20 @@
-# ~*~ encoding: utf-8 ~*~
 require 'nokogiri'
 
 module Spirit
-
   module Render
 
     # Renders a block image with a figure number.
     class Image < Template
 
       # <img ...>
-      IMAGE_TAG = 'img'
+      IMAGE_TAG = 'img'.freeze
 
       # Name of template file for rendering block images
-      TEMPLATE = 'img.haml'
-
-      class << self
-
-        # Parses the given text for a block image.
-        def parse(text)
-          Image.new text
-        end
+      self.template = 'img.haml'
 
+      # Parses the given text for a block image.
+      def self.parse(text)
+        Image.new text
       end
 
       # Creates a new image.
@@ -37,7 +31,7 @@ module Spirit
 
       # Parses the given HTML, or raise {RenderError} if it is invalid.
       def parse_or_raise
-        frag = Nokogiri::HTML::DocumentFragment.parse(@html)
+        frag = Nokogiri::HTML::DocumentFragment.parse(@html.strip)
         if 1 == frag.children.count and
           node = frag.children.first and
           node.is_a? Nokogiri::XML::Element and
@@ -50,5 +44,4 @@ module Spirit
     end
 
   end
-
 end