odin 0.0.4

data/simple_atn/README.md

@@ -0,0 +1,45 @@
+simple_atn
+==========
+
+The version of the ATN framework and sample ATN that was produced during prototyping.  I'm happy with how it turned out.  It should be pretty easy on the eyes.  Example function call:
+
+    push(:noun_phrase, position, registers, :into => :object_of_preposition, :next => :prepositional_phrase__noun_phrase)
+
+There's no frontend.  Running `rake` (or `ruby augmented_transition_network_test.rb`, if you don't have rake installed) in the root of this directory will run the unit tests.  I've left a sample parse of the nonsensical sentence 'the monster in the man grows avocados in the street' uncommented so that you can see some output.  You should receive this at the command prompt:
+
+    Loaded suite augmented_transition_network_test
+    Started
+    ....
+    :sentence
+        :noun_phrase
+            :determiner
+            "the"
+            :noun
+            "monster"
+            :prepositional_phrase
+                :preposition
+                "in"
+                :noun_phrase
+                    :determiner
+                    "the"
+                    :noun
+                    "man"
+        :verb
+        "grows"
+        :noun_phrase
+            :noun
+            "avocados"
+            :prepositional_phrase
+                :preposition
+                "in"
+                :noun_phrase
+                    :determiner
+                    "the"
+                    :noun
+                    "street"
+    ..
+    Finished in 0.02785 seconds.
+    
+    6 tests, 48 assertions, 0 failures, 0 errors
+
+The vocabulary of this ATN is quite limited -- see `string.rb`.  I have more in-depth categorization routines in the parent directory -- I didn't see a huge need to include them here -- it would have only taken longer.  Also, the grammar the ATN represents isn't too entirely complicated.  I spent most of my time paring the former code down so that it could be manageable.  At the moment, only noun phrases, prepositional phrases, verb phrases, and (of course) sentences are defined.  The important part is that it handles non_determinism gracefully.  Also of note, the ATN computes the deep structure of passive sentences by the same mechanism as given during class.

data/simple_atn/Rakefile

@@ -0,0 +1,9 @@
+task :default => "test"
+task :test => ["test:units"]
+
+namespace "test" do
+  task :units do
+    require 'rake/runtest'
+    Rake.run_tests "*_test.rb"
+  end
+end

data/simple_atn/array.rb

@@ -0,0 +1,15 @@
+class Array
+  def inspect_as_tree(indentation = 4, level = 0)
+    tree = ""
+    
+    self.each do |item|
+      if item.respond_to?(:inspect_as_tree)
+        tree << item.inspect_as_tree(indentation, level + indentation)
+      else
+        tree << "#{" " * level}#{item.inspect}\n"
+      end
+    end
+    
+    return tree
+  end
+end

data/simple_atn/augmented_transition_network.rb

@@ -0,0 +1,146 @@
+require File.dirname(__FILE__) + '/string'
+require File.dirname(__FILE__) + '/array'
+
+class Ungrammatical < Exception; end
+
+class AugmentedTransitionNetwork
+  def initialize(language = :en)
+    if :en == language
+      require File.dirname(__FILE__) + '/english'
+      extend English
+    end
+    clear!
+  end
+  
+  def parse(words, start_node = :sentence)
+    clear!
+    @words = words.dup
+    @words.freeze
+    send(start_node, 0, Hash.new)
+    # The result for the network traversal is located in @star.
+    return @star
+  end
+  
+  def parse_to_string(words, start_node = :sentence)
+    parsed = parse(words, start_node)
+    return parsed.inspect.matches_for(/".*?"/).join(" ").gsub("\"", '')
+  end
+  
+  private
+    def clear!
+      @star = nil
+      @words = []
+    end
+    
+    # Tag a word or phrase with a functional role.
+    #
+    # For example, a single word may be labeled :noun.
+    # A phrase (multiple words) may be labeled :noun_phrase.  (Note that each constituent of a phrase
+    # should have a tag as well.)
+    def tag(marker, constituents)
+      # TODO Tag in a different way?  I have to call .last to get the real word...
+      tagged = [marker]
+      
+      constituents.each do |constituent|
+        unless constituent.nil?
+          # if there's nothing in the register, etc, the value will be nil
+          # don't include the nil in the tagging
+          tagged << constituent
+        end
+      end
+      
+      return tagged
+    end
+    
+    # TODO
+    # def choose_arc(arcs, position, registers)
+    #   arcs.each do |arc|
+    #     begin
+    #       arc.call(position, registers)
+    #     rescue Ungrammatical
+    #       # Move onto the next one
+    #     end
+    #   end
+    #   
+    #   raise Ungrammatical
+    # end
+    
+    # Set a given register in the hash given as an argument.  The value that gets assigned
+    # to the key is specified in the optional 'extras' hash.  By default, the tag is the same
+    # as the destination register (register_name) and the content is the word at the given 
+    # position.
+    def set_register(register_name, position, registers, extras = {})
+      # TODO I'm pretty sure there's an easier way to handle the argument hash
+      if extras[:tag]
+        tag = extras[:tag]
+      else
+        tag = register_name
+      end
+      
+      if extras[:content]
+        content = extras[:content]
+      else
+        content = @words[position]
+      end
+      
+      registers[register_name] = tag(tag, content)
+    end
+    
+    def at_last_word?(position)
+      # puts("in at_last_word?")
+      if !@words[position].nil?
+        # puts("failing...")
+        raise Ungrammatical
+      else
+        return @words.length == position
+      end
+    end
+    
+    def in_category?(category, position)
+      word = @words[position]
+      return (!word.nil? and word.send("#{category}?"))
+    end
+    
+    def exact_word?(exact_word, position)
+      word = @words[position]
+      if word.nil? # if we're checking for a position outside the length of @words
+        raise Ungrammatical
+      else
+        return word == exact_word
+      end
+      # word = @words.at(position)
+      # return (!word.nil? and word == exact_word)
+    end
+    
+    def follow_arc_to(node_name, position, registers)
+      send(node_name, position + 1, registers.dup)
+    end
+    
+    def jump_to(node_name, position, registers)
+      send(node_name, position, registers.dup)
+    end
+    
+    def push(node_name, position, registers, extras)
+      # TODO I'm pretty sure there's an easier way to handle the argument hash
+      if extras[:into].nil? or extras[:next].nil?
+        raise "You must give :into and :next for the 'extra' hash"
+      end
+      
+      destination_register = extras[:into]
+      next_node = extras[:next]
+      
+      # Traverse the subnetwork...
+      send(node_name, position, registers.dup)
+      
+      # The result for the subnetwork traversal is located in @star.
+      registers[destination_register] = @star.dup
+      position += registers[destination_register].inspect.number_in_quotes
+      
+      # Move along to the next node
+      send(next_node, position, registers.dup)
+    end
+    
+    def pop(content)
+      @star = content
+    end
+end

data/simple_atn/augmented_transition_network_test.rb

@@ -0,0 +1,113 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/augmented_transition_network'
+
+class AugmentedTransitionNetworkTest < Test::Unit::TestCase
+  def setup
+    @atn = AugmentedTransitionNetwork.new
+  end
+  
+  def test_non_passive_parse
+    sentences = []
+    sentences << %w{man grows}
+    sentences << %w{the man grows}
+    sentences << %w{the old man grows}
+    sentences << %w{the old smiling man grows}
+    sentences << %w{the old smiling man grows avocados}
+    sentences << %w{the old smiling man grows the avocados}
+    sentences << %w{the old old smiling man grows the avocados}
+    sentences << %w{monster ate}
+    sentences << %w{the monster ate}
+    sentences << %w{the monster ate cookie}
+    sentences << %w{the monster ate the cookie}
+    sentences << %w{the monster ate the old cookie}
+    
+    sentences.each do |sentence|
+      parsed = @atn.parse_to_string(sentence)
+      # puts("sentence: #{sentence.inspect}")
+      # puts("parsed: #{parsed.inspect}")
+      # puts('=' * 50)
+      # puts @atn.parse(sentence).inspect_as_tree
+      # puts('=' * 50)
+      assert_equal(sentence.join(" "), parsed)
+    end
+  end
+  
+  def test_passive_parse
+    assert_equal("monster ate cookie", @atn.parse_to_string(%w{cookie was eaten by monster}))
+    assert_equal("the monster ate the cookie", @atn.parse_to_string(%w{the cookie was eaten by the monster}))
+    assert_equal("the monster ate the old cookie", @atn.parse_to_string(%w{the old cookie was eaten by the monster}))
+    assert_equal("the avocados ate the old man", @atn.parse_to_string(%w{the old man was eaten by the avocados}))
+    puts @atn.parse(%w{the old man was eaten by the avocados}).inspect_as_tree
+  end
+  
+  def test_ungrammatical_parse
+    ungrammatical = []
+    ungrammatical << %w{the}
+    ungrammatical << %w{man}
+    ungrammatical << %w{the man}
+    ungrammatical << %w{the old man}
+    ungrammatical << %w{the old smiling man}
+    ungrammatical << %w{grows}
+    ungrammatical << %w{grows avocados}
+    ungrammatical << %w{grows the avocados}
+    ungrammatical << %w{was the avocados}
+    ungrammatical << %w{was eaten the avocados}
+    ungrammatical << %w{was eaten by the avocados}
+    # ungrammatical << %w{the old man was eaten the avocados}
+    
+    ungrammatical.each do |sentence|
+      assert_raise(Ungrammatical) do
+        @atn.parse(sentence)
+      end
+    end
+  end
+  
+  def test_prepositional_phrase
+    assert_equal("in the street", @atn.parse_to_string(%w{in the street}, :prepositional_phrase))
+    
+    ungrammatical = []
+    ungrammatical << %w{}
+    ungrammatical << %w{in}
+    ungrammatical << %w{in the}
+    ungrammatical << %w{in the the}
+    ungrammatical << %w{in the grows}
+    
+    ungrammatical.each do |phrase|
+      assert_raise(Ungrammatical) do
+        @atn.parse(phrase, :prepositional_phrase)
+      end
+    end
+  end
+  
+  def test_prepositional_phrase_in_noun_phrase
+    assert_equal("man in street", @atn.parse_to_string(%w{man in street}, :noun_phrase))
+    assert_equal("man in the street", @atn.parse_to_string(%w{man in the street}, :noun_phrase))
+    assert_equal("the man in the street", @atn.parse_to_string(%w{the man in the street}, :noun_phrase))
+  end
+  
+  def test_prepositional_phrase_in_sentence
+    assert_equal("man in street grows", @atn.parse_to_string(%w{man in street grows}))
+    assert_equal("man in the street grows", @atn.parse_to_string(%w{man in the street grows}))
+    assert_equal("the man in the street grows", @atn.parse_to_string(%w{the man in the street grows}))
+    assert_equal("the man in the street grows avocados", @atn.parse_to_string(%w{the man in the street grows avocados}))
+    
+    assert_equal("the man grows avocados in the street", @atn.parse_to_string(%w{the man grows avocados in the street}))
+    assert_equal("the man in the street grows avocados in the street", @atn.parse_to_string(%w{the man in the street grows avocados in the street}))
+    
+    ungrammatical = []
+    ungrammatical << %w{}
+    ungrammatical << %w{in}
+    ungrammatical << %w{in the}
+    ungrammatical << %w{in the the}
+    ungrammatical << %w{in the grows}
+    ungrammatical << %w{the in the street man in the street grows avocados in the street}
+    
+    ungrammatical.each do |phrase|
+      assert_raise(Ungrammatical) do
+        @atn.parse(phrase, :prepositional_phrase)
+      end
+    end
+    
+    # puts @atn.parse(%w{the monster in the man grows avocados in the street}).inspect
+  end
+end

data/simple_atn/english.rb

@@ -0,0 +1,161 @@
+# there might still be some issues with things that don't raise Ungrammatical correctly
+module English
+  private
+    def sentence(position, registers)
+      push(:noun_phrase, position, registers, :into => :subject, :next => :sentence__subject)
+    end
+    
+    def sentence__subject(position, registers)
+      if in_category?(:verb, position)
+        set_register(:verb, position, registers)
+        follow_arc_to(:verb_phrase__verb, position, registers)
+      else
+        raise Ungrammatical
+      end
+    end
+    
+    def verb_phrase__verb(position, registers)
+      if in_category?(:past_participle, position) and "was" == registers[:verb].last # last because of the tagging
+        # Passive voice
+        registers[:object] = registers[:subject]
+        registers.delete(:subject)
+        set_register(:verb, position, registers, :content => @words[position].preterite)
+        follow_arc_to(:verb_phrase__verb, position, registers)
+        # TODO arc 9
+      else
+        # TODO transitive verb
+        begin
+          push(:noun_phrase, position, registers, :into => :object, :next => :sentence__verb_phrase)
+        rescue Ungrammatical # this is necessary whenever there is a push followed by another arc
+          jump_to(:sentence__verb_phrase, position, registers)
+        end
+      end
+    end
+    
+    def sentence__verb_phrase(position, registers)
+      # puts("@words: #{@words.inspect}")
+      # puts("position: #{position.inspect}")
+      # puts("@words.at(position): #{@words.at(position).inspect}")
+      # if at_last_word?(position)
+      #   @star = tag(:sentence, registers[:subject], registers[:verb], registers[:object])
+      # else
+      #   if exact_word?("by", position)
+      #     follow_arc_to(:sentence__by, position, registers)
+      #   else
+      #     raise Ungrammatical
+      #   end
+      # end
+      begin
+        if at_last_word?(position)
+          pop(tag(:sentence, [registers[:subject], registers[:verb], registers[:object]]))
+        end
+      rescue Ungrammatical
+        # puts("Coming to the rescue!")
+        if exact_word?("by", position)
+          follow_arc_to(:sentence__by, position, registers)
+        else
+          raise Ungrammatical
+        end
+      end
+    end
+    
+    def sentence__by(position, registers)
+      # puts("in sentence__by")
+      if registers[:subject].nil?
+        # Passive voice
+        push(:noun_phrase, position, registers, :into => :subject, :next => :sentence__verb_phrase)
+      else
+        raise Ungrammatical
+      end
+    end
+    
+    def noun_phrase(position, registers)
+      if in_category?(:determiner, position)
+        set_register(:determiner, position, registers)
+        follow_arc_to(:noun_phrase__determiner, position, registers)
+      else
+        begin
+          jump_to(:noun_phrase__determiner, position, registers)
+        rescue Ungrammatical
+          if in_category?(:pronoun, position)
+            set_register(:noun, position, registers)
+            follow_arc_to(:noun_phrase__noun, position, registers)
+          else
+            raise Ungrammatical
+          end
+        end
+      end
+    end
+    
+    def noun_phrase__determiner(position, registers)
+      if in_category?(:adjective, position)
+        set_register(:adjective, position, registers, :content => [registers[:adjective], @words[position]])
+        follow_arc_to(:noun_phrase__determiner, position, registers)
+      else
+        if in_category?(:present_participle, position)
+          set_register(:adjective, position, registers, :content => [registers[:adjective], @words[position]])
+          follow_arc_to(:noun_phrase__determiner, position, registers)
+        else
+          if in_category?(:noun, position)
+            set_register(:noun, position, registers)
+            follow_arc_to(:noun_phrase__noun, position, registers)
+          else
+            raise Ungrammatical
+          end
+        end
+      end
+    end
+    
+    # TODO
+    # def noun_phrase__determiner(position, registers)
+    #   arcs = []
+    #   
+    #   arcs << Proc.new do |position, registers|
+    #     if in_category?(:adjective, position)
+    #       set_register(:adjective, position, registers, :content => [registers[:adjective], @words[position]])
+    #       follow_arc_to(:noun_phrase__determiner, position, registers)
+    #     end
+    #   end
+    #   
+    #   arcs << Proc.new do |position, registers|
+    #     if in_category?(:present_participle, position)
+    #       set_register(:adjective, position, registers, :content => [registers[:adjective], @words[position]])
+    #       follow_arc_to(:noun_phrase__determiner, position, registers)
+    #     end
+    #   end
+    #   
+    #   arcs << Proc.new do |position, registers|
+    #     if in_category?(:noun, position)
+    #       set_register(:noun, position, registers)
+    #       follow_arc_to(:noun_phrase__noun, position, registers)
+    #     end
+    #   end
+    #   
+    #   choose_arc(arcs, position, registers)
+    # end
+    
+    def noun_phrase__noun(position, registers)
+      begin
+        push(:prepositional_phrase, position, registers, :into => :prepositional_phrase, :next => :noun_phrase__noun)
+      rescue Ungrammatical
+        pop(tag(:noun_phrase, [registers[:determiner], registers[:adjective], registers[:noun], registers[:prepositional_phrase]]))
+      end
+    end
+    
+    def prepositional_phrase(position, registers)
+      if in_category?(:preposition, position)
+        set_register(:preposition, position, registers)
+        follow_arc_to(:prepositional_phrase__preposition, position, registers)
+      else
+        raise Ungrammatical
+      end
+    end
+    
+    def prepositional_phrase__preposition(position, registers)
+      push(:noun_phrase, position, registers, :into => :object_of_preposition, :next => :prepositional_phrase__noun_phrase)
+    end
+    
+    def prepositional_phrase__noun_phrase(position, registers)
+      pop(tag(:prepositional_phrase, [registers[:preposition], registers[:object_of_preposition]]))
+    end
+end