hemingway 0.0.0 → 0.0.2

data/lib/hemingway/block/quote/quote_nodes.rb

@@ -0,0 +1,25 @@
+module Hemingway
+
+  module QuoteNode
+    def html(block_content)
+      Build.tag("blockquote", block_content.html)
+    end
+  end
+
+  module QuoteEntryNode
+    def html
+      elements.map { |e| e.html }.join
+    end
+  end
+
+  module QuoteParagraphNode
+    def html
+      paragraph_content = sequence.elements.map do |element|
+        element.html
+      end.join
+
+      Build.tag("p", paragraph_content)
+    end
+  end
+
+end

data/lib/hemingway/block/verbatim/verbatim.rb

@@ -0,0 +1,159 @@
+# Autogenerated from a Treetop grammar. Edits may be lost.
+
+
+require "hemingway/block/verbatim/verbatim_nodes"
+
+module Hemingway
+  module Block
+    module Verbatim
+      include Treetop::Runtime
+
+      def root
+        @root ||= :verbatim
+      end
+
+      def _nt_verbatim
+        start_index = index
+        if node_cache[:verbatim].has_key?(index)
+          cached = node_cache[:verbatim][index]
+          if cached
+            cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        r0 = _nt_verbatim_text
+
+        node_cache[:verbatim][start_index] = r0
+
+        r0
+      end
+
+      def _nt_verbatim_type
+        start_index = index
+        if node_cache[:verbatim_type].has_key?(index)
+          cached = node_cache[:verbatim_type][index]
+          if cached
+            cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        if has_terminal?("verbatim", false, index)
+          r0 = instantiate_node(VerbatimNode,input, index...(index + 8))
+          @index += 8
+        else
+          terminal_parse_failure("verbatim")
+          r0 = nil
+        end
+
+        node_cache[:verbatim_type][start_index] = r0
+
+        r0
+      end
+
+      module VerbatimText0
+        def block_end
+          elements[0]
+        end
+
+        def verbatim_type
+          elements[1]
+        end
+
+      end
+
+      module VerbatimText1
+      end
+
+      def _nt_verbatim_text
+        start_index = index
+        if node_cache[:verbatim_text].has_key?(index)
+          cached = node_cache[:verbatim_text][index]
+          if cached
+            cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        s0, i0 = [], index
+        loop do
+          i1, s1 = index, []
+          i2 = index
+          i3, s3 = index, []
+          r4 = _nt_block_end
+          s3 << r4
+          if r4
+            r5 = _nt_verbatim_type
+            s3 << r5
+            if r5
+              if has_terminal?("}", false, index)
+                r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                @index += 1
+              else
+                terminal_parse_failure("}")
+                r6 = nil
+              end
+              s3 << r6
+            end
+          end
+          if s3.last
+            r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+            r3.extend(VerbatimText0)
+          else
+            @index = i3
+            r3 = nil
+          end
+          if r3
+            r2 = nil
+          else
+            @index = i2
+            r2 = instantiate_node(SyntaxNode,input, index...index)
+          end
+          s1 << r2
+          if r2
+            if index < input_length
+              r7 = instantiate_node(SyntaxNode,input, index...(index + 1))
+              @index += 1
+            else
+              terminal_parse_failure("any character")
+              r7 = nil
+            end
+            s1 << r7
+          end
+          if s1.last
+            r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+            r1.extend(VerbatimText1)
+          else
+            @index = i1
+            r1 = nil
+          end
+          if r1
+            s0 << r1
+          else
+            break
+          end
+        end
+        if s0.empty?
+          @index = i0
+          r0 = nil
+        else
+          r0 = instantiate_node(TextNode,input, i0...index, s0)
+        end
+
+        node_cache[:verbatim_text][start_index] = r0
+
+        r0
+      end
+
+    end
+
+    class VerbatimParser < Treetop::Runtime::CompiledParser
+      include Verbatim
+    end
+
+  end
+end

data/lib/hemingway/block/verbatim/verbatim.treetop

@@ -0,0 +1,21 @@
+require "hemingway/block/verbatim/verbatim_nodes"
+
+module Hemingway
+  module Block
+    grammar Verbatim
+
+      rule verbatim
+        verbatim_text
+      end
+
+      rule verbatim_type
+        "verbatim" <VerbatimNode>
+      end
+
+      rule verbatim_text
+        ( !( block_end verbatim_type "}" ) . )+ <TextNode>
+      end
+
+    end
+  end
+end

data/lib/hemingway/block/verbatim/verbatim_nodes.rb

@@ -0,0 +1,9 @@
+module Hemingway
+
+  module VerbatimNode
+    def html(block_content)
+      Build.tag("pre", block_content.html)
+    end
+  end
+
+end

data/lib/hemingway/build.rb

@@ -0,0 +1,65 @@
+module Hemingway
+
+  # This is a moronic little class to generate some HTML Tags around
+  # some content.
+  class Build
+    def self.tag(html_attribute, html_content=nil, options={})
+      String.new.tap do |t|
+        t << "<" + html_attribute
+        t << " id='" + options[:id] + "'" if options[:id]
+        t << " class='" + options[:class] + "'" if options[:class]
+        t << " href='" + options[:href] + "'" if options[:href]
+        t << ">"
+        t << html_content if html_content
+        t << "</" + html_attribute + ">" unless options[:close_tag] == false
+      end
+    end
+
+    def self.symbol(symbol)
+      latex_sym_to_html[symbol]
+    end
+
+    private
+    def self.latex_sym_to_html
+      {
+        "\\Gamma" =>  "&Gamma;",
+        "\\Delta" =>  "&Delta;",
+        "\\Theta" =>  "&Theta;",
+        "\\Lambda" =>  "&Lambda;",
+        "\\Xi" =>  "&Xi;",
+        "\\Pi" =>  "&Pi;",
+        "\\Sigma" =>  "&Sigma;",
+        "\\Upsilon" =>  "&Upsilon;",
+        "\\Phi" =>  "&Phi;",
+        "\\Psi" =>  "&Psi;",
+        "\\Omega" =>  "&Omega;",
+        "\\alpha" =>  "&alpha;",
+        "\\beta" =>  "&beta;",
+        "\\gamma" =>  "&gamma;",
+        "\\delta" =>  "&delta;",
+        "\\epsilon" =>  "&epsilon;",
+        "\\zeta" =>  "&zeta;",
+        "\\eta" =>  "&eta;",
+        "\\theta" =>  "&theta;",
+        "\\iota" =>  "&iota;",
+        "\\kappa" =>  "&kappa;",
+        "\\lambda" =>  "&lambda;",
+        "\\mu" =>  "&mu;",
+        "\\nu" =>  "&nu;",
+        "\\xi" =>  "&xi;",
+        "\\pi" =>  "&pi;",
+        "\\rho" =>  "&rho;",
+        "\\varsigma" =>  "&sigmaf;",
+        "\\sigma" =>  "&sigma;",
+        "\\tau" =>  "&tau;",
+        "\\upsilon" =>  "&upsilon;",
+        "\\phi" =>  "&phi;",
+        "\\chi" =>  "&chi;",
+        "\\psi" =>  "&psi;",
+        "\\omega" =>  "&omega;"
+      }
+    end
+
+  end
+
+end

data/lib/hemingway/footnote/footnote.rb

@@ -0,0 +1,83 @@
+# Autogenerated from a Treetop grammar. Edits may be lost.
+
+
+require "hemingway/footnote/footnote_nodes"
+
+module Hemingway
+  module Footnote
+    include Treetop::Runtime
+
+    def root
+      @root ||= :footnote
+    end
+
+    module Footnote0
+      def sequence
+        elements[1]
+      end
+
+    end
+
+    def _nt_footnote
+      start_index = index
+      if node_cache[:footnote].has_key?(index)
+        cached = node_cache[:footnote][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+
+      i0, s0 = index, []
+      if has_terminal?("\\footnote{", false, index)
+        r1 = instantiate_node(SyntaxNode,input, index...(index + 10))
+        @index += 10
+      else
+        terminal_parse_failure("\\footnote{")
+        r1 = nil
+      end
+      s0 << r1
+      if r1
+        s2, i2 = [], index
+        loop do
+          r3 = _nt_content
+          if r3
+            s2 << r3
+          else
+            break
+          end
+        end
+        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+        s0 << r2
+        if r2
+          if has_terminal?("}", false, index)
+            r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
+            @index += 1
+          else
+            terminal_parse_failure("}")
+            r4 = nil
+          end
+          s0 << r4
+        end
+      end
+      if s0.last
+        r0 = instantiate_node(FootnoteNode,input, i0...index, s0)
+        r0.extend(Footnote0)
+      else
+        @index = i0
+        r0 = nil
+      end
+
+      node_cache[:footnote][start_index] = r0
+
+      r0
+    end
+
+  end
+
+  class FootnoteParser < Treetop::Runtime::CompiledParser
+    include Footnote
+  end
+
+end

data/lib/hemingway/footnote/footnote.treetop

@@ -0,0 +1,11 @@
+require "hemingway/footnote/footnote_nodes"
+
+module Hemingway
+  grammar Footnote
+
+    rule footnote
+      "\\footnote{" sequence:content* "}" <FootnoteNode>
+    end
+
+  end
+end

data/lib/hemingway/footnote/footnote_nodes.rb

@@ -0,0 +1,21 @@
+module Hemingway
+  module FootnoteNode
+    # This is the method that will place the anchor tag and id of the 
+    # footnote within the paragraph body itself. 
+    def html(id)
+      inline_footnote_label = Build.tag("span", Build.tag("sup", id.to_s), :class => "inline-footnote-number")
+      Build.tag("a", inline_footnote_label, :href => "#footnote#{id}")
+    end
+
+    # This is the method that will actually spit out the div that the 
+    # footnote's content is in. This will generally be called after all of the 
+    # paragraph's text has been spit out so that the footnotes can be appended
+    # after. Note that it needs to be passed an id from the caller so that it 
+    # can be linked to corretly with an anchor tag in the body of the main text. 
+    def footnote_html(id)
+      footnote_label = Build.tag("span", Build.tag("sup", id.to_s), :class => "footnote-number")
+      footnote_content = sequence.elements.map { |s| s.html }.join
+      Build.tag("div", footnote_label + footnote_content, :id => "footnote#{id}", :class => "footnote")
+    end
+  end
+end