noratext 0.0.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 KOJIMA Satoshi
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,74 @@
+= noratext
+
+* http://github.com/skoji/noratext
+
+== DESCRIPTION:
+
+noratext is a simple (and rather stupid) lexer and parser generator for loosly marked-up text.
+current version supports xml-like, but not valid-xml  (like old HTML) markup.
+
+will support wiki-style markup soon.
+
+== FEATURES
+
+* Noratext::Lexer/Noratext::Parser provides functionalty to parse markuped text.
+
+== PROBLEMS
+
+* only provides xml-style tags support.
+
+* need to write duplicated rules for Lexar and Parser. e.g., need to define same tag  for Lexar and Parser.
+
+== SYNOPSIS
+
+=== lexer : style A
+# define lexer :my_ml。
+Noratext::Lexer.define :my_ml, :xml_style do
+   symbols :chapter, :section, :strong, :center, :right, :font-size, :blockquote, :code, :change_paragraph
+
+   without_close :change_paragraph
+   match_pattern :change_paragraph, 'p' # tag is <p> , not <change-paragraph>
+   rawtext_till_close :code
+   
+   # add attribute parser
+   add_parser :font-size do
+     |s|
+	 /size="(.?)"/ =~ s
+	 { :size => $1 }
+   end
+end
+
+# use the lexer
+Noratext::Lexer[:my_ml].parse(io)
+
+=== lexer : style B
+# define symbols
+Noratext::Lexer.define :my_ml, :xml_style do
+   symbol :chapter
+   symbol :section
+   symbol :strong
+   symbol :center
+   symbol :right
+   symbol :blockquote
+   symbol :font-size
+     add_parser do
+       |s|
+  	   /size="(.?)"/ =~ s
+  	   { :size => $1 }
+     end
+   end
+   symbol :code do
+     rawtext_till_close
+   end
+   symbol :change_paragraph do
+     without_close 
+	 match_pattern 'p'
+   end
+end
+
+# use the lexer
+Noratext::Lexer[:my_ml].parse(io)
+
+== Copyright
+
+Copyright (c) 2010 KOJIMA Satoshi. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "noratext"
+    gem.summary = %Q{ noratext: simple lexer/parser generator for markuped text}
+    gem.description = %Q{noratext is a simple (and rather stupid) lexer and parser generator for loosly markuped text.  }
+    gem.email = "skoji@mac.com"
+    gem.homepage = "http://github.com/skoji/noratext"
+    gem.authors = ["KOJIMA Satoshi"]
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "noratext #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/lib/noratext.rb

@@ -0,0 +1,4 @@
+require 'noratext/lexer'
+require 'noratext/xmly_lexer'
+require 'noratext/parser_element'
+require 'noratext/parser'

data/lib/noratext/lexer.rb

@@ -0,0 +1,153 @@
+# -*- coding: utf-8 -*-
+module Noratext
+  class Lexer
+    @instances_block = {}
+    def self.define(name, style = :xml_style, &block)
+      case style
+      when :xml_style
+        lexer = XmlyLexer.new
+      end
+      @instances_block[name] = { :lexer_class => lexer.class, :block => block }
+      lexer.instance_eval(&block) # for check only
+    end
+
+    def self.[](name)
+      lexer = @instances_block[name][:lexer_class].new
+      lexer.instance_eval(&@instances_block[name][:block])
+      lexer
+    end
+
+    def initialize
+      @tags = {}
+    end
+
+    def process(io)
+      result = []
+      while line = io.gets
+        result = result + read_line(line, io.lineno)
+      end
+      result
+    end
+
+    def symbols(*symbols)
+      symbols.each {
+        |symbol|
+        @tags[symbol] = tag_class.new(symbol)
+      }
+    end
+
+    def symbol(symbol, &block)
+      @tags[symbol] = tag_class.new(symbol)
+      @tags[symbol].instance_eval(&block)
+    end
+
+    def match_pattern(tag, pattern)
+      @tags[tag].match_pattern pattern
+    end
+
+    def without_close(*tags)
+      tags.each {
+        |tag|
+        @tags[tag].without_close
+      }
+    end
+    
+    def add_parser(tag, &block)
+      @tags[tag].attribute_parsers << block
+    end
+
+    def rawtext_till_close(tag, closetag = nil)
+      closetag ||= closetag_for(tag)
+      @tags[tag].rawtext_till_close closetag
+    end
+
+    def read_line(s, line_no)
+      return [] if s == ""
+      result = []
+
+      if @rawtext_tag
+        matched = /#{@rawtext_close_tag}/.match(s)
+        if matched.nil?
+          return [{ :type => :text, :data => s, :line => line_no }]
+        else
+          result << { :type => :text, :data => matched.pre_match, :line => line_no }
+          result << {
+            :type => @rawtext_tag.name,
+            :data => matched[0],
+            :line => line_no,
+            :tag => { :name => @rawtext_tag.name }.merge(@rawtext_tag.parse_attribute(matched[0])) }
+
+          @rawtext_tag = nil
+          @rawtext_close_tag = nil
+          return result + read_line(matched.post_match, line_no)
+        end
+      end
+
+      t = factory(s)
+      if (t.nil?)
+        return [{ :type => :text, :data => s, :line => line_no }]
+      else
+        result << { :type => :text, :data => t[:pre], :line => line_no } if t[:pre] != ""
+        result << { :type => t[:tag][:name], :data => t[:data], :line => line_no, :tag => t[:tag] }
+        result + read_line(t[:rest], line_no)
+      end
+    end
+    
+    def factory(s)
+      matched = @tags.map {
+        |name, tag|
+        { :tag => tag, :match => tag.matcher(s) } 
+      }.select { |m| !m[:match].nil? }.sort_by { |m| m[:match].begin(0) }
+
+      return nil if matched.size == 0
+      m = matched[0][:match]
+      tag = matched[0][:tag]
+
+      @rawtext_tag = tag if @rawtext_close_tag = tag.rawtext_till_close_tag
+      { :pre => m.pre_match,
+        :rest => m.post_match,
+        :data => m[0],
+        :tag => { :name => tag.name }.merge(tag.parse_attribute(m[0]))  }
+    end
+    
+    class Tag
+      attr_accessor :name, :attribute_parsers, :rawtext_till_close_tag
+
+      def initialize(name)
+        @name = name
+        @match_pattern = name.to_s
+        @attribute_parsers = []
+        @with_close = true
+        @rawtext_till_close_tag = nil
+      end
+
+      def without_close
+        @with_close = false
+      end
+
+      def rawtext_till_close(tag = nil)
+        tag ||= closetag_for(@name)
+        @rawtext_till_close_tag = tag
+      end
+
+      def add_parser(&block)
+        @attribute_parsers << block
+      end
+
+      def match_pattern(pattern)
+        @match_pattern = pattern
+      end
+      
+      def parse_attribute(s)
+        result = {}
+        @attribute_parsers.each {
+          |parser|
+          result.merge!(parser.call(s))
+        }
+        result
+      end
+
+    end
+  end
+end
+

data/lib/noratext/parser.rb

@@ -0,0 +1,43 @@
+module Noratext
+  class Parser
+    @instances_block = {}
+    def self.define(name, style = :xml_style, &block)
+      parser = Parser.new
+      @instances_block[name] = block
+      parser.instance_eval(&block) # for check only
+    end
+
+    def self.[](name)
+      parser = Parser.new
+      parser.instance_eval(&@instances_block[name])
+      parser
+    end
+
+    def element(name, &block)
+      element = Element.new(name, method(:logger), @elements)
+      @start_element = element if @elements.size == 0
+      @elements[name] = element
+      element.instance_eval(&block)
+    end
+
+    def initialize
+      @elements = {}
+      @log = []
+    end
+
+    def parse(sequence)
+      result = @start_element.process(sequence)
+      logger sequence[0][:line], "unexpected #{sequence[0][:data]}" if (sequence.size > 0)
+      result
+    end
+
+    def logger(lineno, log)
+      @log << { :lineno => lineno, :log => log}
+    end
+
+    def log
+      @log.sort_by { |entry| entry[:lineno] }.map { |entry| "#{entry[:lineno]}: #{entry[:log]}" }
+    end
+    
+  end
+end

data/lib/noratext/parser_element.rb

@@ -0,0 +1,189 @@
+module Noratext
+  class Parser
+
+    module Contains
+      def element_to_parse
+        @element_to_parse ||= @contains.map { |element_name| @elements[element_name] }
+      end
+      
+      def process(sequence)
+        preprocess(sequence)
+        children = []
+        while (sequence.size > 0 && elem = process_one_element(sequence))
+          children << elem
+        end
+        postprocess(sequence)
+        ParsedData.new(@name, children)
+      end
+    end
+
+    module IsOneof
+      def element_to_parse
+        @element_to_parse ||= @is_oneof.map { |element_name| @elements[element_name] }
+      end
+
+      def process(sequence)
+        if sequence.size > 0 && elem = process_one_element(sequence)
+          elem
+        else
+          nil
+        end
+      end
+    end
+
+    module OpenClose
+
+      def accept?(token)
+        is_opentag(token)
+      end
+
+      def preprocess(sequence)
+        @opentag = sequence.shift[:tag]
+      end
+
+      def is_end_of_element(token)
+        is_closetag(token)
+      end
+      
+      def postprocess(sequence)
+        return if sequence.size == 0
+
+        if is_closetag(sequence[0])
+          sequence.shift
+          return
+        end
+
+        log @opentag[:line], "#{@name} is not closed}"
+      end
+    end
+
+    module ParseToken
+      def process(sequence)
+        return ParsedData.new(@name).set_attributes(@parse_token_proc.call(sequence.shift))
+      end
+    end
+
+    module ParseSequence
+      def process(sequence)
+        return ParsedData.new(@name).set_attributes(@parse_sequence_proc.call(sequence))
+      end
+    end
+    
+    class Element
+      def accept?(token)
+        if (@accept_type)
+          return token[:type] == @accept_type
+        else
+          element_to_parse.each {
+            |element|
+            return true if (element.accept?(token)) 
+          }
+          return false
+        end
+      end
+
+      def is_closetag(token)
+        token[:type] == @name &&
+          token[:tag][:kind] == :closetag
+      end
+
+      def is_opentag(token)
+        token[:type] == @name &&
+          token[:tag][:kind] == :opentag
+      end
+      
+      def initialize(name, logger, elements)
+        @name = name
+        @logger = logger
+        @elements = elements
+      end
+
+      def preprocess(sequence)
+      end
+
+      def postprocess(sequence)
+      end
+
+      def is_end_of_element(token)
+        false
+      end
+      
+      def process_one_element(sequence)
+
+        while (sequence.size > 0 && sequence[0][:kind] == :closetag)
+          return nil if (is_end_of_element(sequence[0]))
+          log sequence[0][:line],"no opentag for #{sequence[0][:type]}"
+          sequence.shift
+        end
+        return nil if (sequence.size == 0) 
+
+        element_to_parse.each {
+          |element|
+          return element.process(sequence) if element.accept?(sequence[0])
+        }
+        nil
+      end
+
+      def contains(*array)
+        raise 'already is_oneof are defined' if !@is_oneof.nil?
+        @contains = array
+        extend Contains
+      end
+      
+      def is_oneof(*array)
+        raise 'already contains are defined' if !@contains.nil?
+        @is_oneof = array
+        extend IsOneof
+      end
+      
+      def open_close 
+        extend OpenClose
+      end
+
+      def accepts(type)
+        @accept_type = type
+      end
+
+      def parse_token(&block)
+        raise 'already defined as parse sequence type' if !@parse_sequence_proc.nil?
+        @parse_token_proc = block
+        @accept_type ||= @name
+        extend ParseToken
+      end
+
+      def parse_sequence(&block)
+        raise 'already defined as parse token type' if !@parse_token_proc.nil?
+        @parse_sequence_proc = block
+        @accept_type ||= @name
+        extend ParseSequence
+      end
+
+      def log(lineno, log)
+        @logger.call(lineno, log) if !@logger.nil?
+      end
+    end
+
+    class ParsedData
+      attr_accessor :type, :children
+
+      def initialize(type, children = [])
+        @children = children
+        @type = type
+        @attributes = {}
+      end
+
+      def is_leaf?
+        @children.size == 0
+      end
+
+      def set_attributes(value)
+        @attributes.merge!(value)
+        value.each {
+          |k,v|
+          (class<<self;self;end).instance_eval{define_method(k){v}}
+        }
+        self
+      end
+    end
+  end
+end

data/lib/noratext/xmly_lexer.rb

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+module Noratext
+  class XmlyLexer < Lexer
+
+    def initialize
+      super
+    end
+
+    def tag_class
+      return XmlyTag
+    end
+
+    def closetag_for(tag)
+      "</#{tag.to_s}>"
+    end
+
+    class XmlyTag < Lexer::Tag
+      def self.default_attribute_parser
+        lambda {
+          |s|
+          { :kind => /^<\// =~ s ? :closetag : :opentag }
+        }
+      end
+
+      def initialize(name)
+        super
+        @attribute_parsers << self.class.default_attribute_parser
+      end
+      
+      def matcher(s)
+        tagpattern = "<#{@match_pattern}.*?>"
+        tagpattern = "</?#{@match_pattern}.*?>" if @with_close
+        /#{tagpattern}/.match s
+      end
+    end
+
+  end
+end

data/noratext.gemspec

@@ -0,0 +1,65 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{noratext}
+  s.version = "0.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["KOJIMA Satoshi"]
+  s.date = %q{2010-07-13}
+  s.description = %q{noratext is a simple (and rather stupid) lexer and parser generator for loosly markuped text.  }
+  s.email = %q{skoji@mac.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "lib/noratext.rb",
+     "lib/noratext/lexer.rb",
+     "lib/noratext/parser.rb",
+     "lib/noratext/parser_element.rb",
+     "lib/noratext/xmly_lexer.rb",
+     "noratext.gemspec",
+     "spec/noratext_lexer_spec.rb",
+     "spec/noratext_parser_spec.rb",
+     "spec/noratext_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb",
+     "spec/ydml_grammer_definition.rb"
+  ]
+  s.homepage = %q{http://github.com/skoji/noratext}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{noratext: simple lexer/parser generator for markuped text}
+  s.test_files = [
+    "spec/noratext_lexer_spec.rb",
+     "spec/noratext_parser_spec.rb",
+     "spec/noratext_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/ydml_grammer_definition.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
+    else
+      s.add_dependency(%q<rspec>, [">= 1.2.9"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 1.2.9"])
+  end
+end
+

data/spec/noratext_lexer_spec.rb

@@ -0,0 +1,82 @@
+# -*- coding: utf-8 -*-
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Noratext::Lexer" do
+  before do
+    Noratext::Lexer.define :test do
+      symbols :center, :left, :right, :quote
+      rawtext_till_close :quote
+
+      symbol :paragraph do
+        match_pattern 'p'
+        without_close
+      end
+
+      symbol :image do
+        match_pattern 'img'
+        without_close
+        add_parser do
+          |s|
+          /src="(.*?)"/ =~ s
+          path = $1
+          /scale="(.*?)"/ =~ s
+          scale = $1
+          { :path => path, :scale => scale }
+        end
+      end
+    end
+  end
+
+  it "should parse tag correctly" do
+    lexer = Noratext::Lexer[:test]
+    opentag = lexer.factory('<center>')
+    closetag = lexer.factory('</center>')
+
+    opentag[:tag][:name].should == :center
+    opentag[:tag][:kind].should == :opentag
+
+    closetag[:tag][:name].should == :center
+    closetag[:tag][:kind].should == :closetag
+  end
+
+  it "should create parse path" do
+    lexer = Noratext::Lexer[:test]
+    tag = lexer.factory('<img src="../img/path.jpg">')
+    tag[:tag][:name].should == :image
+    tag[:tag][:kind].should == :opentag
+    tag[:tag][:path].should == '../img/path.jpg'
+    tag[:tag][:scale].should be_nil
+  end
+
+  it "should create parse path" do
+    lexer = Noratext::Lexer[:test]
+    tag = lexer.factory('<img src="../img/path.jpg" scale="90%">')
+    tag[:tag][:name].should == :image
+    tag[:tag][:kind].should == :opentag
+    tag[:tag][:path].should == '../img/path.jpg'
+    tag[:tag][:scale].should == '90%'
+  end
+
+  it "should parse rawtext tag" do
+    lexer = Noratext::Lexer[:test]
+    text = "<quote>この部分は、<center>とかはいっていても、そのまま見えるはず。
+<bold>改行</bold>しても、扱えるはず。</quote>このへんは、タグを<center>読む。"
+    io = StringIO.new(text)
+
+    processed = lexer.process(io)
+    processed.size.should == 7
+    processed[0][:type].should == :quote
+    processed[1][:type].should == :text
+    processed[1][:data].should == "この部分は、<center>とかはいっていても、そのまま見えるはず。\n"
+    processed[2][:type].should == :text
+    processed[2][:data].should == '<bold>改行</bold>しても、扱えるはず。'
+    processed[3][:type].should == :quote
+    processed[4][:type].should == :text
+    processed[4][:data].should == 'このへんは、タグを'
+    processed[5][:type].should == :center
+    processed[6][:type].should == :text
+    processed[6][:data].should == '読む。'
+  end
+
+  
+end

data/spec/noratext_parser_spec.rb

@@ -0,0 +1,87 @@
+# -*- coding: utf-8 -*-
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require File.expand_path(File.dirname(__FILE__) + '/ydml_grammer_definition')
+
+describe "Noratext::Parser" do
+
+  it "should accept open-close" do
+    element = Noratext::Parser::Element.new(:center, nil, nil)
+    element.open_close
+    element.accept?({ :type => :center, :tag => { :name => :center, :kind => :opentag }}).should be_true
+  end
+
+  it "should accept text" do
+    element = Noratext::Parser::Element.new(:text, nil, nil)
+    element.accepts :text
+    element.accept?({ :type => :text })
+  end
+
+  it "should accept open-close" do
+    elements = {}
+    elements[:text] = Noratext::Parser::Element.new(:text, nil, elements)
+    elements[:text].accepts :text
+    elements[:text].parse_sequence do
+      |s|
+      a = s.shift
+      { :data => a[:data] }
+    end
+    element = Noratext::Parser::Element.new(:center, nil, elements)
+    element.open_close
+    element.contains :text
+    element.accept?({ :type => :center, :tag => { :name => :center, :kind => :opentag }}).should be_true
+    a = element.process([{ :type => :center, :tag => { :name => :center, :kind => :opentag }},
+                       { :type => :text, :data => "foobar" },
+                         { :type => :center, :tag => { :name => :center, :kind => :closetag}}])
+    a.type.should == :center
+    a.is_leaf?.should_not be_true
+    a.children.size.should == 1
+    a.children[0].type.should == :text
+    a.children[0].is_leaf?.should be_true
+    a.children[0].data.should == "foobar"
+  end
+  
+end
+
+describe Noratext::Parser do
+  it "should parse valid test" do
+    seq = [ { :type => :text, :data=>'これが中身', :line => 1} ]
+    result = Noratext::Parser[:ydml].parse(seq)
+    result.type.should == :document
+    result.is_leaf?.should_not be_true
+    result.children.size.should == 1
+    result.children[0].is_leaf?.should_not be_true
+    result.children[0].type.should == :paragraph
+    result.children[0].children.size.should == 1
+    result.children[0].children[0].type.should == :text
+    result.children[0].children[0].data.should == 'これが中身'
+  end
+
+  it "should parse nested data" do
+    seq = [ { :type => :center, :tag => { :name => :center, :kind => :opentag}},
+            { :type => :text, :data=>'センタリング', :line => 1},
+            { :type => :center, :tag => { :name => :center, :kind => :closetag}},
+            { :type => :ruby, :tag => { :name => :ruby, :kind => :opentag }},
+            { :type => :text, :data => '蜻蛉/とんぼ', :line => 2 },
+            { :type => :ruby,:tag => { :name => :ruby, :kind => :closetag }}
+          ]
+
+    parser = Noratext::Parser[:ydml]
+    result = parser.parse(seq)
+    result.type.should == :document
+    parser.log.size.should == 0
+    result.children.size.should == 2
+    result.children[0].is_leaf?.should_not be_true
+    result.children[0].type.should == :center
+    result.children[0].children.size.should == 1
+    result.children[0].children[0].type.should == :paragraph
+    result.children[0].children[0].children[0].data.should == 'センタリング'
+    result.children[1].type.should == :paragraph
+    result.children[1].children.size.should == 1
+    result.children[1].children[0].type.should == :ruby
+    result.children[1].children[0].ruby.should == 'とんぼ'
+    result.children[1].children[0].body.should == '蜻蛉'
+
+  end
+  
+end
+

data/spec/noratext_spec.rb

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Noratext::Parser" do
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'noratext'
+require 'spec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+  
+end

data/spec/ydml_grammer_definition.rb

@@ -0,0 +1,95 @@
+Noratext::Parser.define :ydml do
+  element :document do
+    contains :block
+  end
+
+  element :block do
+    is_oneof :paragraph, :center, :left, :right, :quote, :hasen
+  end
+
+  element :paragraph do
+    contains :text, :large, :small, :bold, :image, :sonomama, :ruby 
+  end
+  
+  element :center do
+    open_close 
+    contains :paragraph
+  end
+
+  element :left do
+    open_close 
+    contains :paragraph 
+  end
+
+  element :right do
+    open_close 
+    contains :paragraph 
+  end
+
+  element :quote do
+    open_close
+    contains :paragraph
+  end
+
+  element :hasen do
+    parse_token do
+      |token|
+      {}
+    end
+  end
+
+  element :text do
+    accepts :text
+    parse_sequence do
+      |sequence|
+      data = ""
+      while (sequence.size > 0 &&
+             sequence[0][:type] == :text)
+        data << sequence.shift[:data]
+      end
+      { :data => data }
+    end
+  end
+
+  element :large do
+    open_close
+    contains  :paragraph 
+  end
+
+  element :small do
+    open_close
+    contains  :paragraph 
+  end
+
+  element :bold do
+    open_close
+    contains :paragraph
+  end
+
+  element :image do
+    parse_token do
+      |token|
+      { :imagepath => token[:imagepath], :size => token[:size] }
+    end
+  end
+
+  element :sonomama do
+    open_close
+    contains :text
+  end
+
+  element :ruby do
+    parse_sequence do
+      |sequence|
+      sequence.shift
+      /(.+)\/(.+)/ =~ sequence[0][:data]
+      raise "#{sequence[0][:data]} is invalid inside ruby tag." if $1.nil?
+      sequence.shift
+      raise "rubytag is not closed" if !is_closetag(sequence[0])
+      sequence.shift
+      { :body => $1, :ruby => $2 }
+    end
+    
+  end
+  
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification 
+name: noratext
+version: !ruby/object:Gem::Version 
+  hash: 31
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 0
+  version: 0.0.0
+platform: ruby
+authors: 
+- KOJIMA Satoshi
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-13 00:00:00 +09:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 1
+        - 2
+        - 9
+        version: 1.2.9
+  type: :development
+  version_requirements: *id001
+description: "noratext is a simple (and rather stupid) lexer and parser generator for loosly markuped text.  "
+email: skoji@mac.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/noratext.rb
+- lib/noratext/lexer.rb
+- lib/noratext/parser.rb
+- lib/noratext/parser_element.rb
+- lib/noratext/xmly_lexer.rb
+- noratext.gemspec
+- spec/noratext_lexer_spec.rb
+- spec/noratext_parser_spec.rb
+- spec/noratext_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/ydml_grammer_definition.rb
+has_rdoc: true
+homepage: http://github.com/skoji/noratext
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: "noratext: simple lexer/parser generator for markuped text"
+test_files: 
+- spec/noratext_lexer_spec.rb
+- spec/noratext_parser_spec.rb
+- spec/noratext_spec.rb
+- spec/spec_helper.rb
+- spec/ydml_grammer_definition.rb