acts_as_oqgraph 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Stuart Coyle
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,137 @@
+ActsAsOQGraph
+===========
+This gem can be used with ActiveRecord to access the features of the OQGraph
+MySQL plugin. 
+
+Please take a look at the Open Query Graph engine page at http://openquery.com/products/graph-engine
+
+This provides fast graph operations on the database. It does a similar thing to the 
+acts_as_graph gem, which does all the graph work on the application server. There are 
+pros and cons of both approaches, It really depends on your needs. Both libraries 
+use the C++ Boost graph library at the bottom layers. OQGraph has expensive 
+insert operations but is very fast at delivering the graph data and finding paths in a single SQL query.
+
+Concepts:
+The term graph we are using here is a mathematical one not a pretty picture (sorry designers). 
+For more see: http://en.wikipedia.org/wiki/Graph_(mathematics) 
+A graph consists of nodes (aka vertices) connected by edges (aka edges). 
+In a directed graph an edge has a direction. That is, it has an 'from' node and and a 'to' node.
+When tracing a path on the graph you can only go in the direction of the edge.
+The OQGraph gem operates on directed graphs. To create a non directed graph you have to create two edges,
+one each way between each node.     
+
+Edges can be assigned positive floating point values called weights. Weights default to 1.0
+The weights are used in shortest path calculations, a path is shorter if the sum of weights over each edge is smaller.
+
+What you can do with OQGraph:
+Imagine your shiny new social networking app, FarceBook.
+You have lots and lots of users each with several friends. How do you find the friends of friends?
+Or even the friends of friends of friends...right up to the six degrees of separation perhaps?
+
+Well you can do it, with some really slow and nasty SQL queries. Relational databases are good at set
+based queries but no good at graph or tree based queries. The OQGraph engine is good at graph based queries, 
+it enables you in one simple SQL query to find all friends of friends. 
+    Do this: user.reachable
+    If you really want to you can rename the reachable method so you can do this in your User model:
+             alias friends, reachable
+    Then I can call: 
+             user.friends
+    and I get the whole tree of friends of friends etc...
+             
+    TODO: Perhaps I should hook into ActiveRecord associations somehow so these can be named associations instead of methods.
+          Not really sure of how to go about this as yet
+          .
+Imagine you have a maze to solve. With OQGraph the solution is as simple as: start_cell.shortest_path_to(finish_cell).
+
+It's good for representing tree structures, networks, routes between cities, roads etc.
+
+Usage:
+
+Class Foo < ActiveRecord::Base
+    acts_as_oqgraph +options+
+end
+
+Options: 
+:class_name - The name of the edge class, defaults to current class name appended with Edge. eg FooEdge
+:table_name - The name of the edge table, defaults to table name of the specified class, eg foo_edges
+:oqgraph_table_name - the name of the volatile oqgraph table. Default foo_edge_oqgraph
+:from_key - The from key field in the edge table. Default 'from_id'
+:to_key - The to key field in the edge table. Default: 'to_id'
+:weight_column - The weight field in the edge table.
+
+Setup:
+This gem requires the use of MySQL or MariaDB with the OQGraph engine plugin.
+For details of this see: http://openquery.com/products/graph-engine
+
+You will need a table for the edges with the following schema:
+  create_table foo_edges do |t|
+      t.integer from_id
+      t.integer to_id
+      t.double weight
+  end   
+The field names and table name can be changed via the options listed above.
+You should be able also to extend the edge model as you wish.
+
+The gem will automatically create the oqgraph table and the associations to it from your node model.
+The associations are:
+  node_model.outgoing_edges
+  node_model.incoming_edges
+  node_model.outgoing_nodes
+  node_model.incoming_nodes
+  edge_model.to
+  edge_model.from
+  
+Examples of use:
+
+Creating edges:
+ foo.create_edge_to(bar) 
+ foo.create_edge_to_and_from(bar)
+
+Alternate notation using ActiveRecord associations: 
+ foo.outgoing_nodes << bar
+or equivalently:
+  bar.incoming_nodes << foo
+At the moment you cannot add weights to edges with this style of notation.
+
+Create a edge with weight:
+ bar.create_edge_to(baz, 2.0)
+ 
+Removing a edge:
+ foo.remove_edge_to(bar)
+ foo.remove_edge_from(bar)
+Note that these calls remove ALL edges to bar from foo
+
+Examining edges: 
+
+What nodes point to this one?
+Gives us an array of nodes that are connected to this one in the inward (from) direction.
+Includes the node calling the method.
+ foo.originating
+ bar.originating?(baz)
+
+What nodes can I reach from this one?
+Gives us an array of nodes that are connected to this one in the outward (to) direction.
+Includes the node calling the method.
+ bar.reachable
+ foo.reachable?(baz)
+
+Path Finding:
+  foo.shortest_path_to(baz)
+   returns [foo, bar,baz]
+
+All these methods return the node object with an additional weight field.
+This enables you to query the weights associated with the edges found.
+
+Behind the Scenes:
+When you declare acts_as_oqgraph then the edge class gets created. You can add extra functionality
+if you wish to the edge class by the usual Ruby monkey patching methods.
+
+The OQGraph table will also get created if it does not exist. The OQGraph table is volatile, it holds data in 
+memory only. The table structure is not volatile and gets stored in the db. 
+When your application starts up it will put all the edges into the graph table and update them as
+they are created, deleted or modified. This could slow things down at startup but caching classes in production
+means it does not happen on every request. I will add functionality to only update the oqgraph table if the 
+db server has been stopped, once I figure out the best way to do it.
+    
+
+Copyright (c) 2010 Stuart Coyle, released under the MIT license

data/Rakefile

@@ -0,0 +1,52 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "acts_as_oqgraph"
+    gem.summary = %Q{Use the Open Query Graph engine with Active Record}
+    gem.description = %Q{Acts As OQGraph allows ActiveRecord models to use the fast ans powerful OQGraph engine for MYSQL.}
+    gem.email = "stuart.coyle@gmail.com"
+    gem.homepage = "http://github.com/stuart/acts_as_oqgraph"
+    gem.authors = ["Stuart Coyle"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "testy #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/acts_as_oqgraph.rb

@@ -0,0 +1,205 @@
+require 'active_record'
+require File.join(File.dirname(__FILE__),'graph_edge')
+require 'mysql'
+
+module OQGraph
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+      
+    module ClassMethods
+      # Usage:
+      # 
+      # Class Foo < ActiveRecord::Base
+      #     acts_as_oqgraph  +options+
+      #     ....
+      # end
+      # 
+      # Options: 
+      # :class_name - The name of the edge class, defaults to current class name appended with Edge. eg FooEdge
+      # :table_name - The name of the edge table, defaults to table name of the specified class, eg foo_edges
+      # :oqgraph_table_name - the name of the volatile oqgraph table. Default foo_edge_oqgraph
+      # :from_key - The from key field in the edge table. Default 'from_id'
+      # :to_key - The to key field in the edge table. Default: 'to_id'
+      # :weight_column - The weight field in the edge table.
+      # 
+      # Setup:
+      # This gem requires the use of MySQL or MariaDB with the OQGraph engine plugin.
+      # For details of this see: http://openquery.com/products/graph-engine
+      # 
+      # You will need a table for the edges with the following schema:
+      #   create_table foo_edges do |t|
+      #       t.integer from_id
+      #       t.integer to_id
+      #       t.double weight
+      #   end   
+      # The field names and table name can be changed via the options listed above.
+      #
+      # The gem will automatically create the oqgraph table.
+      # 
+      # Examples of use:
+      # 
+      # Creating and removing edges:
+      #  foo.create_edge_to(bar)
+      #  bar.create_edge_to(baz, 2.0)
+      #  foo.remove_edge_to(bar) : Note that this removes ALL edges to bar from foo.
+      # or alternatively:
+      #  foo.outgoing_nodes << bar
+      #  foo.outgoing_nodes
+      #
+      # Examining edges:
+      #  foo.originating 
+      #    returns [foo]
+      #  baz.originating
+      #    returns [foo, bar,baz]
+      #  bar.reachable
+      #    returns [bar, baz]
+      #  foo.reachable?(baz)
+      #    returns true
+      #
+      # Path Finding:
+      #   foo.shortest_path_to(baz)
+      #    returns [foo, bar,baz]
+      # 
+      # All these methods return the node object with an additional weight field.
+      # This enables you to query the weights associated with the edges found.
+      # 
+      def acts_as_oqgraph(options = {})
+        
+        unless check_for_oqgraph_engine 
+          raise "acts_as_oqgraph requires the OQGRAPH engine. Install the oqgraph plugin with the following SQL: INSTALL PLUGIN oqgraph SONAME 'oqgraph_engine.so'"
+        end
+        
+        class_name = options[:class_name] || "#{self.name}Edge"
+        edge_table_name = options[:table_name] || class_name.pluralize.underscore
+        oqgraph_table_name = options[:oqgraph_table_name] || "#{self.name}Oqgraph".underscore  
+        from_key = options[:from_key] || 'from_id'
+        to_key = options[:to_key]   || 'to_id' 
+        
+        # Create the Edge Model
+        eval <<-EOS
+          class ::#{class_name} < ::GraphEdge
+            set_table_name "#{edge_table_name}"
+            
+            belongs_to :from, :class_name => '#{self.name}', :foreign_key => '#{from_key}'
+            belongs_to :to, :class_name => '#{self.name}', :foreign_key => '#{to_key}'
+            
+            @@oqgraph_table_name = '#{oqgraph_table_name}'
+            @@from_key = '#{from_key}'
+            @@to_key = '#{to_key}'
+            @@node_class = #{self}
+            
+            create_graph_table
+          end
+        EOS
+        
+        has_many :outgoing_edges, {
+           :class_name => class_name,
+           :foreign_key => from_key,
+           :include => :to,
+           :dependent => :destroy
+         }
+        
+        has_many :incoming_edges, {
+           :class_name => class_name,
+           :foreign_key => to_key,
+           :include => :from,
+           :dependent => :destroy
+         }
+        
+        has_many :outgoing_nodes, :through => :outgoing_edges, :source => :to
+        has_many :incoming_nodes, :through => :incoming_edges, :source => :from
+                                    
+        class_eval <<-EOF
+          include OQGraph::InstanceMethods
+          
+          def self.edge_class
+            #{class_name.classify}
+          end
+          
+          def self.edge_table
+            '#{edge_table_name}'
+          end
+          
+        EOF
+      end      
+      
+      private
+      
+      # Check that we have the OQGraph engine plugin installed in MySQL
+      def check_for_oqgraph_engine
+        begin
+          result = false
+          engines = self.connection.execute("SHOW ENGINES")
+          engines.each_hash do |engine|
+            result = true if (engine["Engine"]=="OQGRAPH" and engine["Support"]=="YES")
+          end
+          return result
+        rescue ActiveRecord::StatementInvalid => e
+          # This will occur if the table is not using MySQL
+          # TODO: Raise a sensible error message here.
+          return false
+        end    
+      end
+    end
+    
+    module InstanceMethods
+      
+      # The class used for the edges between nodes
+      def edge_class
+        self.class.edge_class
+      end
+      
+      # Creates a one way edge from this node to another with a weight.
+      def create_edge_to(other, weight = 1.0)
+        edge_class.create!(:from_id => id, :to_id => other.id, :weight => weight)
+      end
+      
+      # +other+ graph node to edge to
+      # +weight+ positive float denoting edge weight
+      # Creates a two way edge between this node and another.
+      def create_edge_to_and_from(other, weight = 1.0)
+        edge_class.create!(:from_id => id, :to_id => other.id, :weight => weight)
+        edge_class.create!(:from_id => other.id, :to_id => id, :weight => weight)
+      end
+      
+      # +other+ The target node to find a route to
+      # +options+ A hash of options: Currently the only option is
+      #            :method => :djiskstra or :breadth_first
+      # Returns an array of nodes in order starting with this node and ending in the target
+      # This will be the shortest path from this node to the other.
+      # The :djikstra method takes edge weights into account, the :breadth_first does not.
+      def shortest_path_to(other, options = {:method => :djikstra})
+        edge_class.shortest_path(self,other, options)
+      end
+      
+      # Returns an array of all nodes which can trace to this node
+      def originating
+        edge_class.originating_vertices(self)
+      end
+      
+      # true if the other node can reach this node.
+      def originating?(other)
+        originating.include?(other)
+      end
+      
+      # Returns all nodes reachable from this node.
+      def reachable
+        edge_class.reachable_vertices(self)
+      end
+      
+      # true if the other node is reachable from this one
+      def reachable?(other)
+       reachable.include?(other)
+      end
+      
+      # +other+ The target node to find a route to 
+      # Gives the path weight as a float of the shortest path to the other
+      def path_weight_to(other)
+        edge_class.shortest_path(self,other,:method => :djikstra).map{|edge| edge.weight.to_f}.sum
+      end
+    end
+    
+end
+
+ActiveRecord::Base.class_eval { include OQGraph }  

data/lib/graph_edge.rb

@@ -0,0 +1,120 @@
+# This is the non-volatile store for the graph data.
+
+class GraphEdge < ActiveRecord::Base
+  
+  after_create  :add_to_graph
+  after_destroy :remove_from_graph
+  after_update  :update_graph
+  
+  cattr_accessor :node_class, :oqgraph_table_name, :to_key, :from_key
+  
+  # Creates the OQgraph table if it does not exist.
+  # Deletes all entries if it does exist and then repopulates with 
+  # current edges. TODO Optimise this so that it only does so if the 
+  # DB server has been restarted.
+  def self.create_graph_table
+    connection.execute <<-EOS
+    CREATE TABLE IF NOT EXISTS #{oqgraph_table_name} (
+        latch   SMALLINT  UNSIGNED NULL,
+        origid  BIGINT    UNSIGNED NULL,
+        destid  BIGINT    UNSIGNED NULL,
+        weight  DOUBLE    NULL,
+        seq     BIGINT    UNSIGNED NULL,
+        linkid  BIGINT    UNSIGNED NULL,
+        KEY (latch, origid, destid) USING HASH,
+        KEY (latch, destid, origid) USING HASH
+      ) ENGINE=OQGRAPH;
+     EOS
+    
+    connection.execute("DELETE FROM #{oqgraph_table_name}")
+    
+    self.all.each do |edge|
+      edge.add_to_graph
+    end
+  end   
+  
+  def self.shortest_path(from, to, options)
+    latch = case options[:method]
+      when :breadth_first then 2
+      else 1
+    end  
+    latch = 1
+    latch = 2 if options[:method] == :breadth_first
+    
+    sql = <<-EOS
+     WHERE latch = #{latch} AND origid = #{from.id} AND destid = #{to.id}
+     ORDER BY seq;
+    EOS
+    
+    node_class.find_by_sql select_for_node << sql
+  end
+  
+  def self.originating_vertices(to)    
+    sql = <<-EOS
+     WHERE latch = 1 AND destid = #{to.id}
+     ORDER BY seq;
+    EOS
+    
+    node_class.find_by_sql select_for_node << sql 
+  end
+  
+  def self.reachable_vertices(from)    
+    sql = <<-EOS
+     WHERE latch = 1 AND origid = #{from.id}
+     ORDER BY seq;
+    EOS
+    
+    node_class.find_by_sql select_for_node << sql 
+  end
+  
+  # FIXME: Note this currently does not work.
+  # I suspect a bug in OQGRaph engine.
+  def self.in_edges(to)
+    sql = <<-EOS
+     WHERE latch = 0 AND destid = #{to.id}
+    EOS
+    
+    node_class.find_by_sql select_for_node << sql 
+  end
+  
+  def self.out_edges(from)    
+    sql = <<-EOS
+     WHERE latch = 0 AND origid = #{from.id}
+    EOS
+  
+    node_class.find_by_sql select_for_node << sql 
+  end
+   
+  private
+    def add_to_graph
+      connection.execute <<-EOS
+        INSERT INTO #{oqgraph_table_name} (origid, destid, weight) 
+        VALUES (#{self.send(self.class.from_key)}, #{self.send(self.class.to_key)}, #{weight || 1.0});
+      EOS
+    end
+
+    def remove_from_graph
+      connection.execute <<-EOS
+        DELETE FROM #{oqgraph_table_name} WHERE origid = #{self.send(self.class.from_key)} AND destid = #{self.send(self.class.to_key)};
+      EOS
+    end
+
+    def update_graph
+      connection.execute <<-EOS
+        UPDATE #{oqgraph_table_name} 
+        SET origid = #{self.send(self.class.from_key)}, 
+            destid = #{self.send(self.class.to_key)}, 
+            weight = #{weight} 
+        WHERE origid = #{self.send(self.class.from_key + '_was')} AND destid = #{self.send(self.class.to_key + '_was')};
+      EOS
+    end
+  def self.select_for_node
+    sql = "SELECT "
+    sql << node_class.columns.map{|column| "#{node_table}.#{column.name}"}.join(",")
+    sql << ", #{oqgraph_table_name}.weight FROM #{oqgraph_table_name} JOIN #{node_table} ON (linkid=id) "
+  end
+  
+  def self.node_table
+    node_class.table_name
+  end
+end

data/test/helper.rb

@@ -0,0 +1,13 @@
+require 'rubygems'
+require 'test/unit'
+require 'mysql'
+require 'active_record'
+require 'active_support'
+require 'active_support/test_case'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'acts_as_oqgraph'
+
+class ActiveSupport::TestCase
+end

data/test/models/custom_test_model.rb

@@ -0,0 +1,3 @@
+class CustomTestModel < ActiveRecord::Base
+  acts_as_oqgraph :class_name => 'CustomEdge', :from_key => 'orig_id', :to_key => 'dest_id'
+end

data/test/models/test_model.rb

@@ -0,0 +1,5 @@
+
+class TestModel < ActiveRecord::Base
+  acts_as_oqgraph
+end
+ 

data/test/test_acts_as_oqgraph.rb

@@ -0,0 +1,195 @@
+require 'helper'
+
+class TestActsAsOqgraph < ActiveSupport::TestCase
+  def setup
+    
+    ActiveRecord::Base.establish_connection(
+        :adapter  => "mysql",
+        :host     => "localhost",
+        :username => "root",
+        :password => "",
+        :database => "test"
+      )
+    
+    ActiveRecord::Base.connection.execute("CREATE TABLE IF NOT EXISTS test_models(id INTEGER DEFAULT NULL AUTO_INCREMENT PRIMARY KEY, name VARCHAR(255) );")
+    ActiveRecord::Base.connection.execute("CREATE TABLE IF NOT EXISTS test_model_edges(id INTEGER DEFAULT NULL AUTO_INCREMENT PRIMARY KEY, from_id INTEGER, to_id INTEGER, weight DOUBLE);")
+    ActiveRecord::Base.connection.execute("CREATE TABLE IF NOT EXISTS custom_edges(id INTEGER DEFAULT NULL AUTO_INCREMENT PRIMARY KEY, from_id INTEGER, to_id INTEGER, weight DOUBLE);")
+    
+    require File.join(File.dirname(__FILE__),'models/custom_test_model')
+    require File.join(File.dirname(__FILE__),'models/test_model')
+    
+    @test_1 = TestModel.create(:name => 'a')
+    @test_2 = TestModel.create(:name => 'b')
+    @test_3 = TestModel.create(:name => 'c')
+    @test_4 = TestModel.create(:name => 'd')
+    @test_5 = TestModel.create(:name => 'e')
+    @test_6 = TestModel.create(:name => 'f')
+    
+  end
+
+  def teardown
+    ActiveRecord::Base.connection.execute("DROP TABLE IF EXISTS test_models;")
+    ActiveRecord::Base.connection.execute("DROP TABLE IF EXISTS test_model_edges;")
+    ActiveRecord::Base.connection.execute("DROP TABLE IF EXISTS custom_edges;")
+    ActiveRecord::Base.connection.execute("DELETE FROM test_model_oqgraph;") 
+    ActiveRecord::Base.connection.execute("DELETE FROM custom_test_model_oqgraph;") 
+    
+  end
+  
+  def test_edge_table_and_class_names
+    assert_equal "test_model_edges", TestModel.edge_table 
+    assert_equal TestModelEdge, TestModel.edge_class
+  end
+  
+  def test_edge_class_created
+    assert_nothing_raised do
+      ::TestModelEdge
+      ::CustomEdge
+    end
+  end
+  
+  def test_creation_of_oqgraph_and_edge_tables
+    mysql = Mysql.new('localhost', 'root', '', 'test')
+    assert mysql.list_tables.include?('test_model_oqgraph')
+    assert mysql.list_tables.include?('test_model_edges')
+    fields = mysql.list_fields('test_model_oqgraph').fetch_fields.map{|f| f.name}
+    assert fields.include?('origid')
+    assert fields.include?('destid')
+    assert fields.include?('weight')
+    assert fields.include?('latch')
+    assert fields.include?('seq')
+    assert fields.include?('linkid')
+  end
+  
+  def test_edge_class_name_option
+    assert_equal 'custom_edges', CustomTestModel.edge_table
+    assert_equal CustomEdge, CustomTestModel.edge_class
+  end
+  
+  def test_test_model_edge_creation
+    @test_1.create_edge_to(@test_2)
+    assert_not_nil edge = TestModelEdge.find(:first, :conditions => {:from_id => @test_1.id, :to_id => @test_2.id, :weight => 1.0})
+    assert @test_1.outgoing_nodes.include?(@test_2)
+  end
+  
+  def test_edge_creation_through_association
+    @test_1.outgoing_nodes << @test_2
+    assert_not_nil edge = TestModelEdge.find(:first, :conditions => {:from_id => @test_1.id, :to_id => @test_2.id})
+  end
+  
+  def test_test_model_undirected_edge_creation
+    @test_1.create_edge_to_and_from(@test_2)
+    assert_not_nil edge = TestModelEdge.find(:first, :conditions => {:from_id => @test_1.id, :to_id => @test_2.id, :weight => 1.0})
+    assert_not_nil edge = TestModelEdge.find(:first, :conditions => {:from_id => @test_2.id, :to_id => @test_1.id, :weight => 1.0}) 
+    assert @test_1.outgoing_nodes.include?(@test_2)
+    assert @test_1.incoming_nodes.include?(@test_2)
+  end
+    
+  def test_adding_weight_to_edges
+    @test_1.create_edge_to(@test_2, 2.0)
+    assert_not_nil edge = TestModelEdge.find(:first, :conditions => {:from_id => @test_1.id, :to_id => @test_2.id})
+    assert edge.weight = 2.0
+  end
+  
+  def test_edge_model_creation_creates_oqgraph_edge
+    @test_1.create_edge_to(@test_2, 2.5)
+    oqedge = ActiveRecord::Base.connection.execute("SELECT * FROM test_model_oqgraph WHERE origid=#{@test_1.id} AND destid=#{@test_2.id};")
+    assert_equal [nil,"1","2","2.5",nil,nil], oqedge.fetch_row                                      
+  end
+  
+  def test_edge_model_removal_deletes_oqgraph_edge
+    @test_1.outgoing_nodes << @test_2
+    edge = @test_1.outgoing_edges.find(:first, :conditions => {:to_id => @test_2.id})
+    edge.destroy
+    oqedge = ActiveRecord::Base.connection.execute("SELECT * FROM test_model_oqgraph WHERE origid=#{@test_1.id} AND destid=#{@test_2.id};")
+    assert_equal nil, oqedge.fetch_row
+  end
+  
+  def test_edge_model_update
+    edge = @test_1.create_edge_to(@test_2, 2.5) 
+    edge.update_attributes(:weight => 3.0)
+    oqedge = ActiveRecord::Base.connection.execute("SELECT * FROM test_model_oqgraph WHERE origid=#{@test_1.id} AND destid=#{@test_2.id};") 
+    assert_equal [nil,"1","2","3",nil,nil], oqedge.fetch_row
+    edge.update_attributes(:to_id => 3)
+    oqedge = ActiveRecord::Base.connection.execute("SELECT * FROM test_model_oqgraph WHERE origid=#{@test_1.id} AND destid=3;") 
+    assert_equal [nil,"1","3","3",nil,nil], oqedge.fetch_row
+  end
+  
+  def test_gettting_the_shortest_path 
+    #   a -- b -- c -- d
+    @test_1.create_edge_to @test_2
+    @test_2.create_edge_to @test_3
+    @test_3.create_edge_to @test_4
+    assert_equal [@test_1, @test_2, @test_3, @test_4], @test_1.shortest_path_to(@test_4)
+    assert_equal ['a','b','c','d'], @test_1.shortest_path_to(@test_4).map(&:name)
+  end
+  
+  def test_getting_shortest_path_more_complex
+    #
+    # a -- b -- c -- d
+    #      |      / 
+    #      e-- f 
+    @test_1.create_edge_to @test_2
+    @test_2.create_edge_to @test_3
+    @test_3.create_edge_to @test_4
+    @test_2.create_edge_to @test_5
+    @test_5.create_edge_to @test_6
+    @test_4.create_edge_to @test_6
+    assert_equal [@test_1, @test_2, @test_5, @test_6], @test_1.shortest_path_to(@test_6)
+  end
+  
+  def test_path_returns_weight
+    #   a -- b -- c -- d
+    @test_1.create_edge_to @test_2, 2.0
+    @test_2.create_edge_to @test_3, 1.5
+    @test_3.create_edge_to @test_4, 1.2
+    assert_equal [nil,"2","1.5","1.2"], @test_1.shortest_path_to(@test_4).map(&:weight)
+  end
+  
+  def test_path_weight
+    #   a -- b -- c -- d
+     @test_1.create_edge_to @test_2, 2.0
+     @test_2.create_edge_to @test_3, 1.5
+     @test_3.create_edge_to @test_4, 1.2
+     assert_equal 4.7, @test_1.path_weight_to(@test_4)
+  end
+  
+  def test_path_find_breadth_first
+    @test_1.outgoing_nodes << @test_2
+    @test_2.outgoing_nodes << @test_3
+    @test_3.outgoing_nodes << @test_4
+    assert_equal [@test_1, @test_2, @test_3, @test_4], @test_1.shortest_path_to(@test_4, :method => :breadth_first)
+  end
+  
+  def test_get_originating_nodes
+    @test_1.create_edge_to @test_2
+    @test_2.create_edge_to @test_3
+    assert_equal [@test_2, @test_1] , @test_2.originating
+  end
+    
+  def test_get_reachable_nodes
+    @test_1.create_edge_to @test_2
+    @test_2.create_edge_to @test_3
+    assert_equal [@test_2, @test_3] , @test_2.reachable
+  end
+  
+  def test_get_originating?
+    @test_1.create_edge_to @test_2
+    @test_2.create_edge_to @test_3
+    assert @test_2.originating?(@test_1)
+    assert !@test_2.originating?(@test_3) 
+  end
+  
+  def test_get_incoming_nodes
+    @test_1.create_edge_to @test_2
+    @test_2.create_edge_to @test_3
+    assert_equal [@test_1] , @test_2.incoming_nodes
+  end
+  
+   def test_get_outgoing_nodes
+     @test_1.create_edge_to @test_2
+     @test_2.create_edge_to @test_3
+     assert_equal [@test_3] , @test_2.outgoing_nodes
+   end
+   
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification 
+name: acts_as_oqgraph
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Stuart Coyle
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-21 00:00:00 +10:00
+default_executable: 
+dependencies: []
+
+description: Acts As OQGraph allows ActiveRecord models to use the fast ans powerful OQGraph engine for MYSQL.
+email: stuart.coyle@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/acts_as_oqgraph.rb
+- lib/graph_edge.rb
+- test/helper.rb
+- test/models/custom_test_model.rb
+- test/models/test_model.rb
+- test/test_acts_as_oqgraph.rb
+has_rdoc: true
+homepage: http://github.com/stuart/acts_as_oqgraph
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Use the Open Query Graph engine with Active Record
+test_files: 
+- test/helper.rb
+- test/models/custom_test_model.rb
+- test/models/test_model.rb
+- test/test_acts_as_oqgraph.rb