hparser 0.1.0

data/lib/hparser/inline/url.rb

@@ -0,0 +1,26 @@
+# Author:: MIZUNO Hiroki (hiroki1124@gmail.com)
+# Copyright:: Copyright (c) 2006 MIZUNO Hiroki
+# License::   Distributes under the same terms as Ruby
+
+require 'hparser/inline/collectable'
+module HParser
+  module Inline
+    class Url
+      include Collectable
+      attr_reader :url
+      def self.parse(scanner)
+        if scanner.scan(%r!https?://[A-Za-z0-9./]+!) then
+          Url.new scanner.matched
+        end
+      end
+      
+      def initialize(url)
+        @url = url
+      end
+      
+      def ==(o)
+        self.class and o.class and @url == o.url
+      end
+    end
+  end
+end

data/lib/hparser/parser.rb

@@ -0,0 +1,70 @@
+# Author:: MIZUNO Hiroki (hiroki1124@gmail.com)
+# Copyright:: Copyright (c) 2006 MIZUNO Hiroki
+# License::   Distributes under the same terms as Ruby
+
+require 'hparser/util/parser'
+require 'hparser/inline/parser'
+require 'hparser/block/collectable'
+require 'hparser/util/line_scanner'
+
+module HParser
+  # Block level parser. +hparser+ split hatena format to 2 level.
+  #
+  # High-level is block elements. This can be identified by first char.
+  #
+  # For exapmle:
+  #   * head1
+  #   This is block element.(paragpaph)
+  #   
+  #   - list
+  #   - is also
+  #   -- block element
+  #
+  # Low-level is inline elements. Pleease see HParser::Inline::Parser.
+  class Parser
+    include HParser::Util
+    include HParser::Block
+
+    # Make parser with block parsers and inline parser.
+    #
+    # This parser can parse +blocks+, and parse block content
+    # by +inlines+.
+    #
+    # If argument is not gived, this use default_parser.
+    def initialize(blocks=HParser::Parser.default_parser,
+                   inlines=HParser::Inline::Parser.new)
+      @blocks = Many1.new(Concat.new(Or.new(*blocks),
+                                     Skip.new(Empty)))
+      @inlines = inlines
+    end
+
+    # Parse hatena format.
+    #
+    # Return array of block element.
+    def parse str
+      @blocks.parse(LineScanner.new(str.split("\n")),@inlines).map{|x|
+        x[0]
+      }
+    end
+
+    # Retutrn array of all usable parser.
+    # 
+    # This method collect all classes/modules which include
+    # HParser::Block::Collectable. And sorting those by <=>. 
+    def self.default_parser
+      parser = []
+      ObjectSpace.each_object(Class){|klass|
+        if klass.include?(HParser::Block::Collectable) then
+          parser.push klass
+        end
+      }
+
+      # sorting parser.
+      # e.g. Parser P should be after any other parser.
+      parser.sort{|a,b|
+        a <=> b or -(b <=> a).to_i
+      }
+    end
+  end
+end
+

data/lib/hparser/util/line_scanner.rb

@@ -0,0 +1,43 @@
+# Author:: MIZUNO Hiroki (hiroki1124@gmail.com)
+# Copyright:: Copyright (c) 2006 MIZUNO Hiroki
+# License::   Distributes under the same terms as Ruby
+module HParser
+  module Util
+    # StringScanner like class
+    class LineScanner
+      attr_reader :matched
+      def initialize(lines)
+        @lines = lines
+      end
+      
+      def scan(exp)
+        if match?(exp) then
+          @matched = @lines.shift
+        else
+          nil
+        end
+      end
+      
+      def skip(exp)
+        if match?(exp) then
+          @lines.shift
+        else
+          nil
+        end
+      end
+      
+      def match?(exp)
+        if @lines == [] then
+          false
+        elsif exp.class == Regexp and @lines[0] =~ exp then
+          true
+        elsif @lines[0] == exp
+          true
+        else
+          false
+        end        
+      end
+    end
+  end
+end
+

data/lib/hparser/util/parser.rb

@@ -0,0 +1,74 @@
+module HParser
+  module Util
+    class Many1
+      def initialize(parser)
+        @parser = parser
+      end
+      
+      def parse(*args)
+        result = []
+        while (r = @parser.parse(*args))
+          result.push r
+        end
+        result==[] ? nil : result
+      end
+    end
+
+    class Skip
+      def initialize(parser)
+        @parser = parser
+      end
+
+      def parse(*args)
+        @parser.parse(*args)
+        true
+      end
+    end
+
+    class Concat
+      def initialize(*parsers)
+        @parsers = parsers
+      end
+      
+      def parse(*args)
+        result = []
+        for parser in @parsers
+          r = parser.parse(*args)
+          unless r then
+            return nil
+          end
+          result.push r
+        end
+        result
+      end
+    end
+
+    class Or
+      def initialize(*parsers)
+        @parsers = parsers
+      end
+      
+      def parse(*args)
+        r = nil
+        for parser in @parsers
+          r = parser.parse(*args)
+          if r then
+            break
+          end
+        end
+        r
+      end
+    end
+    
+    class ProcParser
+      def initialize(&proc)
+        @proc = proc
+      end
+      
+      def parse(*args)
+        @proc.call(*args)
+      end
+    end
+  end
+end
+

data/lib/hparser.rb

@@ -0,0 +1,8 @@
+# Author:: MIZUNO Hiroki (hiroki1124@gmail.com)
+# Copyright:: Copyright (c) 2006 MIZUNO Hiroki
+# License::   Distributes under the same terms as Ruby
+
+require 'hparser/parser'
+require 'hparser/block/all'
+require 'hparser/inline/all'
+require 'hparser/html'

data/test/test_block.rb

@@ -0,0 +1,75 @@
+require 'test/unit'
+require 'hparser/parser'
+require 'hparser/block/list'
+
+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_extra_empty
+    assert_equal [Ul.new(li('a')),P.new([Text.new('b')])],parse(<<-END)
+-a
+
+b
+END
+
+    assert_equal [Head.new(1,[Text.new('a')]),P.new([Text.new('b')])],parse(<<-END)
+*a
+
+b
+END
+  end
+
+  def test_ul
+    assert_equal [Ul.new(li('a'),li('b'),li('c'))],
+                  parse(<<-END)
+- a
+- b
+- c
+    END
+
+    assert_equal [Ul.new(li('a'),Ul.new(li('b')),li('c'))],
+                  parse(<<-END)
+- a
+-- b
+- c
+    END
+  end
+
+  def test_ol
+    assert_equal [Ol.new(li('a'),li('b'),li('c'))],
+                  parse(<<-END)
++ a
++ b
++ c
+    END
+
+    assert_equal [Ol.new(li('a'),Ol.new(li('b')),li('c'))],
+                  parse(<<-END)
++ a
+++ b
++ c
+    END
+  end
+
+  def test_list
+    assert_equal [Ul.new(li('a'),Ol.new(li('b')),Ul.new(li('c')))],
+                  parse(<<-END)
+- a
+++ b
+-- c
+    END
+  end
+
+  def li str
+    Li.new([Text.new(str)])
+  end
+end

data/test/test_head.rb

@@ -0,0 +1,34 @@
+require 'test/unit'
+require 'hparser/parser'
+require 'hparser/block/head'
+require 'hparser/inline/text'
+class HeadTest < Test::Unit::TestCase
+  include HParser::Block
+  include HParser::Inline
+
+  def setup
+    @parser = HParser::Parser.new [Head]
+  end
+
+  def parse str
+    @parser.parse str
+  end
+
+  def test_head
+    assert_equal [head(1,"aaa")],parse("*aaa")
+    assert_equal [head(2,"aaa")], parse("**aaa")
+    assert_equal [head(3,"aaa")], parse("***aaa")
+  end
+
+  def test_strip_space
+    assert_equal [head(1,"aaa")],parse("*  aaa         ")
+  end
+
+  def test_long
+    assert_equal [head(100,"aaa")],parse("#{'*'*100}aaa")
+  end
+
+  def head level,str
+    Head.new level,[Text.new(str)]
+  end
+end

data/test/test_html.rb

@@ -0,0 +1,54 @@
+require 'test/unit'
+require 'hparser/block/all'
+require 'hparser/inline/all'
+require 'hparser/html'
+
+class HtmlTest < Test::Unit::TestCase
+  include HParser::Block
+  include HParser::Inline
+  def setup
+    @parser = HParser::Parser.new
+  end
+  def assert_html expect,node
+    assert_equal expect,node.to_html
+  end
+
+  def test_head
+    assert_html '<h1>foo</h1>',Head.new(1,[Text.new('foo')])
+  end
+
+  def test_p
+    assert_html '<p>foobar</p>',P.new([Text.new('foobar')])
+    assert_html '<p><br /></p>',Empty.new
+  end
+
+  def test_pre
+    assert_html '<pre>foobar</pre>',Pre.new([Text.new('foobar')])
+    assert_html '<pre>foobar</pre>',SuperPre.new('foobar')
+  end
+
+  def test_quote
+    assert_html '<blockquote>foobar</blockquote>',Quote.new([Text.new('foobar')])
+  end
+
+  def test_table
+    assert_html '<table><tr><th>foo</th><th>bar</th></tr><tr><td>baz</td><td>xyzzy</td></tr></table>',
+                Table.new([th('foo'),th('bar')],
+                          [td('baz') ,td('xyzzy')])
+  end
+
+  def test_list
+    assert_html '<ul><li>aaa</li><li>bbb</li></ul>',Ul.new(Li.new([Text.new('aaa')]),Li.new([Text.new('bbb')]))
+    assert_html '<ol><li>aaa</li><li>bbb</li></ol>',Ol.new(Li.new([Text.new('aaa')]),Li.new([Text.new('bbb')]))
+    assert_html '<ol><ul><li>aaa</li></ul><li>bbb</li></ol>',Ol.new(Ul.new(Li.new([Text.new('aaa')])),
+                                                                    Li.new([Text.new('bbb')]))
+  end
+
+  def th str
+    Th.new [Text.new(str)]
+  end
+
+  def td str
+    Td.new [Text.new(str)]
+  end
+end

data/test/test_id.rb

@@ -0,0 +1,22 @@
+require 'test/unit'
+require 'hparser/inline/hatena_id'
+require 'hparser/inline/parser'
+
+class IdTest < Test::Unit::TestCase
+  include HParser::Inline
+  def setup
+    @parser = Parser.new HatenaId
+  end
+
+  def parse str
+    @parser.parse str
+  end
+
+  def test_id
+    assert_equal [HatenaId.new("mzp")],parse("id:mzp")
+  end
+
+  def test_jp
+#    assert_equal [HatenaId.new("mzp"),Text.new("は")],parse("id:mzpは")
+  end
+end

data/test/test_inline.rb

@@ -0,0 +1,20 @@
+require 'test/unit'
+require 'hparser/inline/url'
+require 'hparser/inline/text'
+require 'hparser/inline/hatena_id'
+require 'hparser/inline/parser'
+
+class InlineTest < Test::Unit::TestCase
+  include HParser::Inline
+  def setup
+    @inline = Parser.new
+  end
+
+  def parse str
+    @inline.parse str
+  end
+
+  def test_text
+    assert_equal [Text.new("foo is bar")],parse("foo is bar")
+  end
+end

data/test/test_inline_html.rb

@@ -0,0 +1,34 @@
+require 'test/unit'
+require 'hparser/inline/all'
+require 'hparser/html'
+
+class HtmlInlineTest < Test::Unit::TestCase
+  include HParser::Inline
+  def setup
+    @parser = Parser.new
+  end
+
+  def assert_html expect,str
+    expect.class == String and (expect = [expect])
+
+    assert_equal expect,@parser.parse(str).map{|x| x.to_html}
+  end
+
+  def assert_same str
+    assert_html [str],str
+  end
+
+  def test_text
+    assert_same 'foo is bar'
+    assert_same '<a href="http://mzp.sakura.ne.jp">link!</a>'
+  end
+
+  def test_id
+    assert_html '<a href="http://d.hatena.ne.jp/mzp/">id:mzp</a>','id:mzp'
+  end
+
+  def test_url
+    assert_html '<a href="http://mzp.sakura.ne.jp">http://mzp.sakura.ne.jp</a>',
+                'http://mzp.sakura.ne.jp'
+  end
+end

data/test/test_p.rb

@@ -0,0 +1,54 @@
+require 'test/unit'
+require 'hparser/parser'
+require 'hparser/block/p'
+
+class PTest < Test::Unit::TestCase
+  include HParser::Block
+  include HParser::Inline
+
+  def setup
+    @parser = HParser::Parser.new [Empty,P]
+  end
+
+  def parse str
+    @parser.parse str
+  end
+
+  def test_normal
+    assert_equal [p("aaa")], parse("aaa")
+  end
+
+  def test_has_blank
+    assert_equal [p("aaa")], parse(<<-END)
+aaa
+
+    END
+  end
+
+  def test_multi_line
+    assert_equal [p('aaa'),p('bbb')], parse(<<-END)
+aaa
+bbb
+    END
+
+    assert_equal [p("aaa"),p('bbb')], parse(<<-END)
+aaa
+
+bbb
+    END
+  end
+
+  def test_empty
+    assert_equal [p("aaa"),Empty.new,p('bbb')],
+                  parse(<<-END)
+aaa
+
+
+bbb
+    END
+  end
+
+  def p str
+    P.new([Text.new(str)])
+  end
+end

data/test/test_pair.rb

@@ -0,0 +1,34 @@
+require 'test/unit'
+require 'hparser/parser'
+require 'hparser/block/quote'
+require 'hparser/block/pre'
+require 'hparser/block/super_pre'
+class QuoteTest < Test::Unit::TestCase
+  include HParser::Block
+  include HParser::Inline
+
+  def setup
+    @parser = HParser::Parser.new [SuperPre,Pre,Quote]
+  end
+
+  def parse str
+    @parser.parse str
+  end
+
+  def assert_pair(from,to,klass)
+    assert_equal [klass.new([Text.new("aaa")])], parse("#{from}aaa#{to}")
+    assert_equal [klass.new([Text.new("aaa")])], parse("#{from}\naaa\n#{to}")
+  end
+
+  def test_quote
+    assert_pair ">>","<<",Quote
+  end
+
+  def test_pre
+    assert_pair ">|","|<",Pre
+  end
+  
+  def test_spre
+    assert_pair ">||","||<",SuperPre
+  end  
+end

data/test/test_table.rb

@@ -0,0 +1,40 @@
+require 'test/unit'
+require 'hparser/parser'
+require 'hparser/block/table'
+require 'hparser/block/p'
+
+class TableTest < Test::Unit::TestCase
+  include HParser::Block
+  include HParser::Inline
+
+  def setup
+    @parser = HParser::Parser.new [Table,P]
+  end
+
+  def parse str
+    @parser.parse str
+  end
+
+  def test_table
+    assert_equal [Table.new([th('name'),th('desc')       ],
+                            [td('foo') ,td('foo is ....')],
+                            [td('bar') ,td('bar is ....')])],
+                  parse(<<-END)
+|*name|*desc      |
+|foo  |foo is ....|
+|bar  |bar is ....|
+    END
+  end
+
+  def th str
+    Th.new [Text.new(str)]
+  end
+
+  def td str
+    Td.new [Text.new(str)]
+  end
+
+  def test_p
+    assert_equal [P.new([Text.new("a|aa")])], parse("a|aa")
+  end
+end

data/test/test_url.rb

@@ -0,0 +1,34 @@
+require 'test/unit'
+require 'hparser/inline/parser'
+require 'hparser/inline/url'
+
+class UrlTest < Test::Unit::TestCase
+  include HParser::Inline
+  def setup
+    @parser = Parser.new [Url,Text]
+  end
+
+  def parse str
+    @parser.parse str
+  end
+
+  def test_http
+    assert_equal [Url.new("http://example.com")],parse("http://example.com")
+  end
+
+  def test_text
+    assert_equal [Text.new("<em>"),Url.new("http://example.com"),Text.new("</em>")],
+                 parse("<em>http://example.com</em>")
+
+    assert_equal [Url.new("http://foo.com"),Text.new(" is dummy")],
+                 parse("http://foo.com is dummy")
+  end
+
+  def test_a
+    assert_equal [Text.new("<a>http://example.com</a>")],parse("<a>http://example.com</a>")
+  end
+
+  def test_https
+    assert_equal [Url.new("https://example.com")],parse("https://example.com")
+  end
+end