kwaff 1.0.0

data/lib/kwaff/rexml.rb

@@ -0,0 +1,394 @@
+##
+## translators for REXML
+##
+## $Id: rexml.rb 9 2005-06-09 08:44:11Z kwatch $
+## $Release: 1.0.0 $
+## copyright(c) 2005 kuwata-lab.com all rights reserved
+##
+
+require 'rexml/document'
+
+require 'kwaff/errors'
+require 'kwaff/orderedhash'
+require 'kwaff/node'
+require 'kwaff/parser'
+require 'kwaff/translator'
+
+module Kwaff
+
+   class Node
+      def to_rexml(toppings={})
+         translator = Kwaff::RexmlTranslator.new(toppings)
+         return translator ? translator.translate(self) : nil
+      end
+   end
+
+
+   ## translate Kwaff::Document to REXML::Document
+   ##
+   ## ex.
+   ##   kwaff_str = File.open('file.kwaff') { |f| f.read }
+   ##   kwaff_document = Kwaff.parse_document(kwaff_str)
+   ##   translator = Kwaff::Rexml::RexmlTranslator.new()
+   ##   rexml_document = translator.translate(kwaff_document)
+   ##
+   class RexmlTranslator < Translator
+
+      def initialize(toppings={})
+         super(toppings)
+      end
+
+      def translate_element(elem, level=0)
+         rexml_elem = REXML::Element.new(elem.tag)
+         elem.attrs.each do |aname, avalue|
+            rexml_elem.add_attribute(aname, avalue)
+         end if elem.attrs
+         elem.children.each do |child|
+            rexml_node = translate(child, level)
+            rexml_elem.add(rexml_node)
+         end if elem.children
+         return rexml_elem
+      end
+
+      def translate_document(document, level=0)
+         headers = document.headers
+         rexml_document = REXML::Document.new
+         rexml_xmldecl = REXML::XMLDecl.new(headers[:xmlversion], headers[:encoding])
+         rexml_document.add(rexml_xmldecl)
+         if headers[:doctype]
+            #$stderr.puts "*** debug: headers[:doctype]=#{headers[:doctype].inspect}"
+            rexml_source  = REXML::Source.new(headers[:doctype].to_s)
+            rexml_doctype = REXML::DocType.new(rexml_source)
+            rexml_document.add(rexml_doctype)
+         end
+         rexml_document.add(document.root.to_rexml()) if document.root
+         return rexml_document
+      end
+
+      def translate_comment(comment, level=0)
+         return REXML::Comment.new(comment.str)
+      end
+
+      def translate_text(text, level=0)
+         return REXML::Text.new(text.str)
+      end
+
+   end
+
+
+
+   ##
+   ## * To convert XML string to Kwaff format string,
+   ##   use Kwaff::Rexml::revert()
+   ## * To convert Kwaff format string to REXML::Document tree,
+   ##   use Kwaff::Rexml::Parser or Kwaff::Rexml::parse_document().
+   ## * To convert Kwaff::Document tree to REXML::Document tree,
+   ##   use Kwaff::RexmlTranslator.
+   ## * To convert REXML::Document tree to Kwaff format string,
+   ##   use Kwaff::Rexml::KwaffTranslator
+   ## * To convert REXML::Document tree to Kwaff::Document tree,
+   ##   use Kwaff::Rexml::ReverseTranslator.
+   ##
+   module Rexml
+
+      ## Parse Kwaff string and return REXML::Document
+      ##
+      ## ex.
+      ##   kwaff_str = File.open('file.kwaff') { |f| f.read }
+      ##   parser = Kwaff::Rexml::Parser.new(kwaff_str)
+      ##   rexml_document = parser.parse_document()
+      ##
+      class Parser < Kwaff::Parser
+
+         def create_document(headers, root)
+            Kwaff::assert() unless root.is_a?(REXML::Element)
+            ## XML Declaration and Document Type
+            #rexml_xmldecl  = REXML::XMLDecl.new((headers[:xmlversion] || '1.0'), headers[:encoding])
+            #rexml_source   = REXML::Source.new(headers[:doctype])
+            #rexml_doctype  = REXML::DocType.new(rexml_source)
+            s = ''
+            s << '<?xml version="' << (headers[:xmlversion] || '1.0')
+            if headers[:encoding]
+               s << ' encoding="' << headers[:encoding] << '"'
+            end
+            s << "?>\n"
+            s << headers[:doctype].to_s if headers[:doctype]
+
+            ## create XML Document
+            #rexml_document = REXML::Document.new()
+            #rexml_document.add(rexml_xmldecl)
+            #rexml_document.add(rexml_doctype)
+            rexml_document = REXML::Document.new(s)
+            rexml_document.add(root)
+            return rexml_document
+         end
+
+         def create_element(tag, children, attrs)
+            rexml_element = REXML::Element.new
+            rexml_element.name = tag
+            attrs.each do |aname, avalue|
+               rexml_element.add_attribute(aname, avalue)
+            end if attrs
+            children.each do |child|
+               rexml_element.add(child)
+            end if children
+            return rexml_element
+         end
+
+         def create_comment(str)
+            return REXML::Comment.new(str)
+         end
+
+         def create_text(str, flag_escape=true)
+            return flag_escape ? REXML::Text.new(str) : REXML::CData.new(str)
+         end
+
+         def set_node_option(node, name, value)
+            # nothing
+         end
+
+      end
+
+
+
+      ##
+      ## Kwaff::Rexml::Translator
+      ##
+      class Translator
+         def initialize(toppings={})
+            @toppings = toppings
+            @newline  = toppings[:newline] || "\n"
+            @space    = ' ' * (toppings[:output_indent_width] || 2)
+            @output   = ''
+         end
+
+         ## don't override!
+         def translate(rexml_node, level=0)
+            ## cannot use visitor-pattern
+            case rexml_node
+            when REXML::Document
+               return translate_document(rexml_node, level)
+            when REXML::Element
+               return translate_element(rexml_node, level)
+            when REXML::Comment
+               return translate_comment(rexml_node, level)
+            when REXML::Text
+               return translate_text(rexml_node, level)
+            else
+               errmsg = "translation error (rexml_node.class.name=#{rexml_node.class.name})."
+               raise Kwaff::TranslationError.new(errmsg)
+            end
+         end
+
+         ## abstract method
+         def translate_document(rexml_node, level=0)
+            raise NotImplementedError.new("#{self.class.name}#translate_document() is not implemented.")
+         end
+
+         ## abstract method
+         def translate_element(rexml_node, level=0)
+            raise NotImplementedError.new("#{self.class.name}#translate_element() is not implemented.")
+         end
+
+         ## abstract method
+         def translate_comment(rexml_node, level=0)
+            raise NotImplementedError.new("#{self.class.name}#translate_comment() is not implemented.")
+         end
+
+         ## abstract method
+         def translate_text(rexml_node, level=0)
+            raise NotImplementedError.new("#{self.class.name}#translate_text() is not implemented.")
+         end
+      end
+
+
+      ## Translate REXML::Document to Kwaff string
+      ##
+      ## ex.
+      ##   xml_str = File.open('file.xml') { |f| f.read }
+      ##   rexml_document = REXML::Document.new(xml_str)
+      ##   translator = Kwaff::Rexml::KwaffTranslator.new()
+      ##   kwaff_str = translator.translate(rexml_document)
+      ##
+      class KwaffTranslator < Translator
+         def initialize(toppings={})
+            @toppings = toppings
+            @newline  = toppings[:newline] || "\n"
+            @space    = ' ' * (toppings[:output_indent_width] || 2)
+            @output   = ''
+         end
+
+         def translate_element(rexml_elem, level=0)
+            Kwaff::assert() unless rexml_elem.is_a?(REXML::Element)
+
+            children = []
+            rexml_elem.children.each do |child|
+               children << child if !child.is_a?(REXML::Text) || child.to_s =~ /\S/
+            end if rexml_elem.children
+
+            tag = rexml_elem.expanded_name		## namespace + tagname
+            @output << (@space * level) if level > 0
+            @output << "* #{tag}"					## *pattern*
+
+            text = nil
+            if children.length == 1 && children[0].is_a?(REXML::Text)
+               text = children[0].to_s.strip
+               if text.index(?\n) == nil
+                  @output << " = #{text}"
+               else
+                  text = nil
+               end
+            end
+            @output << @newline
+
+            rexml_elem.attributes.each do |name, value|
+               @output << (@space * (level + 1))
+               @output << "- #{name} = #{value}#{@newline}"		## *pattern*
+            end
+
+            if text == nil
+               children.each do |child|
+                  #translate_element(child, level+1)
+                  translate(child, level+1)
+               end if rexml_elem.children
+            end
+
+            return @output
+         end
+
+         def _rexml_doctype_to_kwaff_doctype(rexml_doctype)
+            tag       = rexml_doctype.name
+            public_id = rexml_doctype.instance_eval("@long_name")
+            public_id = public_id.gsub(/\A"/, '').gsub(/"\z/, '') if public_id
+            system_id = rexml_doctype.instance_eval("@uri")
+            system_id = system_id.gsub(/\A"/, '').gsub(/"\z/, '') if system_id
+            if system_id || public_id
+               doctype = Kwaff::DocType.new(tag, public_id, system_id)
+            else
+               doctype = Kwaff::DocType.new()
+               doctype.doctype = rexml_doctype.to_s
+            end
+            return doctype
+         end
+
+         def translate_document(rexml_document, level=0)
+            Kwaff::assert() unless rexml_document.class == REXML::Document
+            @output << "?xmlversion = #{rexml_document.version.sub(/\s+encoding=/,'')}#{@newline}"
+            @output << "?encoding   = #{rexml_document.encoding.to_s}#{@newline}"
+            rexml_doctype = rexml_document.doctype
+            if rexml_doctype
+               doctype = _rexml_doctype_to_kwaff_doctype(rexml_doctype)
+               nickname = nil
+               if doctype.system_id
+                  dtype = DocType.find { |dt| doctype.system_id == dt.system_id }
+                  nickname = DocType.nickname(dtype) if dtype
+               end
+               doctype_str = nickname || rexml_doctype.to_s
+               @output << "?doctype    = #{doctype_str}#{@newline}" if doctype_str
+            end
+            translate_element(rexml_document.root, level)
+            return @output
+         end
+
+         def translate_comment(rexml_comment, level=0)
+            prefix = (@space * level) + "# "				## *pattern*
+            rexml_comment.string.split(/\r?\n/).each do |line|
+               @output << prefix << line << @newline
+            end
+            return @output
+         end
+
+         def translate_text(rexml_text, level=0)
+            str = rexml_text.value
+            return @output if str =~ /\A\s*\z/
+            prefix = (@space * level) + ". "				## *pattern*
+            str.split(/\r?\n/).each do |line|
+               @output << prefix << line << @newline
+            end
+            return @output
+         end
+
+      end
+
+
+      ##
+      ## translate REXML::Document to Kwaff::Document
+      ##
+      class ReverseTranslator < Translator
+
+         def translate_document(rexml_document, level=0)
+            headers = OrderedHash.new
+            headers[:xmlversion] = rexml_document.version().to_s
+            headers[:encoding]   = rexml_document.encoding().to_s
+            if doctype = rexml_document.doctype
+               doctype = doctype.to_s
+               doctype << "\n" if doctype[-1] != ?\n
+               headers[:doctype] = doctype.to_s
+            end
+            root = translate_element(rexml_document.root)
+            return Document.new(headers, root)
+         end
+
+         def translate_element(rexml_element, level=0)
+            tag      = rexml_element.name
+            children = []
+            attrs    = OrderedHash.new
+            rexml_element.attributes.each do |aname, avalue|
+               attrs[aname] = avalue
+            end if rexml_element.attributes
+            rexml_element.children.each do |child|
+               node = translate(child)
+               children << node if node
+            end if rexml_element.children
+            return Element.new(tag, children, attrs)
+         end
+
+         def translate_comment(rexml_comment, level=0)
+            str = rexml_comment.to_s
+            return Comment.new(str)
+         end
+
+         def translate_text(rexml_text, level=0)
+            str = rexml_text.value
+            return nil if str =~ /\A\s*\z/
+            flag_escape = !rexml_text.is_a?(REXML::CData)
+            return Text.new(str, flag_escape)
+         end
+
+      end
+
+
+      ## return an intance of REXML::Document
+      ##
+      ## ex.
+      ##    kwaff_str = File.open('file.kwaff') { |f| f.read }
+      ##    rexml_document = Kwaff::parse_document(kwaff_str)
+      ##
+      def self.parse_document(kwaff_str, toppings={})
+         parser = Kwaff::Rexml::Parser.new(kwaff_str, toppings)
+         rexml_document = parser.parse_document()
+         return rexml_document
+      end
+
+
+      ## convert XML string to Kwaff string.
+      ##
+      ## ex.
+      ##   xml_str = File.open('file.xml') { |f| f.read }
+      ##   kwaff_str = Kwaff::Rexml::revert(xml_str)
+      ##
+      def self.revert(xml_str, toppings={})
+         rexml_document = REXML::Document.new(xml_str)
+         if !toppings[:newline]
+            pos = xml_str.index(?\n)
+            toppings[:newline] = "\r\n" if xml_str[pos-1] == ?\r
+         end
+         translator = Kwaff::Rexml::KwaffTranslator.new(toppings)
+         kwaff_str = translator.translate(rexml_document)
+         return kwaff_str
+      end
+
+
+   end  ## module Rexml
+
+end

data/lib/kwaff/translator.rb

@@ -0,0 +1,275 @@
+##
+## translate Kwaff node-tree to XML document or Kwaff document
+##
+## $Id: translator.rb 8 2005-05-18 17:33:43Z kwatch $
+## $Release: 1.0.0 $
+## copyright(c) 2005 kuwata-lab.com all rights reserved
+##
+
+require 'kwaff/errors'
+require 'kwaff/node'
+require 'kwaff/doctype'
+
+module Kwaff
+
+   class TranslationError < KwaffError
+   end
+
+
+   ## abstract class for XmlTranslator and KwaffTranslator
+   class Translator
+      def initialize(toppings={})
+         @toppings = toppings
+      end
+      attr_reader :toppings
+
+
+      ## concrete method (don't override!)
+      def translate(node, level=0)		## don't override!
+         return node.accept(self, level)
+      end
+
+      ## abstract method
+      def translate_document(document, level=0)
+         raise NotImplementedError.new("#{self.class.name}#translate_document() is not implemented.")
+      end
+
+      ## abstract method
+      def translate_element(document, level=0)
+         raise NotImplementedError.new("#{self.class.name}#translate_element() is not implemented.")
+      end
+
+      ## abstract method
+      def translate_comment(comment, level=0)
+         raise NotImplementedError.new("#{self.class.name}#translate_comment() is not implemented.")
+      end
+
+      ## abstract method
+      def translate_text(text, level=0)
+         raise NotImplementedError.new("#{self.class.name}#translate_text() is not implemented.")
+      end
+
+   end
+
+
+
+   ## translate Kwaff::Document into XML string
+   ##
+   ## ex.
+   ##   kwaff_str  = File.open('file.kwaff') { |f| f.read }
+   ##   parser     = Kwaff::Parser.new(kwaff_str)
+   ##   document   = parser.parse_document()
+   ##   toppings   = { :newline => parser.newline, :output_indent_width=>2 }
+   ##   translator = XmlTranslator.new(toppings)
+   ##   xml_str    = translator.translate(document)
+   ##
+   class XmlTranslator < Translator
+
+      def initialize(toppings={})
+         super(toppings)
+         @newline = toppings[:newline] || "\n"
+         @output = ""
+         width = toppings[:output_indent_width]
+         @space = width ? ' ' * width.to_i : '  '
+      end
+
+
+      def translate_element(elem, level=0)
+         n = elem.empty_lines()
+         n.times { @output << @newline } if n
+         
+         @output << @space * level if @output[-1] == ?\n
+         @output << "<" << elem.tag
+         elem.attrs.each do |aname, avalue|
+            @output << " #{aname}=\"#{_escape_attrval(avalue)}\""
+         end
+         
+         children = elem.children
+         if children.empty?
+            @output << "/>#{@newline}"
+         elsif children.length == 1 && children[0].is_a?(Text)
+            text = children[0]
+            str  = text.escape? ? _escape(text.str) : text.str
+            @output << ">#{str}</#{elem.tag}>#{@newline}"
+         else
+            @output << ">#{@newline}"
+            children.each do |child|
+               translate(child, level+1)
+            end
+            n = children[0].empty_lines
+            n.times { @output << @newline } if n && n > 0
+            @output << @space * level if @output[-1] == ?\n
+            @output << "</#{elem.tag}>#{@newline}"
+         end
+         return @output
+      end
+
+
+      def translate_document(document, level=0)
+         headers = document.headers()
+         xmlversion = headers[:xmlversion] || '1.0'
+         encoding = headers[:encoding] ? " encoding=\"#{headers[:encoding]}\"" : ''
+         doctype = headers[:doctype]
+         @output << "<?xml version=\"#{xmlversion}\"#{encoding}?>#{@newline}"
+         @output << doctype.to_s if doctype
+         @output << "\n" if @output[-1] != ?\n
+         if document.root
+            translate_element(document.root, level)
+            #if (n = document.empty_lines) != nil && n > 0
+            #   @output.sub!(/^\s*<\/.*?>\r?\n?\z/, (@newline * n) + '\&')
+            #end
+         end
+         return @output
+      end
+
+
+      def translate_comment(comment, level=0)
+         n = comment.empty_lines()
+         n.times { @output << @newline } if n
+         @output << @space * level
+         @output << "<!-- #{comment.str} -->#{@newline}"
+         return @output
+      end
+
+
+      def translate_text(text, level=0)
+         n = text.empty_lines()
+         n.times { @output << @newline } if n
+         #@output << @space * level
+         str = text.escape? ? _escape(text.str) : text.str
+         @output << "#{str}"
+         return @output
+      end
+
+
+      private
+
+      def _escape_attrval(str)
+         s = str.dup
+         s.gsub!(/\&/, '&amp;')
+         s.gsub!(/</,  '&lt;')
+         s.gsub!(/>/,  '&gt;')		# should be comment-out?
+         s.gsub!(/"/,  '&quot;')	#"
+         return s
+      end
+
+      def _escape(str)
+         s = str.dup
+         s.gsub!(/\&/, '&amp;')
+         s.gsub!(/</,  '&lt;')
+         s.gsub!(/>/,  '&gt;')
+         return s
+      end
+
+   end
+
+
+   ## translate Kwaff::Document into Kwaff string
+   ##
+   ## ex.
+   ##   kwaff_str  = File.open('file.kwaff') { |f| f.read }
+   ##   parser     = Kwaff::Parser.new(kwaff_str)
+   ##   document   = parser.parse_document()
+   ##   toppings   = { :newline => parser.newline, :output_indent_width=>2 }
+   ##   translator = KwaffTranslator.new(toppings)
+   ##   xml_str    = translator.translate(document)
+   ##
+   ## if you want to convert XML string to Kwaff string,
+   ## use Kwaff::Rexml::revert() or Kwaff::Rexml::KwaffTranslator.
+   ##
+   class KwaffTranslator < Translator
+
+      def initialize(toppings={})
+         super(toppings)
+         @toppings = toppings
+         @space    = toppings[:indent_width] || '  '
+         @newline  = toppings[:newline] || "\n"
+         @output   = ''
+      end
+
+      def translate_element(elem, level=0)
+         ## check value
+         children = elem.children
+         value = nil
+         if children.length == 1 && children[0].is_a?(Text)
+            text = children[0]
+            str  = text.str
+            value = str if !str.index(?\n)
+         end
+
+         ## create string
+         @output << (@space * level) if level > 0
+         @output << '* ' << elem.tag				## *pattern*
+         @output << " = #{value}" if value
+         @output << @newline
+         elem.attrs.each do |aname, avalue|
+            @output << (@space * (level+1))
+            @output << "- #{aname} = #{avalue}#{@newline}"	## *pattern*
+         end
+         if !value && children.length > 0
+            children.each do |child|
+               translate_element(child, level+1)
+            end
+         end
+         return @output
+      end
+
+      def translate_document(document, level=0)
+         headers = document.headers
+         if headers
+            #if headers[:doctype]
+            #    headers[:doctype] = headers[:doctype].gsub(/\n(.)/, ' \1')
+            #end
+            doctype = headers[:doctype]
+            if doctype && doctype.is_a?(DocType)
+               doctype2 = DocType.find { |dt| dt.public_id && dt.public_id == doctype.public_id }
+               if doctype2 != nil && (nickname = DocType.nickname(doctype2)) != nil
+                  headers[:doctype] = nickname
+               end
+            end
+            headers.each do |key, value|
+               @output ||= ""
+               @output << "?#{key} = #{value.to_s}"		## *pattern*
+               @output << @newline if @output[-1] != ?\n
+            end
+         end
+         translate_element(document.root, level) if document.root
+         return @output
+      end
+
+      def translate_comment(comment, level=0)
+         @output ||= ""
+         @output << @space * level
+         @output << "# #{comment.str}#{@newline}"		## *pattern*
+         return @output
+      end
+
+      def translate_text(text, level=0)
+         @output ||= ""
+         @output << @space * level
+         @output << ". #{text.str}#{@newline}"			## *pattern*
+         return @output
+      end
+
+   end
+
+
+   ##
+   ## convert Kwaff string to XML string
+   ##
+   ## ex.
+   ##   kwaff_str = File.open('file.kwaff') { |f| f.read }
+   ##   xml_str = Kwaff::convert(kwaff_str)
+   ##
+   def self.convert(kwaff_str, toppings={})
+      parser = Parser.new(kwaff_str, toppings)
+      document = parser.parse_document()
+      if !toppings.key?(:newline)
+         toppings[:newline] = parser.newline
+      end
+      translator = Kwaff::XmlTranslator.new(toppings)
+      xml_str = translator.translate(document)
+      return xml_str
+   end
+
+end