has_shortest_path 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in has_shortest_path.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,5 @@
+require 'bundler'
+#require(File.join(File.dirname(__FILE__), 'test', 'dummy', 'config', 'application'))
+
+Bundler::GemHelper.install_tasks
+#Dummy::Application.load_tasks

data/has_shortest_path.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "has_shortest_path/version"
+
+Gem::Specification.new do |s|
+  s.name        = "has_shortest_path"
+  s.version     = HasShortestPath::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Felix Jodoin"]
+  s.email       = ["felix@fjstudios.net"]
+  s.homepage    = ""
+  s.summary     = %q{Provides a simple way to find the shortest path in a graph of Rails records}
+  s.description = %q{Provides a simple way to find the shortest path in a graph of Rails records using Floyd's algorithm}
+
+  s.rubyforge_project = "has_shortest_path"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  
+  s.add_dependency "activesupport", "3.0.5"
+end

data/lib/has_shortest_path.rb

@@ -0,0 +1,173 @@
+#require 'has_shortest_path/railtie' if defined?(Rails)
+require 'active_support'
+
+module HasShortestPath
+  extend ActiveSupport::Concern
+  
+  Infinity = 1.0/0 unless defined?(Infinity)
+  
+  module ClassMethods
+    # +has_shortest_path+ defines a class as an edge in a graph
+    #
+    # * +via+: the class's accessor for edges that it is connected to
+    # 
+    # * +weighted_with+: the class's accessor for the weight variable
+    #
+    # * +through+: the intermediate model that contains the weight (this is the vertex model)
+    #
+    def has_shortest_path options = {}
+      cattr_accessor :shortest_path_opts
+      cattr_accessor :weighted_array
+      
+      self.shortest_path_opts = options
+      
+      raise "has_shortest_path requires the arguments :via, :weighted_with, and :through." if shortest_path_opts[:via].nil? || shortest_path_opts[:through].nil? || shortest_path_opts[:weighted_with].nil?
+      
+      # Weight of the vertex origination.destinations[1] => origination.connections[1].cost
+      # Set up a method like 'weighted_destinations' that will return an array of all of the edges we have a vertex to,
+      # with each edge having the weight from this edge to that edge.
+      attr_accessor shortest_path_opts[:weighted_with]
+      self.weighted_array = "weighted_#{self.shortest_path_opts[:via].to_s}".to_sym
+      define_method(weighted_array) do
+        self.send(shortest_path_opts[:via]).enum_for(:each_with_index).map { |dest, i| dest.cost = self.send(shortest_path_opts[:through])[i].cost; dest }
+      end
+      
+    end
+  end
+  
+  # +shortest_path+ returns an array of intermediate edges in between this edge and the destination (exclusive).
+  # The array is empty if there are no intermediate edges.
+  # The array is nil if there is no available path.
+  # * +final_destination+: The edge record to attempt to find the shortest path to.
+  # * +options[:recompute]+: If set to true, all intermediate work will be discarded.
+  def shortest_path final_destination, options = {}
+    self.reload && @shortest_path_cache = nil if options[:recompute]
+    build_cache
+    
+    # 1. Build an adjacency matrix out of this model's relevent records
+    @shortest_path_cache[:w_table] = gen_w_table unless @shortest_path_cache[:w_table].present?
+    
+    # 2. Perform Floyd's shortest path algorithm
+    @shortest_path_cache[:p_table] = floyd(@shortest_path_cache[:w_table], @shortest_path_cache[:w_size]) unless @shortest_path_cache[:p_table].present?
+    
+    # 3. Attempt to reconstruct a path to final_destination
+    # Only attempt reconstruction if final_destination is in the table!
+    # If final_destination is in the table, there must be a path, otherwise it would not have
+    # been included by traverse_all_edges
+    final_index = index_from_edge(final_destination)
+    if(final_index < @shortest_path_cache[:w_size] && final_index != nil) then
+      reconstruct_path(index_from_edge(self), final_index, @shortest_path_cache[:p_table])
+    else
+      nil
+    end
+  end
+  
+  private #:nodoc
+    # Performs the Floyd-Warshall algorithm on the given W-Table, returning the P table used to reconstruct shortest paths
+    def floyd w_table, size #:nodoc
+      p_table = Array.new(size) { Array.new(size) { 0 } }
+      d_table = w_table
+    
+      # 0...size is used since the w_table may be larger than needed
+      (0...size).each do |k|
+        (0...size).each do |i|
+          (0...size).each do |j|
+            if d_table[i][k] + d_table[k][j] < d_table[i][j] then
+              d_table[i][j] = d_table[i][k] + d_table[k][j]
+              p_table[i][j] = k
+            end
+          end
+        end
+      end
+    
+      p_table
+    end
+    
+    # Sets up the cache has, if it hasn't already been populated
+    def build_cache #:nodoc:
+      unless @shortest_path_cache.present? then
+        @shortest_path_cache = Hash.new 
+
+        @shortest_path_cache[:visited_edges] = []
+        @shortest_path_cache[:next_edge_index] = 0
+        @shortest_path_cache[:edge_indices] = Hash.new
+      end
+    end
+    
+    # Generates the w_table used as D0 for the Floyd-Warshall algorithm
+    def gen_w_table #:nodoc:    
+      # Builds the w_table
+      # The w_table size cannot exceed the number of edges in the database
+      # If memory is a real constraint, could also loop through traverse_all_edges to get an accurate matrix size
+  
+      # Set up the working variables
+      @shortest_path_cache[:w_table] = Array.new(self.class.count) { |j| Array.new(self.class.count) { |i| if i==j then 0 else Infinity end } }
+      
+      traverse_all_edges(self)    
+      @shortest_path_cache[:w_size] = @shortest_path_cache[:next_edge_index]
+    
+      # This w_table matches the properties:
+      # w[i][j] = weight on edge    if an edge between Vi and Vj exists
+      # w[i][j] = Infinity          if no edge between Vi and Vj exists
+      # w[i][j] = 0                 if i == j 
+      @shortest_path_cache[:w_table]
+    end
+  
+    # Reconstructs the path between start using the given p_table
+    # Returns an empty array if there are no intermediate vertices
+    # Vertices are in order of Start -> [Intermediate 1, Intermediate 2] -> Finish
+    def reconstruct_path start_index, finish_index, p_table #:nodoc:
+      ret = []
+      pqr = p_table[start_index][finish_index]
+      if pqr != 0 then
+        # recurse and concat the recursive results into our result array
+        reconstruct_path(start_index, pqr, p_table).each {|p| ret << p }
+        ret << edge_from_index(pqr)
+        reconstruct_path(pqr, finish_index, p_table).each {|p| ret << p }
+      end
+      ret
+    end
+  
+    # Assigns a unique sequential index to each edge, or returns the existing index if it has already been set
+    def index_from_edge edge #:nodoc:
+      unless @shortest_path_cache[:edge_indices][edge].present? then
+        @shortest_path_cache[:edge_indices][edge] = @shortest_path_cache[:next_edge_index]
+        @shortest_path_cache[:next_edge_index] = @shortest_path_cache[:next_edge_index] + 1
+      end
+      @shortest_path_cache[:edge_indices][edge]
+    end
+    
+    # Returns the edge's class from the given index (reverse of index_from_edge)
+    def edge_from_index index #:nodoc
+      if @shortest_path_cache[:edge_indices].has_value?(index) then
+        @shortest_path_cache[:edge_indices].index(index)
+      end
+    end
+  
+    # adds the specified path to the w_table
+    def add_to_w_table start, finish #:nodoc
+      s_index = index_from_edge(start)
+      f_index = index_from_edge(finish)
+      
+      @shortest_path_cache[:w_table][s_index][f_index] = finish.send(shortest_path_opts[:weighted_with])
+    end
+  
+    def traverse_all_edges edge #:nodoc
+      # don't recurse infinitely..
+      unless @shortest_path_cache[:visited_edges].include?(edge) then
+        
+        @shortest_path_cache[:visited_edges].insert(-1, edge) # mark this edge has having been visited
+        
+        unless edge.send(weighted_array).empty? then
+          # don't recurse further if there aren't any other connections
+          edge.send(weighted_array).each do |path|
+            add_to_w_table(edge, path)
+            traverse_all_edges(path)
+          end
+          
+        end
+      end
+    end
+end
+
+ActiveRecord::Base.send(:include, HasShortestPath) if defined?(ActiveRecord)

data/lib/has_shortest_path/version.rb

@@ -0,0 +1,3 @@
+module HasShortestPath
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: has_shortest_path
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Felix Jodoin
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-28 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 3
+        - 0
+        - 5
+        version: 3.0.5
+  type: :runtime
+  version_requirements: *id001
+description: Provides a simple way to find the shortest path in a graph of Rails records using Floyd's algorithm
+email: 
+- felix@fjstudios.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Rakefile
+- has_shortest_path.gemspec
+- lib/has_shortest_path.rb
+- lib/has_shortest_path/version.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: has_shortest_path
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: Provides a simple way to find the shortest path in a graph of Rails records
+test_files: []
+