hparser 0.1.0

data/README

@@ -0,0 +1,17 @@
+=Hatena Format Parser
+==OverReview
++hparser+ is hatena format parser. This format is used at hatena diary(http://d.hatena.ne.jp/)
+If you want to know more detail about hatena format, please see http://hatenadiary.g.hatena.ne.jp/keyword/%e3%81%af%e3%81%a6%e3%81%aa%e8%a8%98%e6%b3%95%e4%b8%80%e8%a6%a7
+
++hpaser+ is constructed with some little parser.(e.g. header parser,list parser,and ...)
+So,+hparser+ can be added new format,or removed unused format.
+
+==Basic usage
+To parse hatena format,please use Hatena::Parser.
+
+ require 'hatena/parser'
+ require 'hatena/block/all'
+ require 'hatena/inline/all'
+ 
+ parser = Hatena::Parser.new
+ puts parser.parse(some_text)

data/lib/hparser/block/all.rb

@@ -0,0 +1 @@
+Dir[File.dirname(__FILE__)+'/*.rb'].each{|x| require x}

data/lib/hparser/block/collectable.rb

@@ -0,0 +1,7 @@
+module HParser
+  module Block
+    # This is marker for Hatena::Parser.default_parser.
+    module Collectable
+    end
+  end
+end

data/lib/hparser/block/head.rb

@@ -0,0 +1,45 @@
+# Author:: MIZUNO Hiroki (hiroki1124@gmail.com)
+# Copyright:: Copyright (c) 2006 MIZUNO Hiroki
+# License::   Distributes under the same terms as Ruby
+
+require 'hparser/block/collectable'
+module HParser
+  module Block
+    # Header parser.
+    #
+    # Header is defiend as "a line which is start with '*'". 
+    # And a number of '*' show that level.
+    #
+    # For example:
+    #  * level1
+    #  ** level2
+    #  *** level3
+    class Head
+      include Collectable
+      def self.parse(scanner,inlines)
+        if scanner.scan(/\A\*/) then
+          level = 0
+          scanner.matched.each_byte{|c|
+            if c.chr == '*' then
+              level += 1
+            else
+              break
+            end
+          }
+          Head.new level,inlines.parse(scanner.matched[level..-1].strip)
+        end
+      end
+      
+      attr_reader :level,:content
+      def initialize(level,content)
+        @level = level
+        @content = content
+      end
+      
+      def ==(o)
+        o.class == self.class and o.level == self.level and
+          o.content == self.content
+      end
+    end
+  end
+end

data/lib/hparser/block/list.rb

@@ -0,0 +1,101 @@
+# Author:: MIZUNO Hiroki (hiroki1124@gmail.com)
+# Copyright:: Copyright (c) 2006 MIZUNO Hiroki
+# License::   Distributes under the same terms as Ruby
+# This code should be rewrite.
+# Ul and Ol is depend each other.
+
+require 'hparser/block/collectable'
+require 'hparser/util/parser'
+module HParser
+  module Block
+    include HParser::Util
+    def self.make_list_parser(level,mark,&proc)
+      ProcParser.new{|scanner,inlines|
+        if level == 3 then
+          parser = Many1.new(Li.make_parser(level,mark))
+        else
+          parser = Many1.new(Or.new(UnorderList.make_parser(level+1),
+                                    OrderList.make_parser(level+1),
+                                    Li.make_parser(level,mark)))
+        end
+        list = parser.parse(scanner,inlines)
+        
+        if list then
+          proc.call list
+        end
+      }
+    end
+
+    # This class undocumented.
+    # Maybe rewrite in near future.
+    class UnorderList
+      include Collectable
+      def self.parse(scanner,inlines)
+        Ul.make_parser(1).parse(scanner,inlines)
+      end
+      
+      def self.make_parser(level)
+        Block.make_list_parser(level,'-'){|x| Ul.new(*x)}
+      end
+      
+      attr_reader :items
+      def initialize(*items)
+        @items = items
+      end
+      
+      def ==(o)
+        o.class == self.class and o.items == self.items
+      end
+    end
+
+    # This class undocumented.
+    # Maybe rewrite in near future.    
+    class OrderList
+      include Collectable
+      def self.parse(scanner,inlines)
+        Ol.make_parser(1).parse(scanner,inlines)
+      end
+      
+      def self.make_parser(level)
+        Block.make_list_parser(level,'+'){|x| Ol.new(*x) }
+      end
+      
+      attr_reader :items
+      def initialize(*items)
+        @items = items
+      end
+      
+      def ==(o)
+        o.class == self.class and o.items == self.items
+      end
+    end
+    
+    # This class undocumented.
+    # Maybe rewrite in near future.
+    class ListItem
+      def self.make_parser(level,mark)
+        include HParser::Util
+        ProcParser.new{|scanner,inlines|
+          if scanner.scan(/\A#{Regexp.quote mark*level}.*/) then
+            ListItem.new inlines.parse(scanner.matched[level..-1].strip)
+          end
+        }
+      end
+      
+      attr_reader :content
+      def initialize(content)
+        @content = content
+      end
+      
+      def ==(o)
+        o.class==self.class and o.content == self.content
+      end
+    end
+    
+    unless defined?(Ul)
+      Ul = UnorderList
+      Ol = OrderList
+      Li = ListItem
+    end
+  end
+end

data/lib/hparser/block/p.rb

@@ -0,0 +1,59 @@
+# Author:: MIZUNO Hiroki (hiroki1124@gmail.com)
+# Copyright:: Copyright (c) 2006 MIZUNO Hiroki
+# License::   Distributes under the same terms as Ruby
+
+require 'hparser/block/collectable'
+module HParser
+  module Block
+    # Blank line parser. This parser should be use with HParser::Block::P.
+    # 
+    # This parser can parse blank line.
+    #
+    # For example:
+    #  aaaa
+    #  <blank>
+    #  <blonk>
+    #
+    # First line and second line is parsed with HParser::Block::P. And
+    # third line is parsed with HParser::Block::Empty.
+    class Empty
+      include Collectable
+      def self.parse(scanner,inlines)
+        if scanner.scan('') then
+          Empty.new
+        end
+      end
+      
+      def ==(o)
+        o.class == self.class
+      end
+    end
+    
+    # Normal line parser.
+    #
+    # At hatena format, a line which is not parsed by any other parser is
+    # paragraph.
+    class P
+      include Collectable
+      attr_reader :content
+      def self.parse(scanner,inlines)
+        if scanner.scan(/./) then
+          P.new inlines.parse(scanner.matched)
+        end
+      end
+      
+      def initialize(content)
+        @content = content
+      end
+      
+      def ==(o)
+        self.class == o.class and self.content == o.content
+      end
+
+      def self.<=>(o)
+        # This parser should be last.
+        o.class == P ? nil : 1
+      end
+    end
+  end
+end

data/lib/hparser/block/pair.rb

@@ -0,0 +1,52 @@
+# Author:: MIZUNO Hiroki (hiroki1124@gmail.com)
+# Copyright:: Copyright (c) 2006 MIZUNO Hiroki
+# License::   Distributes under the same terms as Ruby
+
+require 'hparser/util/parser'
+module HParser
+  module Block
+    # Some formats have common structure.
+    # 
+    # Qutoe is defined as
+    #  >>quoted string<<
+    #
+    # Pre is defiend as
+    #  >|plain text|<
+    #
+    # In short,some format is different in begining/ending string.
+    # So this class have basic structure for that format.
+    class Pair
+      # make parser by begin/end-ing string
+      def self.spliter(from,to)
+        from_q = Regexp.quote from
+        to_q = Regexp.quote to
+
+        module_eval <<-"END"
+        def self.parse(scanner,inlines)
+          if scanner.scan(/\\A#{from_q}(.*)#{to_q}\\Z/) then
+            content = scanner.matched
+            self.new inlines.parse(content[#{from.length}...-#{to.length}].strip)
+          elsif scanner.scan(/\\A#{from_q}/)
+            content = scanner.matched[#{from.length}..-1]
+            until scanner.scan(/#{to_q}\\Z/) do
+              content += "\n"+ scanner.scan(/./)
+            end
+            content += "\n"+scanner.matched[0...-#{to.length}]
+            self.new inlines.parse(content.strip)
+          end
+        end
+        END
+      end
+
+      attr_reader :content
+      def initialize(content)
+        @content = content
+      end
+      
+      def ==(o)
+        self.class == o.class and self.content == o.content
+      end
+    end    
+  end
+end
+

data/lib/hparser/block/pre.rb

@@ -0,0 +1,15 @@
+# Author:: MIZUNO Hiroki (hiroki1124@gmail.com)
+# Copyright:: Copyright (c) 2006 MIZUNO Hiroki
+# License::   Distributes under the same terms as Ruby
+
+require 'hparser/block/collectable'
+require 'hparser/block/pair'
+module HParser
+  module Block
+    # Pre format.
+    class Pre < Pair
+      include Collectable
+      spliter '>|','|<'
+    end
+  end
+end

data/lib/hparser/block/quote.rb

@@ -0,0 +1,11 @@
+require 'hparser/block/pair'
+require 'hparser/block/collectable'
+module HParser
+  module Block
+    # Quote parser.
+    class Quote < Pair
+      include Collectable
+      spliter '>>','<<'
+    end
+  end
+end

data/lib/hparser/block/super_pre.rb

@@ -0,0 +1,19 @@
+require 'hparser/block/pair'
+require 'hparser/block/collectable'
+module HParser
+  module Block
+    # Super pre parser.
+    class SuperPre < Pair
+      include Collectable
+      spliter '>||','||<'
+
+      def self.<=>(o)
+        if Block.const_defined?(:Pre) and o == Pre then
+          1
+        else
+          -1
+        end
+      end
+    end
+  end
+end

data/lib/hparser/block/table.rb

@@ -0,0 +1,71 @@
+# Author:: MIZUNO Hiroki (hiroki1124@gmail.com)
+# Copyright:: Copyright (c) 2006 MIZUNO Hiroki
+# License::   Distributes under the same terms as Ruby
+
+require 'hparser/block/collectable'
+module HParser
+  module Block
+    # Table parser.
+    class Table
+      attr_reader :rows
+      include Collectable
+      def self.parse(scanner,inlines)
+        rows = []
+        while scanner.scan(/\A\|/)
+          rows.push scanner.matched[1..-1].split('|').map{|label|
+            if label[0].chr == '*' then
+              Th.new inlines.parse(label[1..-1].strip)
+            else
+              Td.new inlines.parse(label.strip)
+            end
+          }
+        end
+        rows == [] ? nil : Table.new(*rows)
+      end
+      
+      def initialize(*rows)
+        @rows = rows
+      end
+      
+      def ==(o)
+        o.class == self.class and o.rows == self.rows
+      end
+
+      def map_row(&f) # :yield: tr
+        @rows.map(&f)
+      end
+
+      def each_row(&f) # :yield: tr
+        @row.each(&f)
+      end
+    end
+    
+    class TableHeader
+      attr_reader :content
+      def initialize(content)
+        @content = content
+      end
+        
+      def ==(o)
+        o.class == self.class and o.content == self.content
+      end
+    end
+    
+    class TableCell
+      attr_reader :content
+      def initialize(content)
+        @content = content
+      end
+      
+      def ==(o)
+        o.class == self.class and o.content == self.content
+      end
+    end
+    
+    unless defined?(Th)
+      Th = TableHeader
+      Td = TableCell
+    end
+  end
+end
+

data/lib/hparser/html.rb

@@ -0,0 +1,144 @@
+# Author:: MIZUNO Hiroki (hiroki1124@gmail.com)
+# Copyright:: Copyright (c) 2006 MIZUNO Hiroki
+# License::   Distributes under the same terms as Ruby
+# This file define +to_html+. +to_html+ is convert hatena format to html.
+#
+
+module HParser
+  # This module provide +to_html+ method.
+  # This method is intended to convert  hatena format to html format.
+  #
+  # For example:
+  #  Hatena::Parser.parse('*foo').to_html # -> <h1>foo</h1>
+  #  Hatena::Parser.parse('>|bar|<').to_html # -> <pre>bar</pre>
+  #
+  # A class including this module shold implement 2 methods,+html_tag+ and 
+  # +html_content+. Obviously,+html_tag+ provid using html tag name. 
+  # +html_content+ is provid that content.
+  # If content is +Arary+,each elements convert to html by
+  # +to_html+. Otherwise,using as it self.
+  #
+  # For example,Head implements is following:
+  #  class Hatena::Block::Head
+  #    include Hatena::Html
+  #    def tag_name
+  #      "h#{@level}"
+  #    end
+  #
+  #    def content
+  #      @inlines
+  #    end
+  #  end
+  # 
+  module Html
+    def to_html
+      content = html_content
+      if content.class == Array then
+        content = content.map{|x| x.to_html}.join
+      end
+      %(<#{html_tag}>#{content}</#{html_tag}>)
+    end
+  end
+
+  module Block
+    class Head
+      include Html
+      private
+      def html_tag
+        "h#{self.level}"
+      end
+
+      alias_method :html_content,:content
+    end
+
+    class P
+      include Html
+      private
+      def html_tag() 'p' end
+
+      alias_method :html_content,:content
+    end
+
+    class Empty
+      def to_html() '<p><br /></p>' end
+    end
+
+    class Pre
+      include Html
+      private
+      def html_tag() 'pre' end
+      alias_method :html_content,:content
+    end
+
+    class SuperPre
+      include Html
+      private
+      def html_tag() 'pre' end
+      alias_method :html_content,:content
+    end
+
+    class Quote
+      include Html
+      private
+      def html_tag() 'blockquote' end
+      alias_method :html_content,:content
+    end
+
+    class Table
+      def to_html
+        '<table>'+self.map_row{|tr|
+          '<tr>'+tr.map{|cell| tag = cell.class == Th ? 'th' : 'td'
+            "<#{tag}>#{cell.content.map{|x| x.to_html}.join}</#{tag}>"}.join+'</tr>'
+        }.join+'</table>'
+      end
+    end
+
+    class UnorderList
+      include Html
+      private
+      def html_tag
+        'ul'
+      end
+      alias_method :html_content,:items
+    end
+
+    class OrderList
+      include Html
+      private
+      def html_tag
+        'ol'
+      end
+      alias_method :html_content,:items
+    end
+
+
+    class ListItem
+      include Html
+      private
+      def html_tag
+        'li'
+      end
+      alias_method :html_content,:content
+    end
+  end
+
+  module Inline
+    class Text
+      def to_html
+        self.text
+      end
+    end
+
+    class Url
+      def to_html
+        %(<a href="#{self.url}">#{self.url}</a>)
+      end
+    end
+
+    class HatenaId
+      def to_html
+        %(<a href="http://d.hatena.ne.jp/#{self.name}/">id:#{self.name}</a>)
+      end
+    end
+  end
+end

data/lib/hparser/inline/all.rb

@@ -0,0 +1 @@
+Dir[File.dirname(__FILE__)+'/*.rb'].each{|x| require x}

data/lib/hparser/inline/collectable.rb

@@ -0,0 +1,6 @@
+module HParser
+  module Inline
+    module Collectable
+    end
+  end
+end

data/lib/hparser/inline/hatena_id.rb

@@ -0,0 +1,30 @@
+# 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
+    # hatena id parser.
+    #
+    # For example:
+    #  id:mzp
+    class HatenaId
+      include Collectable
+      attr_reader :name
+      def initialize(name)
+        @name = name
+      end
+      
+      def self.parse(scanner)
+        if scanner.scan(/id:\w+/) then
+          HatenaId.new scanner.matched[3..-1]
+        end
+      end
+      
+      def ==(o)
+        self.class == o.class and @name == o.name
+      end
+    end
+  end
+end

data/lib/hparser/inline/parser.rb

@@ -0,0 +1,48 @@
+# Author:: MIZUNO Hiroki (hiroki1124@gmail.com)
+# Copyright:: Copyright (c) 2006 MIZUNO Hiroki
+# License::   Distributes under the same terms as Ruby
+
+require 'strscan'
+require 'hparser/inline/collectable'
+require 'hparser/util/parser'
+module HParser
+  module Inline
+    class Parser
+      include Util
+      def initialize(parsers=Parser.default_parser)
+        @document =  Many1.new(Or.new(*parsers))
+      end
+
+      def parse str
+        scanner = StringScanner.new str
+        join_text @document.parse(scanner)
+      end
+
+      def self.default_parser
+        parser = []
+        ObjectSpace.each_object(Class){|klass|
+          if klass.include?(HParser::Inline::Collectable) then
+            parser.push klass
+          end
+        }
+        parser.sort{|a,b|
+          a <=> b or -(b <=> a).to_i
+        }
+      end
+
+      private
+      def join_text(nodes)
+        if nodes.length == 1 then
+          nodes
+        else
+          rest = join_text nodes[1..-1]
+          if rest[0].class == Text and nodes[0].class == Text then
+            rest[1..-1].unshift(nodes[0]+rest[0])
+          else
+            rest.unshift nodes[0]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hparser/inline/text.rb

@@ -0,0 +1,35 @@
+# 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 Text
+      include Collectable
+      attr_reader :text
+
+      def self.<=>(o)
+        1
+      end
+
+      def self.parse(scanner)
+        if scanner.scan(%r!<a.*</a>!) or scanner.scan(/./)
+          Text.new(scanner.matched)
+        end
+      end
+      
+      def initialize(text)
+        @text = text
+      end
+        
+      def +(other)
+        Text.new(self.text+other.text)
+      end
+      
+      def ==(o)
+        o.class == self.class and @text == o.text
+      end
+    end
+  end
+end