shalmaneser-lib 1.2.rc5

data/lib/salsa_tiger_xml/syn_node.rb

@@ -0,0 +1,169 @@
+require_relative 'salsa_tiger_xml_node'
+
+module STXML
+#############
+# class SynNode
+#
+# inherits from SalsaTigerXmlNode,
+# adds to it methods specific to nodes
+# that describe the syntactic structure
+#
+# additional/changed methods:
+#
+# part_of_speech  part_of_speech information as a string,
+#         nil for anything but terminal nodes
+#
+# word    word information for this node as a string,
+#         nil for anything but terminal nodes
+#
+# category category information for this node as a string,
+#         nil for anything but nonterminal nodes
+#
+# is_punct?       true if this is a terminal node and it is a punctuation sign
+#
+# get_sem  add a non-tree edge from this syntactic node to a semantic node
+#         Idea: this is basically the inverse of the edge pointing from
+#         the FeNode to this SynNode, so you can fetch a node's semantics directly
+#
+# add_sem add non-tree edge from this syntactic node to a FeNode
+class SynNode < SalsaTigerXmlNode
+
+  ###
+  def initialize(xml)
+    super(xml)
+
+    @sem = []
+    @other_links = []
+  end
+
+  ###
+  def add_link(other_node,        # SynNode
+               link_label,        # string: edge label
+               attributes = {})   # hash string>string: further attribute-value pairs for the edge
+
+    @other_links << [link_label, other_node, attributes]
+  end
+
+  ###
+  def get_linked(label = nil)  # string/nil: if string, use only linked with this link_label
+    if label
+      return @other_links.select { |label_node_attr| label_node_attr.first == label }
+    else
+      return @other_links
+    end
+  end
+
+  ###
+  def part_of_speech
+    if get_attribute("pos")
+      return get_attribute("pos").strip
+    else
+      return nil
+    end
+  end
+
+  ###
+  def category
+    if get_attribute("cat")
+      return get_attribute("cat").strip
+    else
+      return nil
+    end
+  end
+
+  ###
+  def word
+    if get_attribute("word")
+      return get_attribute("word").strip
+    else
+      return nil
+    end
+  end
+
+  ###
+  def is_punct?
+    if is_nonterminal?
+      # only terminals can be punctuation signs
+      return false
+    end
+
+    # next check part of speech
+    # this works at least for TIGER corpus annotation
+    case part_of_speech
+    when '$.', '$,', '$('
+      return true
+    end
+    if part_of_speech =~ /^PUNC/
+      return true
+    end
+
+    # known punctuation signs: filtered out for determining maximal constituents
+
+    # no luck with part of speech:
+    # check word
+    case word
+    when ".", ";", ",", ":", "?", "!", "(", ")", "[", "]", "{", "}", "-", "''", "``", "\"", "'"
+      return true
+    end
+
+    # not a punctuation sign by any of the tests we have applied
+    return false
+  end
+
+  ###
+  def to_s
+    if is_terminal?
+      return word
+    else
+      return super()
+    end
+  end
+
+  ###
+  def get_sem
+    return @sem.clone
+  end
+
+  ###
+  def add_sem(fe_node)
+    unless fe_node.class == FeNode
+      raise "Unexpected class of semantic node: was expecting an FeNode"
+    end
+
+    @sem << fe_node
+  end
+
+  #############
+  protected
+
+  def get_xml_ofchildren
+    string = ""
+
+    each_child_with_edgelabel { |label, child|
+      unless child.is_splitword?
+        # terminal or nonterminal child.
+        # splitwords are handled separately in the "sem" part of the sentence
+        if label
+          string << "<edge label=\'#{xml_secure_val(label)}\' idref=\'#{xml_secure_val(child.id)}\'/>\n"
+        else
+          string << "<edge label=\'-\' idref=\'#{xml_secure_val(child.id)}\'/>\n"
+        end
+      end
+    }
+    @other_links.each { |label, node, attributes|
+      if label
+        string << "<other_edge label=\'#{xml_secure_val(label)}\'"
+      else
+        string << "<other_edge label=\'-\'"
+      end
+      string <<  " idref=\'#{xml_secure_val(node.id)}\'"
+      if attributes
+        string << " " + attributes.to_a.map { |attr, val| "#{xml_secure_val(attr)}=\'#{xml_secure_val(val)}\'" }.join(" ")
+      end
+      string << "/>\n"
+    }
+
+    return string
+  end
+end
+end

data/lib/salsa_tiger_xml/tree_node.rb

@@ -0,0 +1,59 @@
+require_relative 'graph_node'
+
+module STXML
+class TreeNode < GraphNode
+
+  def initialize(id)
+    super(id)
+  end
+
+  # redo the ancestor-related methods,
+  # since here we only have one parent per node
+  def parent
+    retv = parents
+    if retv.nil?
+      return nil
+    else
+      return retv.first
+    end
+  end
+
+  def parent_label
+    retv = parent_labels
+    if retv.nil?
+      return nil
+    else
+      return retv.first
+    end
+  end
+
+  def parent_with_edgelabel
+    retv = parents_with_edgelabel
+
+    if retv.nil?
+      return nil
+    else
+      return retv.first
+    end
+  end
+
+  def add_parent(parent, edgelabel, varhash = {})
+    set_parent(parent, edgelabel, varhash)
+  end
+
+  def set_parent(parent, edgelabel, varhash = {})
+    # remove old parent
+    each_parent_with_edgelabel { |label, p| remove_parent(p, label, varhash) }
+
+    # set new parent
+    @parents << [edgelabel, parent]
+
+    # and vice versa: add self as child to parent
+    unless varhash["pointer_insteadof_edge"]
+      unless parent.children_with_edgelabel.include? [edgelabel, self]
+        parent.add_child(self, edgelabel)
+      end
+    end
+  end
+end
+end

data/lib/salsa_tiger_xml/ts_syn_node.rb

@@ -0,0 +1,47 @@
+require_relative 'syn_node'
+require_relative 'reg_xml'
+
+module STXML
+#############
+# class TSSynNode
+#
+# inherits from SynNode
+#
+# describes a syntactic node that isn't really there:
+# a reference to a node in another sentence
+#
+# contains that node's ID, but an empty RegXML object,
+# its string is "<unknown>", and you cannot add
+# a child to it
+#
+# new or changed methods:
+#-----------------------
+#
+# is_outside_sentence? returns true
+#
+# word                 returns "<unknown>"
+#
+# add_child raises an error
+class TSSynNode < SynNode
+
+  ###
+  def initialize(id_string)
+    super(RegXML.new("<OTHER_SENTENCE id='" + id_string + "'/>"))
+  end
+
+  ###
+  def is_outside_sentence?
+    return true
+  end
+
+  ###
+  # word of this node: <unknown>
+  def word
+    return "<unknown>"
+  end
+
+  def add_child(arg1, arg2)
+    raise "Not implemented for this class"
+  end
+end
+end

data/lib/salsa_tiger_xml/usp_node.rb

@@ -0,0 +1,72 @@
+require_relative 'salsa_tiger_xml_node'
+
+module STXML
+#############
+# class UspNode
+#
+# inherits from SalsaTigerXmlNode,
+# adds to it methods specific to nodes
+# that describe a frame underspecification or frame element underspecification
+#
+# additional/changed methods:
+#----------------------------
+#
+# new             initializes the object
+#    rexml_object: underlying XML object for this node
+#    frame_or_fe:  string, either "frame" for frame underspecification
+#                  or "fe" for frame element underspecification
+#
+# add_child, remove_child   add, remove underspecification entry
+class UspNode <  SalsaTigerXmlNode
+
+  attr_reader :i_am
+
+  ###
+  def initialize(xml_obj,      # RegXMl object
+                 frame_or_fe)  # string "frame" or "fe"
+
+    super(xml_obj)
+    case frame_or_fe
+    when "frame"
+      @i_am = "frame"
+    when "fe"
+      @i_am = "fe"
+    else
+      raise "new: neither frame nor fe??"
+    end
+  end
+
+  ###
+  def add_child(node, varhash={})
+    if node
+      super(node, nil, "pointer_insteadof_edge" => true)
+    else
+      raise "Got nil for a node."
+    end
+
+    # set usp. attribute on child
+    node.set_attribute("usp", "yes")
+  end
+
+  ###
+  def remove_child(node, varhash={})
+    super(node, nil, "pointer_insteadof_edge" => true)
+
+    # removing "usp" attribute on child
+    # this will be wrong if the child is involved in more
+    # than one instance of underspecification!
+
+    $stderr.puts "Warning: unsafe removal of attribute 'usp'"
+    node.del_attribute("usp")
+  end
+
+  #############
+  protected
+
+  def get_xml_ofchildren
+    return children.map { |child|
+      "<uspitem idref=\'#{xml_secure_val(child.id)}\'/>\n"
+    }.join
+  end
+end
+end

data/lib/salsa_tiger_xml/xml_node.rb

@@ -0,0 +1,163 @@
+require_relative 'tree_node'
+
+module STXML
+#############
+# class XMLNode
+#
+# node with entries pointing to its children
+# as well as its parent.
+# all edges may be labeled.
+# each node has a unique ID.
+#
+# indexes a string with XML data representing the same node,
+# but does not look into it, just keeps it
+#
+# methods:
+# This class inherits from TreeNode and GraphNode.
+# See Tree.rb and Graph.rb for the methods they offer.
+#
+# new        initializes the object
+#
+# get        returns the XML object representing
+#            the same node as this node object
+#
+class XMLNode < TreeNode
+
+  # @param name [String] element name; or, for text, the whole text
+  # @param attribute [Hash] attr_name(string) -> attr_value(string)
+  # @param id [String] node ID
+  # @param i_am_text [false, true] set to anything but false or nil to represent
+  #                                not an xml element but text
+  def initialize(name, attribute, id, i_am_text = false)
+
+    if id.nil?
+      # I wasn't given any ID
+      # take system time for an ID
+      # use to_f to get fractions of seconds too:
+      # If I make several nodes in the same second,
+      # they should still have unique IDs
+      id = Time.new.to_f.to_s
+    end
+
+    super(id)
+
+    # remember values for this element
+    set_f("name", name)
+    set_f("attributes", attribute)
+    set_f("i_am_text", i_am_text)
+
+    # sanity check
+    if i_am_text and attributes
+      raise "A text element cannot have attributes"
+    end
+
+    @kith = []
+  end
+
+  ###
+  # add sanity check:
+  # if this is text rather than an xml element,
+  # it cannot have children
+  def add_child(child, edgelabel, varhash={})
+    if get_f("i_am_text")
+      raise "A text element cannot have children"
+    end
+    super(child, edgelabel, varhash)
+  end
+
+  ###
+  def add_kith(xml) # RegXML object
+    @kith << xml
+  end
+
+  ###
+  # set attribute
+  # @param value [String]
+  def set_attribute(name, value)
+    unless value.class == String
+      raise "I can only set attribute values to strings. Got: #{value.class}."
+    end
+
+    if get_f("attributes").nil?
+      set_f("attributes", {})
+    end
+    get_f("attributes")[name] = value
+  end
+
+  ###
+  def get_attribute(name)
+    if get_f("attributes")
+      return get_f("attributes")[name]
+    else
+      return nil
+    end
+  end
+
+  ###
+  # delete attribute
+  def del_attribute(name)
+    if get_f("attributes")
+      get_f("attributes").delete(name)
+    end
+  end
+
+  ###
+  # return XML as string:
+  # If this is a text, just return the text
+  # which is stored in "name"
+  # If this is an XMl element,
+  # make a tag from its name and attributes,
+  # then add tags for all its children,
+  # then add an end tag.
+  def get
+    if get_f("i_am_text")
+      # text rather than XML element
+      return get_f("name")
+    else
+      # XMl element, not text
+      string = "<" + get_f("name")
+      if get_f("attributes")
+        string << get_f("attributes").to_a.map { |name, value|
+          " " + name + "=\'" + xml_secure_val(value) + "\'"
+        }.join
+      end
+      string << ">\n"
+      string << get_xml_embedded
+      string << "</#{get_f("name")}>\n"
+      return string
+    end
+  end
+
+  #############
+  protected
+
+  def get_xml_embedded
+    return get_xml_ofchildren +
+           get_xml_ofkith
+  end
+
+
+  def get_xml_ofchildren
+    return children.map { |child|
+      child.get
+    }.join
+  end
+
+
+  def get_xml_ofkith
+    return @kith.map { |thing| thing.to_s + "\n" }.join
+  end
+
+
+  ###
+  def warn_child_ignored(where, xml_node)
+    $stderr.puts "WARNING: additional material found in #{where}, will be ignored:"
+    $stderr.puts "\t" + xml_node.to_s
+  end
+
+  ###
+  def xml_secure_val(value) # string: value of an attribute
+    value.gsub(/'/, "&apos;").gsub(/"/, "&apos;&apos;")
+  end
+end
+end