kwaff 1.0.0

data/lib/kwaff/errors.rb

@@ -0,0 +1,26 @@
+##
+## errors and assertions
+##
+## $Id: errors.rb 7 2005-05-18 14:33:37Z kwatch $
+## $Release: 1.0.0 $
+## copyright(c) 2005 kuwata-lab.com all rights reserved
+##
+
+module Kwaff
+   class KwaffError < StandardError
+   end
+
+   class NotImplementedError < KwaffError
+   end
+
+   class AssertionError < KwaffError
+      def initialize(linenum, msg=nil)
+	 super("assertion error: #{linenum}" + (msg ? ": msg=#{msg};" : ""))
+      end
+   end
+
+   def self.assert(message=nil)
+      linenum = caller()[0]
+      AssertionError.new(linenum, message)
+   end
+end

data/lib/kwaff/node.rb

@@ -0,0 +1,101 @@
+##
+## definitions of node, element and document
+##
+## $Id: node.rb 7 2005-05-18 14:33:37Z kwatch $
+## $Release: 1.0.0 $
+## copyright(c) 2005 kuwata-lab.com all rights reserved
+##
+
+require 'kwaff/errors'
+require 'kwaff/orderedhash'
+
+module Kwaff
+   
+   ## abstract class
+   class Node
+      ## abstract method
+      def accept(translator, level=0)
+         raise NotImplementedError.new("#{self.class.name}#accept() is not implemented.")
+      end
+      
+      def to_xml(toppings={})
+         translator = XmlTranslator.new(toppings)
+         return translator ? translator.translate(self) : nil
+      end
+
+      def initialize()
+         @empty_lines = 0
+      end
+      
+      attr_accessor :empty_lines
+   end
+   
+   
+   class Element < Node
+      def accept(translator, level=0)
+         return translator.translate_element(self, level)
+      end
+      def initialize(tag, children=[], attrs=OrderedHash.new)
+         @tag = tag
+         @children = children
+         @attrs = attrs		## Hash or OrderedHash
+      end
+      attr_reader :children, :attrs
+      attr_accessor :tag
+      
+      def text
+         if @children.length > 0 && @children[0].is_a?(Text)
+            text = children[0]
+            return text.str
+         end
+         return nil
+      end
+      
+      def text=(str, flag_escape=true)
+         children[0] = Text.new(str, flag_escape)
+      end
+   end
+   
+   
+   class Document < Node
+      def accept(translator, level=0)
+         return translator.translate_document(self, level)
+      end
+      def initialize(headers=OrderedHash.new, root=nil)
+         @headers = headers
+         @root = root
+      end
+      attr_reader :headers
+      attr_accessor :root
+   end
+   
+   
+   class Comment < Node
+      def accept(translator, level=0)
+         return translator.translate_comment(self, level)
+      end
+      def initialize(str)
+         @str = str
+      end
+      attr_reader :str
+   end
+   
+   
+   class Text < Node
+      def accept(translator, level=0)
+         return translator.translate_text(self, level)
+      end
+      def initialize(str, flag_escape=true)
+         @str = str
+         @escape = flag_escape
+      end
+      attr_accessor :str, :escape
+      #def str
+      #	 return @escape ? Kwaff::escape(@str) : @str
+      #end
+      def escape?
+         return @escape
+      end
+   end
+   
+end

data/lib/kwaff/optparse.rb

@@ -0,0 +1,101 @@
+##
+## required only from 'bin/kwaff' script
+##
+## $Id: optparse.rb 11 2005-06-09 12:32:33Z kwatch $
+## $Release: 1.0.0 $
+## copyright(c) 2005 kuwata-lab.com all rights reserved
+##
+
+require 'kwaff/errors'
+
+module Kwaff
+
+   class CommandOptionError < KwaffError
+   end
+
+   class CommandOptionParser
+
+      def initialize(noarg_opts='', argneed_opts='', argoptional_opts='', flag_str2value=true)
+         @noarg_opts       = noarg_opts
+         @argneed_opts     = argneed_opts
+         @argoptional_opts = argoptional_opts
+         @flag_str2value   = flag_str2value
+         @options    = nil
+         @properties = nil
+      end
+      attr_reader :options, :properites
+
+
+      def parse(argv=ARGV)
+         options    = {}
+         properties = {}
+
+         while !argv.empty? && argv[0][0] == ?-
+            opt = argv.shift
+            if opt[1] == ?-			## properteis
+               propstr = opt.sub(/^--/, '')
+               unless propstr =~ /^([-\w]+)(?:=(.*))?$/
+                  raise CommandOptionError.new("--#{optstr}: invalid property.")
+               end
+               name  = $1
+               value = $2
+               name.gsub!(/-/, '_')
+               if !value
+                  value = true
+               elsif flag_str2value
+                  value = self.to_value(value)
+               end
+               properties[name.intern] = value
+
+            else				## options
+               optstr = opt.sub(/^-/, '')
+               while optstr && !optstr.empty?
+                  optchar = optstr[0]
+                  optstr = optstr[1, optstr.length-1]
+                  if @noarg_opts.include?(optchar)
+                     options[optchar] = true
+                  elsif @argneed_opts.include?(optchar)
+                     arg = optstr
+                     optstr = nil
+                     arg = argv.shift if !arg || arg.empty?
+                     unless arg
+                        raise CommandOptionError.new("-#{optchar.chr}: argument required.")
+                     end
+                     options[optchar] = arg
+                  elsif @argoptional_opts.include?(optchar)
+                     arg = optstr && !optstr.empty? ? optstr : true
+                     optstr = nil
+                     options[optchar] = arg
+                  else
+                     raise CommandOptionError.new("-#{optchar.chr}: invalid option.")
+                  end
+               end
+
+            end   # if
+
+         end   # while
+
+         @options = options
+         @properties = properties
+         return options, properties
+      end
+
+
+      def to_value(str)
+         case str
+         when 'true', 'yes'     ;  return true
+         when 'false', 'no'     ;  return false
+         when 'null', 'nil'     ;  return nil
+         when /\A\d+\z/         ;  return str.to_i
+         when /\A\d+\.\d+\z/    ;  return str.to_f
+         when /\A\/(.*)\/\z/    ;  return Regexp.new($1)
+         when /\A'.*'\z/        ;  return eval(str)
+         when /\A".*"\z/        ;  return eval(str)
+         else
+            return str
+         end
+      end
+
+   end
+
+end

data/lib/kwaff/orderedhash.rb

@@ -0,0 +1,56 @@
+##
+## hash which keeps order of keys added into itself
+##
+## $Id: orderedhash.rb 7 2005-05-18 14:33:37Z kwatch $
+## $Release: 1.0.0 $
+## copyright(c) 2005 kuwata-lab.com all rights reserved
+##
+
+module Kwaff
+
+   class OrderedHash
+      include Enumerable
+
+      def initialize
+	 @keys = []
+	 @hash = {}
+      end
+
+      attr_reader :keys, :hash
+
+      def each(&block)
+	 keys.each do |key|
+	    value = @hash[key]
+	    yield(key, value)
+	 end
+      end
+
+      def [](key)
+	 return @hash[key]
+      end
+
+      def []=(key, value)
+	 @keys << key unless @hash.key?(key)
+	 @hash[key] = value
+      end
+
+      def delete(key)
+	 @keys.delete(key)
+	 @hash.delete(key)
+      end
+
+      def default
+	 return @hash.default
+      end
+
+      def default=(value)
+	 @hash.default = value
+      end
+
+      def key?(key)
+	 return @hash.key?(key)
+      end
+
+   end
+
+end

data/lib/kwaff/parser.rb

@@ -0,0 +1,342 @@
+##
+## parse Kwaff document
+##
+## $Id: parser.rb 14 2005-06-10 09:01:18Z kwatch $
+## $Release: 1.0.0 $
+## copyright(c) 2005 kuwata-lab.com all rights reserved
+##
+
+require 'kwaff/errors'
+require 'kwaff/orderedhash'
+require 'kwaff/node'
+require 'kwaff/doctype'
+
+module Kwaff
+
+   class ParseError < KwaffError
+      def initialize(msg, parser)
+         super(msg)
+         @parser = parser
+      end
+
+      def to_s
+         index = @parser.index
+         line = @parser.lines[index]
+         super() + " - (line #{index + 1}: #{line.inspect})\n"
+      end
+   end
+
+   ## parse Kwaff string and create Kwaff::Document.
+   ##
+   ## ex.
+   ##   kwaff_str = File.open('file.kwaff') { |f| f.read }
+   ##   parser = Kwaff::Parser.new(kwaff_str)
+   ##   kwaff_doc = parser.parse_document()
+   ##   translator = Kwaff::XmlTranslator.new()
+   ##   xml_str = translator.translate(kwaff_doc)
+   ##
+   ## if you want to get REXML::Document instead of Kwaff::Document,
+   ## use Kwaff::Rexml::Parser instead of Kwaff::Parser.
+   ##
+   class Parser
+      def initialize(str, toppings={})
+         reset(str)
+         @toppings = toppings
+         @_s_cache = {}			# for spclen()
+         @indent_width = toppings[:indent_width] || 2
+      end
+      attr_reader :lines, :index, :newline
+
+
+      def reset(str)
+         @str = str
+         idx = str.index(?\n)
+         @newline  = (idx && str[idx-1] == ?\r) ? "\r\n" : "\n"
+         @lines    = str.split(@newline, -1)
+         @lines.pop()		# remove the last line
+         @index    = 0
+         @limit    = @lines.length
+      end
+
+
+      def _read_line
+         return nil if @index >= @limit
+         @index += 1
+         return @lines[@index]
+      end
+      private :_read_line
+
+      def _current_line
+         return @lines[@index]
+      end
+      private :_current_line
+
+
+      ## space length, with tab expanding
+      def spclen(str)
+         return 0 unless str
+         len = (@_s_cache[str] ||= (str.gsub(/([^\t]{8})|([^\t]*)\t/n){[$+].pack("A8")}).length)
+         return len
+      end
+
+
+      ## factory method
+      def create_document(headers, root)
+         return Document.new(headers, root)
+      end
+
+      ## factory method
+      def create_element(tag, children, attrs)
+         return Element.new(tag, children, attrs)
+      end
+
+      ## factory method
+      def create_comment(str)
+         return Comment.new(str)
+      end
+
+      ## factory method
+      def create_text(str, flag_escape=true)
+         return Text.new(str, flag_escape)
+      end
+
+      ##
+      def set_node_option(node, name, value)
+         node.empty_lines = value if name == :empty_lines
+      end
+
+      ##
+      def parse_document(str=nil)
+         reset(str) if str
+         headers = OrderedHash.new
+         line = _current_line()
+         while line
+            if line =~ /^\?[ \t]*([-:\w]+)[ \t]*[:=][ \t]*(.*)/	## *pattern*
+               headers[$1.intern] = $2.strip
+            elsif line =~ /^\s*$/
+               # ignore empty line
+            elsif line =~ /^\s*\/\//				## *pattern*
+               # ignore comment line
+            else
+               break
+            end
+            line = _read_line()
+         end
+         if headers[:doctype] =~ /\A@[-:\w]+\z/
+            nickname = headers[:doctype]
+            doctype = DocType.get(nickname)
+            unless doctype
+               raise ParseError.new("doctype `#{headers[:doctype]}' not registered.", self)
+            end
+            headers[:doctype] = doctype
+         end
+         root_elem = parse_element()
+         doc = create_document(headers, root_elem)
+         set_node_option(doc, :empty_lines, @empty_lines)
+         return doc
+      end
+
+
+      def parse_node_list(level=0)
+         list = []
+         str  = nil
+         line = _current_line()
+         while line
+            if line =~ /^(\s*)([*\#!.\~])/	# node		## *pattern*
+               curr_level = spclen($1)
+               ch = $2
+               if str
+                  list << create_text(str)
+                  str = nil
+               end
+               if curr_level == level		# sibling node
+                  empty_lines = @empty_lines || 0
+                  @empty_lines = 0
+                  case ch
+                  when '*'					## *pattern*
+                     node = parse_element(level)
+                  when '#', '!'					## *pattern*
+                     node = parse_comment(level)
+                  when '.'					## *pattern*
+                     node = parse_text(level)
+                  when '~'					## *pattern*
+                     node = parse_cdata(level)
+                  else
+                     raise ParseError.new("internal error", self)
+                  end
+                  set_node_option(node, :empty_lines, empty_lines)
+                  list << node
+                  line = _current_line()
+                  next
+               elsif curr_level < level		# parent node
+                  break
+               else				# child node
+                  raise ParseError.new("illegal indentation.", self)	# or internal error
+               end
+            elsif line =~ /^\s*$/		# empty lines
+               @empty_lines ||= 0
+               @empty_lines += 1
+               line = _read_line()
+            elsif line =~ /^\s*\/\//		# line-comment	# *pattern*
+               line = _read_line()
+            else
+               #raise ParseError.new("invalid line.", self)
+               str ||= ''
+               str << line
+               line = _read_line()
+            end
+         end
+         list << create_text(str) if str
+         return list
+      end
+
+
+      def _parse_heredoc(terminator, flag_join=false)
+         s = ""
+         while line = _read_line()
+            break if terminator === line.strip
+            s << @newline unless flag_join || s.empty?
+            s << line
+         end
+         raise ParseError.new("'<<#{terminator.to_s}' is not ended.", self) unless line
+         if line =~ /\A\s*/
+            space = $&
+            s.gsub!(/^#{space}/, '')
+         end
+         return s
+      end
+      private :_parse_heredoc
+
+
+      def parse_element(level=0)
+         ## tag and text
+         line = _current_line()
+         line =~ /^([ \t]*)\*[ \t]*([-:\w]+)([ \t]*=[ \t]*(.*))?/	## *pattern*
+         Kwaff::assert() unless level == spclen($1)
+         tag = $2 || ''
+         value = $4
+         tag.strip!
+         if tag.empty?
+            raise ParseError.new("tag is missing.", self)
+         end
+         flag_escape = true
+         if value =~ /^<<<?('?\w+'?)$/
+            terminator = $1
+            if terminator =~ /\A'(.*)'\z/
+               terminator = $1
+               flag_escape = false
+            end
+            value = _parse_heredoc(terminator)
+         end
+
+         ## text
+         text = value ? create_text(value, flag_escape) : nil
+
+         ## attrs
+         attrs = OrderedHash.new
+         line = _read_line()
+         while line
+            if line =~ /^\s*\/\/$/	# line comment				## *pattern*
+               # nothing
+            #elsif line =~ /^\s*$/	# empty line
+            #   @empty_lines += 1
+            elsif line =~ /^\s*\-/	# attribute				## *pattern*
+               unless line =~ /\A([ \t]*)\-[ \t]+([-:\w]+)[ \t]*=[ \t]*(.*)/	## *pattern*
+                  raise ParseError.new("invalid attribute format.", self)
+               end
+               attr_level = spclen($1)
+               attr_name = $2
+               attr_value = $3
+               unless attr_level == level + @indent_width			## *indent*
+                  raise ParseError.new("attr indent width is not #{@indent_width}.", self)
+               end
+               if attr_value =~ /^<<([_A-Z]+)$/
+                  terminator = $1
+                  attr_value = _parse_heredoc(terminator)
+               end
+               attrs[attr_name] = attr_value
+            else
+               break
+            end
+            line = _read_line()
+         end
+
+         ## empty lines
+         @empty_lines = 0
+         while line && line =~ /\A\s*\z/
+            @empty_lines += 1
+            line = _read_line()
+         end
+
+         ## children
+         if line && line =~ /^(\s*)[*\#!.\~]/ && spclen($1) > level	## *pattern*
+            #children = parse_node_list(spclen($1))
+            unless spclen($1) == level + @indent_width			## *indent*
+               raise ParseError.new("indent width is not #{@indent_width}.", self)
+            end
+            children = parse_node_list(level+@indent_width)
+         else
+            children = []
+         end
+         children.unshift(text) if text
+
+         ## element
+         return create_element(tag, children, attrs)
+      end
+
+
+      def parse_comment(level=0)
+         line = _current_line()
+         line =~ /^([ \t]*)[\#\!][ \t]*(.*)$/			# *pattern*
+         Kwaff::assert() unless level == spclen($1)
+         str = $2
+         comment = create_comment(str)
+         line = _read_line()
+         return comment
+      end
+
+
+      def parse_text(level=0)
+         return _parse_textline(/^([ \t]*)\. ?(.*)$/, true, level)	# *pattern*
+      end
+      
+      def parse_cdata(level=0)
+         return _parse_textline(/^([ \t]*)\~ ?(.*)$/, false, level)	# *pattern*
+      end
+
+      def _parse_textline(pattern, flag_escape, level=0)
+         line = _current_line()
+         str = ''
+         while line
+            break unless line =~ pattern
+            curr_level = spclen($1)
+            value = $2
+            if curr_level == level
+               str << @newline unless str.empty?
+               str << value
+               line = _read_line()
+            elsif curr_level < level
+               break
+            else
+               raise Parser.new("invalid indentaton.", self)
+            end
+         end
+         text = create_text(str, flag_escape)
+         return text
+      end
+      private :_parse_textline
+
+   end
+
+
+   ##
+   ## ex.
+   ##   kwaff_str = File.open('file.kwaff') { |f| f.read }
+   ##   kwaff_document = Kwaff::parse_document(kwaff_str)
+   ##   xml_str = kwaff_document.to_xml
+   ##
+   def self.parse_document(input, toppings={})
+      return Parser.new(input, toppings).parse_document()
+   end
+
+end