hparser 0.3.0 → 0.4.0

data/lib/hparser/latex.rb

@@ -0,0 +1,273 @@
+# Author:: Masayoshi Tajahashi (takahashimm@gmail.com)
+# Copyright:: Copyright (c) 2010 Masayoshi Takahashi
+# License::   Distributes under the same terms as Ruby
+# This file define +to_latex+. +to_latex+ is convert hatena format to LaTeX.
+#
+
+module HParser
+  # This module provide +to_latex+ method.
+  # This method is intended to convert hatena format to LaTeX format.
+  #
+  # For example:
+  #  Hatena::Parser.parse('*foo').to_latex # -> \section{foo}
+  #  Hatena::Parser.parse('>|bar|<').to_latex # -> \begin{verbatim} <\n> bar <\n> \end{verbatim}
+  #
+  # Unlike html, LaTeX phrase cannot be separated with tag and conent.
+  # so common methods, such like tag_name and html_content, are not always used.
+  # Only to_latex method is commonly impletemted.
+  # If content is +Arary+,each elements convert to LaTeX by
+  # +to_latex+. Otherwise,using as it self.
+  #
+  module Latex
+    def to_latex
+      content = latex_content
+      if content.class == Array then
+        content = content.map{|x| x.to_latex}.join
+      end
+      content
+    end
+  end
+
+  module Block
+    class Head
+      include Latex
+
+      def to_latex
+        content = super
+        headers = [
+                   nil,
+                   "section",
+                   "subsection",
+                   "subsubsection",
+                   "paragraph",
+                   "subparagraph",
+                   "textbf"
+                  ]
+        level = @@head_level + self.level - 1
+        "\\#{headers[level]}{#{content}}\n\n"
+      end
+
+      @@head_level = 1
+      def self.head_level=(l)
+        @@head_level = l
+      end
+      def self.head_level
+        @@head_level
+      end
+
+      alias_method :latex_content,:content
+    end
+
+    class P
+      include Latex
+
+      def to_latex
+        content = super
+        content += "\n\n"
+        content
+      end
+
+      alias_method :latex_content, :content
+    end
+
+    class Empty
+      def to_latex() "\n\n" end
+    end
+
+    class SeeMore
+      def to_latex() '' end
+    end
+
+    class Pre
+      include Latex
+
+      def to_latex
+        content = super
+        %Q[\\begin{verbatim}\n#{content}\n\\end{verbatim}\n]
+      end
+
+      alias_method :latex_content, :content
+    end
+
+    class SuperPre
+      include Latex
+
+      def to_latex
+        content = latex_content  ## not 'super'
+        %Q[\\begin{verbatim}\n#{content}\n\\end{verbatim}\n]
+      end
+
+      alias_method :latex_content,:content
+    end
+
+    class Quote
+      include Latex
+
+      def to_latex
+        content = super
+        %Q[\\begin{quotation}\n#{content}\n\\end{quotation}\n]
+      end
+
+      def latex_content
+        @items
+      end
+    end
+
+    class Table
+      def to_latex
+        row_size = self.row_size
+
+        output  = "\\begin{table}\n"
+        output << "  \\centering\n"
+        output << "  \\begin{tabular}{ #{"l " * row_size }}\n"
+        self.map_row do |row|
+          output << "    #{row.map{|cell| cell.to_latex }.join(" & ")} \\\\\n"
+        end
+        output << "  \\end{tabular}\n"
+        output << "\\end{table}\n"
+        output
+      end
+
+      def row_size
+        self.map_row do |tr|
+          return tr.size
+        end
+      end
+    end
+
+    class Dl
+      include Latex
+
+      class Item
+        def to_latex
+          dt = self.title.map{|x| x.to_latex}.join
+          dd = self.description.map{|x| x.to_latex}.join
+
+          %Q(\\item[#{dt}] \\quad \\\\\n#{dd}\n)
+        end
+      end
+
+      def to_latex
+        content = super
+        %Q[\\begin{description}\n#{content}\n\\end{description}\n]
+      end
+
+      def latex_content
+        @items
+      end
+    end
+
+    class TableHeader
+      include Latex
+
+      def to_latex
+        content = super
+        content
+      end
+
+      alias_method :latex_content,:content
+    end
+
+    class TableCell
+      include Latex
+
+      def to_latex
+        content = super
+        content
+      end
+
+      alias_method :latex_content,:content
+    end
+
+    class UnorderList
+      include Latex
+
+      def to_latex
+        content = super
+        %Q[\\begin{itemize}\n#{items.map{|i| i.to_latex }.join("\n")}\n\\end{itemize}\n]
+      end
+      alias_method :latex_content,:items
+    end
+
+    class OrderList
+      include Latex
+
+      def to_latex
+        content = super
+        %Q[\\begin{enumerate}\n#{items.map{|i| i.to_latex }.join("\n")}\n\\end{enumerate}\n]
+      end
+
+      alias_method :latex_content,:items
+    end
+
+
+    class ListItem
+      include Latex
+
+      def to_latex
+        content = super
+        "  \\item #{content}\n"
+      end
+
+      alias_method :latex_content,:content
+    end
+
+    class RAW
+      def to_latex
+        @content.map {|i| i.to_latex }.join
+      end
+    end
+
+    class FoonoteList
+      def to_latex
+        ""
+      end
+    end
+  end
+
+  module Inline
+    class Text
+      def to_latex
+        self.text
+      end
+    end
+
+    class Url
+      def to_latex
+        "\\href{#{self.url}/}{#{self.url}}"
+      end
+    end
+
+    class HatenaId
+      def to_latex
+        "\\href{http://d.hatena.ne.jp/#{self.name}/}{id:#{self.name}}"
+      end
+    end
+
+    class Fotolife
+      def to_latex
+        alias_method :to_latex,:url
+      end
+    end
+
+    class Tex
+      def to_latex
+        %($#{self.text}$)
+      end
+    end
+
+    class Footnote
+      def to_latex
+        %(\\footnote{#{self.text}})
+      end
+    end
+
+    class Comment
+      def to_latex
+        ""
+      end
+    end
+  end
+end
+
+

data/lib/hparser/parser.rb

@@ -4,6 +4,7 @@
 
 require 'hparser/util/parser'
 require 'hparser/inline/parser'
+require 'hparser/inline/footnote'
 require 'hparser/block/collectable'
 require 'hparser/util/line_scanner'
 
@@ -42,9 +43,14 @@ module HParser
     #
     # Return array of block element.
     def parse str
-      @blocks.parse(LineScanner.new(str.split("\n")),@inlines).map{|x|
+      context = Context.new
+      res = (@blocks.parse(LineScanner.new(str.split(/\r\n|\r|\n/)),context,@inlines) || []).map{|x|
         x[0]
       }
+      if context.footnotes.length > 0
+        res << FootnoteList.new(context.footnotes)
+      end
+      res
     end
 
     # Retutrn array of all usable parser.
@@ -66,5 +72,15 @@ module HParser
       }
     end
   end
+
+  # Parse context.
+  #
+  # Context instance is passed to all parsers.
+  class Context
+    attr_reader :footnotes
+    def initialize(footnotes=[])
+      @footnotes = footnotes
+    end
+  end
 end
 

data/lib/hparser/text.rb

@@ -39,6 +39,10 @@ module HParser
       end
     end
 
+    class SeeMore
+      def to_text() "" end
+    end
+
     module Indent
       include Text
       def text_content
@@ -57,7 +61,11 @@ module HParser
       include Indent
     end
     class Quote
+      include Text
       include Indent
+      def text_content
+        @items
+      end
     end
 
     class Table
@@ -117,6 +125,20 @@ module HParser
         [HParser::Inline::Text.new(' '),self.content].flatten
       end
     end
+
+    class RAW
+      def to_text
+        @content.map {|i| i.to_text }.join
+      end
+    end
+
+    class FootnoteList
+      def to_text
+        @footnotes.map {|f| 
+          %((*#{f.index}) #{f.text})
+        }.join("\n")
+      end
+    end
   end
 
   module Inline
@@ -133,5 +155,25 @@ module HParser
         "id:#{self.name}"
       end
     end
+
+    class Fotolife
+      alias_method :to_text,:url
+    end
+
+    class Tex
+      alias_method :to_text,:text
+    end
+
+    class Footnote
+      def to_text
+        "(*#{self.index})"
+      end
+    end
+
+    class Comment
+      def to_text
+        ""
+      end
+    end
   end
 end

data/lib/hparser/util/line_scanner.rb

@@ -5,12 +5,13 @@ module HParser
   module Util
     # StringScanner like class
     class LineScanner
-      attr_reader :matched
+      attr_reader :matched, :matched_pattern
       def initialize(lines)
         @lines = lines
       end
       
       def scan(exp)
+        @matched_pattern = nil
         if match?(exp) then
           @matched = @lines.shift
         else
@@ -29,7 +30,7 @@ module HParser
       def match?(exp)
         if @lines == [] then
           false
-        elsif exp.class == Regexp and @lines[0] =~ exp then
+        elsif exp.class == Regexp and (@matched_pattern = @lines[0].match(exp)) then
           true
         elsif @lines[0] == exp
           true

data/lib/hparser.rb

@@ -6,3 +6,4 @@ require 'hparser/parser'
 require 'hparser/block/all'
 require 'hparser/inline/all'
 require 'hparser/html'
+require 'hparser/latex'

data/test/integration_texts/error1.ok.hatena

@@ -0,0 +1,23 @@
+- A
+- B
+>||
+A
+B
+||<
+A
+>||
+C
+D
+||<
+- A
+- A
+- A
+- A
+-- A
+-- A
+
+** A
+- A
+
+** A
+- A

data/test/test_block.rb

@@ -1,4 +1,4 @@
-require 'test/unit'
+require 'test_helper'
 require 'hparser/parser'
 require 'hparser/block/list'
 
@@ -61,14 +61,38 @@ END
   end
 
   def test_spre
-    assert_equal [SuperPre.new('a')],parse(<<-END)
+    assert_equal [SuperPre.new(' a ')],parse(<<-END)
 >||
+ a 
+||<
+END
+    assert_equal [SuperPre.new('a')],parse(<<-END), 'with space'
+>|| 
 a
+||< 
+END
+
+  end
+
+  def test_spre_html
+    assert_equal [SuperPre.new('<foo />')],parse(<<-END)
+>||
+<foo />
 ||<
 END
 
   end
 
+  def test_spre_format
+    parsed = parse(<<-END)
+>|xml|
+<foo />
+||<
+END
+    assert_equal [SuperPre.new('<foo />')], parsed
+    assert_equal 'xml', parsed.first.format
+  end
+
   def test_list
     assert_equal [Ul.new(li('a'),Ol.new(li('b')),Ul.new(li('c')))],
                   parse(<<-END)
@@ -78,6 +102,45 @@ END
     END
   end
 
+
+  def test_comment
+    assert_equal [HParser::Block::RAW.new([ Comment.new("\naaa\n") ])], parse(<<-END.unindent)
+    ><!--
+    aaa
+    --><
+    END
+  end
+
+  def test_raw
+    assert_equal [RAW.new([ Text.new("<ins>") ]), P.new([ Text.new("foo") ]), RAW.new([ Text.new("</ins>") ])], parse(<<-END.unindent)
+    ><ins><
+    foo
+    ></ins><
+    END
+  end
+
+  def test_raw_without_end_lt
+    assert_equal [RAW.new([ Text.new("<ins>") ]), P.new([ Text.new("foo") ]), RAW.new([ Text.new("</ins>") ])], parse(<<-END.unindent)
+    ><ins><
+    foo
+    ></ins>
+    END
+  end
+
+  def test_p
+    assert_equal [P.new([ Text.new(" foo") ])], parse(<<END)
+ foo
+END
+
+    str = <<END
+ foo
+ bar
+ buz
+END
+    assert_equal [P.new([ Text.new(" foo")]), P.new([Text.new(" bar") ]), P.new([Text.new(" buz") ])], parse(str)
+  end
+
+
   def li str
     Li.new([Text.new(str)])
   end

data/test/test_bruteforce.rb

@@ -0,0 +1,48 @@
+require 'test_helper'
+require 'hparser/parser'
+require 'hparser/block/list'
+require 'pathname'
+
+class BlockTest < Test::Unit::TestCase
+  include HParser::Block
+  include HParser::Inline
+
+  def setup
+    @parser = HParser::Parser.new
+  end
+
+  def parse str
+    @parser.parse str
+  end
+
+  def test_from_cpan_text_hatena
+    Pathname.glob(Pathname.new(__FILE__).parent + "test_from_perl/*.t").each do |test|
+      data = test.read.gsub(/\r?\n|\r/, "\n")[/__END__\n([\s\S]+)/, 1].split(/^===\s*/)
+      data.each do |d|
+        name, *rest = d.split(/^--- */)
+        rest = rest.inject({}) {|r,i|
+          i.sub!(/^(.*)\n/, "")
+          r.update(Regexp.last_match[1] => i)
+        }
+        next unless rest["text"]
+
+        parsed = nil
+        assert_nothing_raised("#{test.basename}::#{name}\n\n#{rest["text"]}\n") {
+          parsed = @parser.parse(rest["text"])
+        }
+
+        html = nil
+        assert_nothing_raised("to_html") {
+          html = @parser.parse(rest["text"]).map {|i| i.to_html }.join.strip
+        }
+
+        # paranoid test
+        if ENV["TEST_PARANOID"]
+          require "rubygems"
+          require "hpricot"
+          assert_equal Hpricot(rest["html"].strip).to_s, Hpricot(html).to_s
+        end
+      end
+    end
+  end
+end

data/test/test_dl.rb

@@ -1,4 +1,4 @@
-require 'test/unit'
+require 'test_helper'
 require 'hparser/parser'
 require 'hparser/block/dl'
 
@@ -23,4 +23,16 @@ class DlTest < Test::Unit::TestCase
 :bar:bar is ...
                   END
   end
+
+  def test_dl2
+    first = Dl::Item.new([Text.new('<a href="http://example.com/">a</a>')],
+                         [Text.new('b')])
+    assert_equal [Dl.new(first)],
+                 parse(':<a href="http://example.com/">a</a>:b')
+  end
+
+  def test_fake_dl
+    assert_equal [],parse(":this is not dl")
+    assert_equal [],parse(":this is not dl too:")
+  end
 end

data/test/test_footnote.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+require 'hparser/parser'
+require 'hparser/block/p'
+require 'hparser/inline/parser'
+require 'hparser/inline/footnote'
+
+class FootnoteTest < Test::Unit::TestCase
+  include HParser::Inline
+  def setup
+    @parser = Parser.new [Footnote]
+  end
+
+  def parse str
+    @parser.parse str, HParser::Context.new
+  end
+
+  def test_new
+    footnote = Footnote.new(1, "text")
+    assert_equal 1, footnote.index
+    assert_equal "text", footnote.text
+  end
+
+  def test_parse
+    assert_equal [Footnote.new(1, "text")], parse("((text))")
+    assert_equal [Footnote.new(1, "text1"),Footnote.new(2, "text2")], parse("((text1))((text2))")
+    assert_equal [Text.new("((text))")], parse(")((text))(")
+  end
+
+  def test_parse_footnote_list
+    f1 = Footnote.new(1, "text1")
+    f2 = Footnote.new(2, "text2")
+
+    # [ P ([ Footnote(...), Foonote(...) ]),
+    #   FoonoteList([ Footnote(...), Foonote(...) ])
+    # ]
+    elements = HParser::Parser.new.parse("((text1))((text2))")
+
+    assert_equal 2, elements.length
+    assert_equal HParser::Block::P.new([f1, f2]), elements[0]
+    assert_equal HParser::Block::FootnoteList.new([f1, f2]), elements[1]
+  end
+end

data/test/test_fotolife.rb

@@ -0,0 +1,29 @@
+require 'test_helper'
+require 'hparser/inline/parser'
+require 'hparser/inline/fotolife'
+
+class FotolifeTest < Test::Unit::TestCase
+  include HParser::Inline
+  def setup
+    @parser = Parser.new [Fotolife]
+  end
+
+  def parse str
+    @parser.parse str
+  end
+
+  def test_new
+    f = Fotolife.new("nitoyon", "20100718", "010346", "jpg")
+    assert_equal "nitoyon", f.id
+    assert_equal "20100718", f.date
+    assert_equal "010346", f.time
+    assert_equal "jpg", f.ext
+    assert_equal "http://f.hatena.ne.jp/nitoyon/20100718010346", f.url
+    assert_equal "http://f.hatena.ne.jp/images/fotolife/n/nitoyon/20100718/20100718010346.jpg", f.image_url
+  end
+
+  def test_parse
+    assert_equal [Fotolife.new("nitoyon", "20100718", "010346", "jpg")],
+                 parse("[f:id:nitoyon:20100718010346j:image]")
+  end
+end