shalmaneser-prep 1.2.0.rc4

data/lib/frprep/RegXML.rb

@@ -0,0 +1,269 @@
+# RegXML
+#
+# Katrin Erk June 2005
+
+# SalsaTigerRegXML: take control of the data structure, no underlying xml
+# representation anymore, re-generation of xml on demand
+
+class RegXML
+
+  def initialize(string, # string representing a single XML element
+                 i_am_text = false) # boolean: xml element (false) or text (true)
+
+    unless string.class == String
+      raise "First argument to RegXML.new must be string. I got #{string.class.to_s}"
+    end
+    if i_am_text
+      @s = string
+      @i_am_text = true
+    else
+      @s = string.gsub(/\n/,  " ").freeze
+      @i_am_text = false
+
+      element_test()
+      dyck_test()
+    end
+  end
+
+  def to_s()
+    return xml_readable(@s)
+  end
+  
+  def text?
+    return @i_am_text
+  end
+
+  def name()
+    if @i_am_text
+      # text
+      return nil
+
+    else
+      # xml element
+      if @s =~ /^\s*<\s*([\w-]+)[\s\/>]/
+        return $1
+      else
+        raise "Cannot parse:\n#{xml_readable(@s)}"
+      end
+    end
+  end
+
+  def attributes()
+    if @i_am_text
+      # text
+      return {}
+
+    else
+      #  xml element
+
+      # remove <element_name  from the beginning of @s,
+      # place the rest up to the first > into elt_contents:
+      # this is a string of the form
+      # - either (name=value)*
+      # - or     (name=value)*/
+      unless @s =~ /^\s*<\s*#{name()}(.*)$/
+        raise "Cannot parse:\n #{xml_readable(@s)}"
+      end
+      
+      retv = Hash.new
+      elt_contents = $1
+      
+      # repeat until only > or /> is left
+      while elt_contents !~ /^\s*\/?>/
+        
+        # shave off the next name=value pair
+        # put the rest into elt_contents
+        # make sure that if the value is quoted with ',
+        # we accept " inside the value, and vice versa.
+        unless elt_contents =~ /^\s*([\w-]+)=(['"])(.*?)\2(.*)$/
+          raise "Cannot parse:\n #{xml_readable(elt_contents)}"
+        end
+        retv[$1] = $3
+        elt_contents = $4
+      end
+
+      return retv
+    end
+  end
+
+  def children_and_text()
+    if @i_am_text
+      return []
+
+    else
+      if unary_element()
+        # <bla/>, no children
+        return []
+      end
+      
+      # @s has the form <bla...>  ... </bla>.
+      # remove <bla ...>  from the beginning of @s,
+      # place the rest up to </bla> into children_s:
+      
+      mainname = name()
+      unless @s =~ /^\s*<\s*#{mainname}(\s+[\w-]+=(["']).*?\2)*\s*>(.*?)<\/\s*#{mainname}\s*>\s*$/
+        raise "Cannot parse:\n #{xml_readable(@s)}"
+      end
+      
+      retv = Array.new
+      children_s = $3
+
+      # repeat until only whitespace is left
+      while children_s !~ /^\s*$/
+        
+      # shave off the next bit of text
+        # put the rest into children_s
+        unless children_s =~ /^\s*(.*?)(<.*$|$)/
+          $stderr.puts "Whole was:\n #{xml_readable(@s)}"
+          $stderr.puts 
+          raise "Cannot parse:\n #{xml_readable(children_s)}"
+        end
+        unless $1.strip.empty?
+          children_s = $2
+          retv << RegXML.new($1, true)
+        end
+        
+        # anything left after we've parsed text?
+        if children_s =~ /^s*$/
+          break
+        end
+
+        # shave off the next child
+        # and put the rest into children_s
+
+        # determine the next child's name, and the string index at which
+        # the element start tag ends with either / or >
+        unless children_s =~ /^\s*(<\s*([\w-]+)(\s+[\w-]+=(["']).*?\4)*\s*)/
+          $stderr.puts "Whole was:\n #{xml_readable(@s)}"
+          $stderr.puts 
+          raise "Cannot parse:\n #{xml_readable(children_s)}"
+        end
+        childname = $2
+        child = $1
+        endofelt_ix = $&.length()
+
+        
+        # and remove it
+        case children_s[endofelt_ix..-1]
+        when /^\/>(.*)$/
+          # next child is a unary element
+          children_s = $1
+          retv << RegXML.new(child + "/>")
+
+        when /^(>.*?<\s*\/\s*#{childname}\s*>)(.*)$/
+          children_s = $2
+          retv << RegXML.new(child + $1)
+
+        else
+          $stderr.puts "Whole was:\n #{xml_readable(@s)}"
+          $stderr.puts 
+          raise "Cannot parse:\n#{xml_readable(children_s)}"
+        end
+      end
+
+      return retv
+    end
+  end
+
+  def RegXML.test()
+    bla = RegXML.new("  <bla blupp='a\"b' 
+lalala=\"c\">
+  <lalala> </lalala>
+  texttext
+  <lala blupp='b'/>
+  nochtext
+  <la> <l/> </la>  
+</ bla >
+")
+    puts "name " + bla.name()
+    puts
+    puts bla.to_s()
+    puts
+    bla.attributes.each { |attr, val|
+      puts "attr " + attr + "=" + val
+    }
+    puts
+    bla.children_and_text.each { |child_obj|
+      if child_obj.text?
+        puts "da text " + child_obj.to_s
+      else
+        puts "da child " + child_obj.to_s
+      end
+    }
+    puts
+
+    puts "NEU"
+    bla = RegXML.new("  < bla blupp='a\"'/> ")
+    puts "name " + bla.name()
+    puts
+    puts bla.to_s()
+    puts
+    bla.attributes.each { |attr, val|
+      puts "attr " + attr + "=" + val
+    }
+    puts
+    bla.children_and_text.each { |child_obj|
+      if child_obj.text?
+        puts "da text " + child_obj.to_s
+      else
+        puts "da child " + child_obj.to_s
+      end
+    }
+    puts
+
+  end
+
+  ##############
+  protected
+
+  def unary_element()
+    # <bla/>
+    if @s =~ /^\s*<.*\/>\s*$/
+      return true
+    else
+      return false
+    end
+  end
+
+  def element_test()
+    # make sure we have a single XML element, either <bla/> or
+    # <bla>...</bla>
+    
+    if unary_element()
+      # <bla/>
+    elsif @s =~ /^\s*<\s*([\w-]+)\W.*?<\/\s*\1\s*>\s*$/
+      # <bla  > ... </bla>
+    else
+      raise "Cannot parse:\n #{xml_readable(@s)}"
+    end
+  end
+
+  def dyck_test()
+    # every prefix of @s must have at least as many < as >
+    opening = 0
+    closing = 0
+    @s.scan(/[<>]/) { |bracket|
+      case bracket
+      when "<"
+        opening += 1
+      when ">"
+        closing += 1
+        if closing > opening
+          raise "More closing than opening brackets in prefix of:\n #{xml_readable(@s)}"
+        end
+      end
+    }
+
+    # and in total, @s must have equally many < and >
+    unless @s.count("<") == @s.count(">")
+      raise "Inequal number of brackets in:\n #{xml_readable(@s)}"
+    end
+  end
+
+  def xml_readable(string)
+    return string.gsub(/>/, ">\n")
+  end
+end
+
+# RegXML.test()
+

data/lib/frprep/STXmlTerminalOrder.rb

@@ -0,0 +1,194 @@
+#########
+# module StringTerminalsInRightOrder
+#
+# returns the yield of a node, or a list of nodes, as a string
+# of " "-separated words
+#
+# Words are put into the right order, left to right,
+# under the assumption that their node IDs reflect that order
+#
+# Terminal nodes are assumed to have IDs ending in a number,
+# numbered from left to right
+#
+# Splitword nodes are assumed to have IDs ending in N_sM
+# for numbers N and M, where N orders terminals left to right
+# and M orders the splitword parts left to right
+#
+# If the yield of the node/the list of nodes contains all splitwords of a terminal,
+# the whole terminal is taken instead
+#
+# methods:
+# 
+# string_for_node  returns the string for the yield of a node
+#     node: a node object
+#
+# string_for_nodes returns the string for the yield of a list of nodes
+#     nodes: a list of node objects
+
+module StringTerminalsInRightOrder
+  def string_for_node(node)
+    string_for_nodes([node])
+  end
+
+  def string_for_nodes(nodes)
+    a = right_level_terminals_for_nodes(nodes)
+    a = sort_terminals_and_splitwords_left_to_right(a)
+    return node_array_to_string(a)
+  end
+
+  #####
+  private
+  
+  # right_level_terminals_for_nodes:
+  # - compute the yield for each element of 'nodes'
+  # - then consider all splitwords in the yield:
+  #   if all splitwords of a terminal are in the yield,
+  #   then use the terminal rather than its splitwords
+  def right_level_terminals_for_nodes(nodes)
+    a = nodes.map { |n| n.yield_nodes()}.flatten
+    b = Array.new
+    a.each { |n|
+      if n.is_splitword? 
+	# see if a contains all parts of this splitword
+	# if so, take into b the splitword's parent, the terminal,
+	# rather than the individual splitwords
+
+	if n.parent.nil?
+	  # splitword without a parent
+	  b << n
+	elsif b.include? n.parent or a.include? n.parent
+	  # did we already include the splitword's parent in b?
+	  # then we're done
+	else
+
+	  # check if all children of n.parent are in 'a'
+	  all_in = true
+	  n.parent.each_child { |nsibling|
+	    unless a.include? nsibling
+	      all_in = false
+	      break
+	    end
+	  }
+	  
+	  if all_in
+	    # yes, all children of n.parent are in 'a'
+	    b << n.parent
+	  else
+	    # no, some sibling of n is not in 'a'
+	    b << n
+	  end
+	end
+      elsif n.is_terminal?
+	# n is a terminal
+	b << n
+	# if n is anything but a splitword or a terminal,
+	# ignore it
+      end
+    }
+    return b.uniq
+  end
+
+  # sort_terminals_and_splitwords_left_to_right:
+  # take an array of nodes that consists of terminals and splitwords
+  # and sort them using the following comparison:
+  # - when comparing two terminals, use the 
+  #   last numbers in their respective IDs
+  # - when comparing two splitwords, their IDs end in _N_sM
+  #   for numbers N and M.
+  #   If they coincide in N, compare them by M, 
+  #   else compare them by M
+  # - when comparing a terminal and a splitword,
+  #   compare the terminal's last number to the splitword's N
+  def sort_terminals_and_splitwords_left_to_right(nodes)
+    nodes.sort { |a, b|
+      if a.is_splitword? and b.is_splitword?
+	compare_splitwords(a, b)
+      elsif a.is_terminal? and b.is_terminal?
+	compare_terminals(a, b)
+      else
+	compare_mixed(a, b)
+      end
+    }
+  end
+
+  # node_array_to_string:
+  # 'nodes' is an array of node objects, each of which offer a "word" method
+  # string their words together separated by " "
+  def node_array_to_string(nodes)
+    s = ""
+    nodes.each { |n|
+      s = s + n.word + " "
+    }
+    return s
+  end
+
+  # - when comparing two terminals, use the 
+  #   last numbers in their respective IDs
+  def compare_terminals(a, b)
+    last_i(a) <=> last_i(b)
+  end
+
+  # - when comparing two splitwords, their IDs end in _N_sM
+  #   for numbers N and M.
+  #   If they coincide in N, compare them by M, 
+  #   else compare them by M
+  def compare_splitwords(a, b)
+    if splitword_terminal_i(a) == splitword_terminal_i(b)
+      # parts of same terminal?
+      # compare parts
+      last_i(a) <=> last_i(b)
+    else
+      # not parts of same terminal?
+      # compare terminals
+      splitword_terminal_i(a) <=> splitword_terminal_i(b)
+    end
+  end
+
+  # - when comparing a terminal and a splitword,
+  #   compare the terminal's last number to the splitword's N
+  def compare_mixed(a, b)
+    if a.is_splitword? and b.is_terminal?
+      splitword_terminal_i(a) <=> last_i(b)
+
+    elsif a.is_terminal? and b.is_splitword? 
+       last_i(a) <=> splitword_terminal_i(b)
+    else
+      # not one terminal, one splitword?
+      # then what?
+      $stderr.print "SalsaTigerSentence, compare_mixed: confused by "
+      $stderr.print a.id, ",  ", b.id, "\n"
+    end
+  end
+
+  # return last number of the ID of a node
+  def last_i(n)
+    n.id =~ /(\d+)$/ # match final string of digits
+    if $1.nil? # if shouldn't happen _in principle_
+               # but we might get weird node IDs for splitwords; 
+               # so we act gracefully and catch the case where there
+               # is one final letter behind the digits
+      n.id =~ /(\d+)\w$/
+    end
+    if $1.nil? # this shouldn't ever happen
+      $stderr.print "SalsaTigerSentence, last_i: Couldn't extract digits from: "
+      $stderr.print n.id, "\n"
+      exit 1
+    end
+    return $1.to_i       # and return it as number
+  end
+
+  # assume the ID of the node includes N_sM
+  # return N
+  def splitword_terminal_i(n)
+    n.id =~ /(\d+)_s\d*/ # match string of digits before splitword ID
+    if $1.nil? # this shouldn't ever happen
+      $stderr.print "SalsaTigerSentence, splitword_terminal_i: Couldn't extract digits from: "
+      $stderr.print n.id, "\n"
+      exit 1
+    end
+    return $1.to_i       # and return it as number
+  end
+    
+end
+
+