shalmaneser-lib 1.2.rc5

data/lib/salsa_tiger_xml/salsa_tiger_sentence_graph.rb

@@ -0,0 +1,333 @@
+require_relative 'xml_node'
+require_relative 'string_terminals_in_right_order'
+require_relative 'reg_xml'
+
+module STXML
+#############
+class SalsaTigerSentenceGraph < XMLNode
+  include StringTerminalsInRightOrder
+
+  attr_reader :node
+
+  def initialize(xml_obj,     # RegXML object
+                 sentence_id) # string: ID of this sentence
+
+    # global data:
+    # node: hash node_id -> XMLNode object
+    #       maps node IDs to the nodes with that ID
+    @node = {}
+    @sentence_id = sentence_id
+
+    if xml_obj
+      # we actually have syntactic information.
+      # read it.
+
+      # initialize this object as an XML node,
+      # i.e. remember the outermost element's name, attributes,
+      # and ID, and specify that it's not a text but an XML object
+      super(xml_obj.name, xml_obj.attributes, sentence_id + "_graph", false)
+
+      # initialize nodes, remember their IDs
+      xml_obj.children_and_text.each { |child_or_text|
+
+        case child_or_text.name
+        when "terminals"
+          make_nodes(child_or_text, "t", "s/graph/terminals", "all_children_kith")
+        when "nonterminals"
+          make_nodes(child_or_text, "nt", "s/graph/nonterminals")
+        else
+          # additional info that we don't need for now
+          # keep for output
+          add_kith(child_or_text)
+        end
+      }
+
+
+
+      # add edges between nodes
+      nonterminals = xml_obj.children_and_text.detect { |child| child.name == "nonterminals" }
+      if nonterminals
+        nonterminals.children_and_text.each { |nt|
+
+          unless nt.name == "nt"
+            # we've already done the warning bit in make_nodes
+            next
+          end
+
+          syn_add_children(@node[SalsaTigerXmlNode.xmlel_id(nt)], nt)
+        }
+      end
+
+    else
+      # we have no syntactic information
+      # record it anyway
+
+      super("graph", {}, sentence_id + "_graph", false)
+    end
+  end
+
+
+  ###
+  def add_splitwords(xml_obj)  #RegXMl object
+    unless xml_obj.nil?
+      # splitwords is an XML element with name "splitwords" and
+      # children named "splitword", each of which describes a split
+      # for one of the terminals we already know
+      xml_obj.children_and_text.each { |splitword|
+        unless splitword.name == "splitword"
+          warn_child_ignored("s/sem/splitwords/", splitword)
+          next
+        end
+
+        # make nodes for the splitword parts
+        make_nodes(splitword, "part", "s/sem/splitwords/splitword", "all_children_kith")
+
+        # this is the terminal that is being split:
+        # add links to its new children
+        syn_add_children(@node[SalsaTigerXmlNode.xmlel_id(splitword)], splitword)
+      }
+    end
+  end
+
+  ###
+  def to_s
+    string_for_nodes(syn_roots)
+  end
+
+  ###
+  def get
+    # make sure that the graph element has a 'root' attribute
+    # since the Salsa tool needs this
+    set_attribute("root", syn_roots.first.id)
+    super()
+  end
+
+  #####
+  # access methods
+
+  ###
+  def each_node
+    @node.each_value { |n|
+      yield n
+    }
+  end
+
+  ###
+  def nodes
+    return @node.values
+  end
+
+  ###
+  def each_terminal
+    @node.each_value { |node|
+      if node.is_terminal?
+        yield node
+      end
+    }
+  end
+
+  ###
+  def each_terminal_sorted
+    sort_terminals_and_splitwords_left_to_right(terminals).each { |node_obj|
+      yield node_obj
+    }
+  end
+
+  ###
+  def terminals
+    return @node.values.select { |node| node.is_terminal? }
+  end
+
+  ###
+  def terminals_sorted
+    return  sort_terminals_and_splitwords_left_to_right(terminals)
+  end
+
+  ###
+  def each_nonterminal
+    @node.each_value { |node|
+      if node.is_nonterminal?
+        yield node
+      end
+    }
+  end
+
+  ###
+  def nonterminals
+    return @node.values.select { |node| node.is_nonterminal? }
+  end
+
+  ###
+  def syn_roots
+    return @node.values.select { |node|
+      node.parent.nil?
+    }
+  end
+  ###
+
+  ######################3
+  # adding nodes
+
+  ###
+  def add_child(arg1, arg2, varhash={})
+    raise "Not implemented for this class"
+  end
+
+  ###
+  def remove_child(arg1, arg2, varhash={})
+    raise "Not implemented for this class"
+  end
+
+  ###
+  def add_node(sentid,    # string: sentence ID
+               label,     # string: t or nt
+               cat = nil, # string: category
+               word = nil,# string: word
+               pos = nil, # string: part of speech
+               syn_id = nil)   # string: ID for the new node
+
+    unless ["t", "nt"].include? label
+      raise "Unknown node label #{label} for new syntactic node. Must be either t or nt."
+    end
+
+    # make node ID: sentence ID plus ID generated by system time
+    if syn_id
+      new_id = sentid + "_" + syn_id
+    else
+      new_id = sentid + "_" + Time.new.to_f.to_s
+    end
+
+    elt = "<#{label}"
+    [["id", new_id], ["cat", cat], ["word", word], ["pos", pos]].each { |lbl, content|
+      if content
+        elt << " #{lbl}=\"#{xml_secure_val(content)}\""
+      end
+    }
+    elt << "/>"
+    n = SynNode.new(RegXML.new(elt))
+    @node[n.id] = n
+
+    return n
+  end
+
+  ###
+  def remove_node(node) # SynNode
+    # remove node from list
+    @node.delete(node.id)
+
+    # remove it as child and parent of other nodes;
+    # add its own children to the parent.
+    # the _edgelabel_ of the new edges will be the edgeslabels
+    # between the original node in its children
+    # in other words, the label of the removed node's incoming edge
+    # is deleted
+
+    pair = node.parent_with_edgelabel
+    if pair
+    # delete incoming edge for deleted node
+      label, parent = pair
+      parent.remove_child(node, label)
+    end
+    # delete outgoing edge for deleted node
+    node.each_child_with_edgelabel { |lbl, child| child.remove_parent(node, lbl) }
+    # glue deleted node's children to its parent
+    if pair
+      _plabel, parent = pair
+      node.each_child_with_edgelabel { |clabel, child| parent.add_child(child, clabel) }
+    end
+  end
+
+  ######################
+  protected
+
+  ###
+  def get_xml_ofchildren
+    string = ""
+
+    string << "<terminals>\n"
+    each_terminal_sorted { |t|
+      string << t.get
+    }
+    string << "</terminals>\n"
+
+    string << "<nonterminals>\n"
+    each_nonterminal { |nt|
+      string << nt.get
+    }
+    string << "</nonterminals>\n"
+
+    return string
+
+  end
+
+  def make_nodes(xml_obj,  # RegXML object
+                 expected_obj_name, # string
+                 where, # string
+                 all_children_kith = nil) # object: if non-nil,
+                                          # keep all children of the new nodes
+                                          # as kith"
+
+    xml_obj.children_and_text.each { |elt|
+
+      if elt.name == expected_obj_name
+        # this is the kind of child we were expecting to see
+        n = SynNode.new(elt)
+        @node[n.id] = n
+
+        if all_children_kith
+          elt.children_and_text.each { |elt_child|
+            n.add_kith(elt_child)
+          }
+        end
+
+      else
+        warn_child_ignored(where, elt)
+      end
+    }
+  end
+
+  def syn_add_children(node,
+                       xml_obj)
+    unless node
+      raise "Shouldn't be here"
+    end
+
+    xml_obj.children_and_text.each { |edge|
+
+      if ["edge", "part"].include? edge.name
+
+        # add an edge to this child,
+        # retrieve the node with the given ID from id_to_node
+        child = @node[SalsaTigerXmlNode.xmlel_id(edge)]
+        unless child
+          raise "Sentence #{@sentence_id}: I cannot find a node for " + edge.to_s
+        end
+
+        edgelabel = edge.attributes["label"]
+        node.add_child(child, edgelabel)
+
+      elsif edge.name == "other_edge"
+        # add link to this node,
+        # retrieve the node with the given ID from id_to_node
+        child = @node[SalsaTigerXmlNode.xmlel_id(edge)]
+        unless child
+          raise "Sentence #{@sentence_id}: I cannot find a node for other_edge #{SalsaTigerXmlNode.xmlel_id(edge)} : " + edge.to_s
+        end
+
+        attributes = edge.attributes
+        if attributes
+          edgelabel = attributes.delete("label")
+        else
+          edgelabel = nil
+        end
+        node.add_link(child, edgelabel, attributes)
+
+      else
+        # something other than an edge
+        # keep for output
+        node.add_kith(edge)
+      end
+    }
+  end
+end
+end

data/lib/salsa_tiger_xml/salsa_tiger_sentence_sem.rb

@@ -0,0 +1,438 @@
+require_relative 'xml_node'
+require_relative 'ts_syn_node'
+require_relative 'salsa_tiger_xml_node'
+require_relative 'usp_node'
+require_relative 'frame_node'
+require_relative 'fe_node'
+require_relative 'reg_xml'
+
+module STXML
+#############
+class SalsaTigerSentenceSem < XMLNode
+
+  attr_reader :node
+
+  ###
+  def SalsaTigerSentenceSem.get_splitwords(xml_obj)
+    return xml_obj.children_and_text.detect { |child|
+      child.name == "splitwords"
+    }
+  end
+
+  ###
+  def initialize(xml_obj,      # RegXML object
+                 sentence_id,  # string: sentence ID
+                 id_to_node)   # hash: syn_node_id(string) -> SynNode object
+
+    # global data:
+    # node: hash node_id -> XMLNode object
+    #       maps node IDs to the nodes with that ID
+    # frame_id, uspframe_id, uspfe_id: arrays of node IDs,
+    #   listing all frame nodes, frame underspecification nodes,
+    #   and FE underspecification nodes respectively
+    # globals: array of RegXML objects, each representing one sentence flag
+    @node = {}
+    @frame_id = []
+    @uspframe_id = []
+    @uspfe_id = []
+    @globals = []
+
+    if xml_obj
+      # we actually have semantic information.
+      # read it.
+
+      super(xml_obj.name, xml_obj.attributes, sentence_id + "_sem", false)
+
+      globals_obj = frames_obj = usp_obj = nil
+
+      xml_obj.children_and_text.each { |obj|
+        case obj.name
+        when "globals"
+          globals_obj = obj
+        when "frames"
+          frames_obj = obj
+        when "usp"
+          usp_obj = obj
+        else
+          add_kith(obj)
+        end
+      }
+
+      # handle globals
+      if globals_obj
+        globals_obj.children_and_text.each { |obj|
+          @globals << obj
+        }
+      end
+
+      # index frames
+      if frames_obj
+        frames_obj.children_and_text.each { |frame|
+          unless frame.name == "frame"
+            warn_child_ignored("s/sem/frames/", frame)
+            next
+          end
+
+          # make a node for the frame.
+          node = FrameNode.new(frame)
+          semnode_add_flags(node, frame)
+          @node[node.id] = node
+          @frame_id << node.id
+          # add FEs
+          frame_add_children(node, frame, id_to_node)
+        }
+      end
+
+      # index underspecification
+      if usp_obj
+        usp_obj.children_and_text.each { |uspframe_or_fe|
+          case uspframe_or_fe.name
+          when "uspframes"
+            initialize_usp(uspframe_or_fe, "frame")
+          when "uspfes"
+            initialize_usp(uspframe_or_fe, "fe")
+
+          else
+            warn_child_ignored("s/sem/usp/", uspframe_or_fe)
+          end
+        }
+      end
+
+    else
+      # we have no semantic information
+      # record it anyway
+
+      super("sem", {}, sentence_id + "_sem", false)
+    end
+  end
+
+  ################################################3
+  # access methods
+
+  ###
+  def each_frame
+    @frame_id.each { |node_id|
+      yield @node[node_id]
+    }
+  end
+
+  ###
+  def frames
+    return @frame_id.map { |node_id| @node[node_id] }
+  end
+
+  ###
+  def each_usp_frameblock
+    @uspframe_id.each { |node_id|
+      yield @node[node_id]
+    }
+  end
+
+  ###
+  def usp_frameblocks
+    return @uspframe_id.map { |node_id| @node[node_id] }
+  end
+
+  ###
+  def each_usp_feblock
+    @uspfe_id.each { |node_id|
+      yield @node[node_id]
+    }
+  end
+
+  ###
+  def usp_feblocks
+    return @uspfe_id.map { |node_id| @node[node_id] }
+  end
+
+  ###
+  def flags
+    return @globals.map { |xml_obj|
+      { "type" => xml_obj.attributes["type"],
+       "param" => xml_obj.attributes["param"],
+       "text" => xml_obj.children_and_text.map { |c| c.to_s }.join
+      }
+    }
+  end
+
+  ################################################3
+  # adding and removing things
+
+  ###
+  def add_frame(sentid,  # string: sentence ID
+                name,    # string: name of the frame
+                sem_id = nil) # string: ID for the new node
+
+    # make a node for the frame
+    if sem_id
+      frameid = sem_id
+    else
+      frameid = sentid + "_f" + Time.new.to_f.to_s
+    end
+    n = FrameNode.new(RegXML.new("<frame id=\"#{frameid}\" name=\"#{name}\"/>"))
+    @node[n.id] = n
+    @frame_id << n.id
+
+    return n
+  end
+
+  ###
+  def remove_frame(frame_node)
+    @node.delete(frame_node.id)
+    @frame_id.delete(frame_node.id)
+  end
+
+  ###
+  def add_fe(frame_node, # FrameNode
+             fe_name,    # string: name of new FE
+             fe_children, # array:SynNode, children of new FE
+             sem_id = nil) # optional: ID of new FE
+
+
+    new_fe = frame_node.add_fe(fe_name, fe_children, sem_id)
+    @node[new_fe.id] = new_fe
+    return new_fe
+  end
+
+  ###
+  def remove_fe(fe_node)
+    @node.delete(fe_node.id)
+    fe_node.parent.remove_child(fe_node)
+  end
+
+  ###
+  def add_usp(frame_or_fe)    # string: "frame" or "fe"
+
+    n = UspNode.new(RegXML.new("<uspblock/>"), frame_or_fe)
+    @node[n.id] = n
+    case frame_or_fe
+    when "frame"
+      @uspframe_id << n.id
+    when "fe"
+      @uspfe_id << n.id
+    else
+      raise "Shouldn't be here"
+    end
+
+    return n
+  end
+
+  ###
+  def remove_usp(usp_node)
+    usp_node.children.each { |child|
+      usp_node.remove_child(child)
+    }
+    @node.delete(usp_node.id)
+    case usp_node.i_am
+    when "frame"
+      @uspframe_id.delete(usp_node.id)
+    when "fe"
+      @uspfe_id.delete(usp_node.id)
+    else
+      raise "Shouldn't be here"
+    end
+  end
+
+
+  ###
+  def add_child(arg1, arg2)
+    raise "Not implemented for this class"
+  end
+
+  ###
+  def remove_child(arg1, arg2)
+    raise "Not implemented for this class"
+  end
+
+  ###
+  def add_flag(type, param=nil, text=nil)
+#    unless ["REEXAMINE", "WRONGSUBCORPUS", "INTERESTING", "LATER"].include? type
+#      raise "add_flag: unknown type "+type
+#    end
+
+    newglob = "<global type=\'#{xml_secure_val(type)}\'"
+    if param
+      newglob << " param=\'#{xml_secure_val(param)}\'"
+    end
+    if text
+      newglob << "> #{text} </global>"
+    else
+      newglob << "/>"
+    end
+
+    newglob = RegXML.new(newglob)
+    @globals << newglob
+    return newglob
+  end
+
+  ###
+  def remove_flag(type, param=nil, text=nil)
+
+    remove_ix = nil
+    @globals.each_with_index { |glob,ix|
+      if glob.attributes("type") == type
+        if param.nil? or glob.attributes("param") == param
+          if text.nil? or glob.children_and_text.map { |c| c.to_s }.join == text
+            # found it
+            remove_ix = ix
+            break
+          end
+        end
+      end
+    }
+
+    if remove_ix
+     return  @globals.delete_at(remove_ix)
+    else
+      return nil
+    end
+  end
+
+  ############################3
+  protected
+
+  def get_xml_ofchildren
+    string = ""
+
+    # globals
+    string << "<globals>\n"
+    @globals.each { |glob|
+      string << glob.to_s + "\n"
+    }
+    string << "</globals>\n"
+
+    # frames
+    string << "<frames>\n"
+    each_frame { |frame_node|
+      string << frame_node.get
+    }
+    string << "</frames>\n"
+
+    # underspecification
+    string << "<usp>\n"
+    string << "<uspframes>\n"
+    each_usp_frameblock { |block|
+      string << block.get
+    }
+    string << "</uspframes>\n"
+    string << "<uspfes>\n"
+    each_usp_feblock { |block|
+      string << block.get
+    }
+    string << "</uspfes>\n"
+    string << "</usp>\n"
+
+    return string
+  end
+
+  ###
+  def semnode_add_flags(sem_node,  # SemNode object
+                        xml_obj)   # RegXML object
+
+    xml_obj.children_and_text.each { |child|
+      if child.name == "flag"
+        # found a flag, record it
+        name = child.attributes["name"]
+        if name
+          sem_node.add_flag(name)
+        else
+          $stderr.puts "Warning: flag without a name"
+        end
+      end
+    }
+  end
+
+  def frame_add_children(frame_node, # FrameNode object
+                         xml_obj,    # RegXML object
+                         id_to_node) # hash: syn_node_id(string) -> SynNode object
+
+    xml_obj.children_and_text.each { |fe|
+      case fe.name
+      when "fe", "target"
+#        $stderr.puts "Da: #{fe.name}\n#{fe.to_s}"
+
+        # make a node for this,
+        # and add it as child of this frame node.
+        fe_node = FeNode.new(fe)
+        @node[fe_node.id] = fe_node
+        frame_node.add_child(fe_node)
+
+        semnode_add_flags(fe_node, fe)
+
+        # add the FE's children
+        fe.children_and_text.each { |fechild|
+          case fechild.name
+          when "fenode"
+
+            syn_node = id_to_node[SalsaTigerXmlNode.xmlel_id(fechild)]
+            if syn_node
+              # normal syntactic node, which the id_to_node mapping knows
+              fe_node.add_child(syn_node, fechild)
+              syn_node.add_sem(fe_node)
+
+            else
+              # must be a node in a different sentence
+              # make a dummy graph node for it
+              fe_node.add_child(TSSynNode.new(SalsaTigerXmlNode.xmlel_id(fechild)), fechild)
+            end
+
+          when "flag"
+            # nothing to do, we've handled that already
+          else
+            fe_node.add_kith(fechild)
+          end
+        }
+
+      when "flag"
+        # nothing to do, wee handled that already
+
+      else
+        # keep for output
+        frame_node.add_kith(fe)
+      end
+    }
+  end
+
+  ###
+  def initialize_usp(xml_obj,      # RegXML object
+                     frame_or_fe)  # string: "frame" or "fe"
+
+    xml_obj.children_and_text.each { |uspblock|
+      unless uspblock.name == "uspblock"
+        warn_child_ignored("s/sem/usp/uspframe|uspfe", uspblock)
+        next
+      end
+
+      # node for this underspecified block
+      n = UspNode.new(uspblock, frame_or_fe)
+      @node[n.id] = n
+
+      case frame_or_fe
+      when "frame"
+        @uspframe_id << n.id
+      when  "fe"
+        @uspfe_id << n.id
+      else
+        raise "Shouldn't be here"
+      end
+
+      # add its children
+      uspblock.children_and_text.each { |uspitem|
+        unless uspitem.name == "uspitem"
+          warn_child_ignored("s/sem/usp/uspframe|uspfe/uspblock", uspitem)
+          next
+        end
+
+        usp_id = SalsaTigerXmlNode.xmlel_id(uspitem)
+        usp_id = usp_id.gsub(/.*_s/, "s")
+
+        unless @node[usp_id]
+          $stderr.puts "Error: Underspecification: could not find node with ID #{usp_id}. Skipping."
+          next
+        end
+        n.add_child(@node[usp_id])
+      }
+    }
+  end
+end
+end