acts-as-dag 2.0.1 → 2.5.0

data/README.rdoc

@@ -6,6 +6,12 @@ Acts As Dag, short for Acts As Directed Acyclic Graph, is a plugin which allows
 
 Say you have been using one of the many great plugins that allow for Tree hierarchy like: acts_as_tree or acts_as_nested_set, acts_as_better_nested_set, etc. Yet, you feel something is missing. Tree's are just not good enough. You want to allow each record to have multiple parent objects within a hierarchy as well as multiple children. Then you are going to need a DAG instead of a tree, and thats were this plugin becomes useful.
 
+Version 1.1.1 tested using Rails 2.3.8 and Ruby 1.9.2-p0.
+
+Version 2.0.x tested using Rails 3.0.0 and Ruby 1.9.2-p0, without major structural changes to code from the Rails 3 framework. Removes all deprecation warnings I have received while using AAD and Rails 3.0.0.
+
+Version 2.5.0 is based on Rails 3.0.0 and uses all of the new ActiveModel/ActiveRecord goodness found there.
+
 === What's a DAG?
 
 http://en.wikipedia.org/wiki/Directed_acyclic_graph
@@ -28,17 +34,11 @@ Yes, but I think they aren't as fast or feature filled. Flogic has a good simple
 
 Version 1.x of Acts As Dag uses named_scope so your going to need Rails 2.1 or above.
 
-Version 2.x of Acts As Dag uses validate and scope, so you are going to need Rails 3.0 or higher.
-
-Version 1.1.1 tested using Rails 2.3.8 and Ruby 1.9.2-p0.
-
-Version 2.0.0 tested using Rails 3.0.0 and Ruby 1.9.2-p0, without major structural changes to code from the Rails 3 framework. Removes all deprecation warnings I have received while using AAD and Rails 3.0.0.
-
-Version 2.1.x (in development) will be based on Rails 3.0.0 and attempt to use all of the new ActiveRecord goodness found there.
+Version 2.x of Acts As Dag uses validate and scope/where and ActiveModel::Validator, so you are going to need Rails 3.0 or higher.
 
 == Installation
 
-	gem install acts-as-dag
+    gem install acts-as-dag
 	
 == Terminology
 
@@ -284,5 +284,4 @@ Authors:: Matthew Leventi, Robert Schmitt
 
 Algorithm and plugin designed by Matthew Leventi Email:(first letter of my first name followed by my last name @gmail.com). Im open to questions, very open to bugs, and even more receptive of bug fixes. I am also currently (August 2008) looking for a job just having graduated University of Rochester.
 
-Robert Schmitt: I have modified the Rake system to support Jeweler to build this as a Ruby gem that can be installed and managed through the gem system. Updated to work without deprecation warnings from Rails 3.0.0.
-
+Gemification and upgrade to Rails 3.0.0 and Ruby 1.9.2 performed by Robert Schmitt. Please feel free to contact me with bug reports and suggestions, and any patches you may have developed/applied.

data/lib/dag.rb

@@ -0,0 +1,18 @@
+require "active_model"
+require "active_record"
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require "dag/dag"
+require "dag/columns"
+require "dag/poly_columns"
+require "dag/polymorphic"
+require "dag/standard"
+require "dag/edges"
+require "dag/validators"
+
+$LOAD_PATH.shift
+
+if defined?(ActiveRecord::Base)
+  ActiveRecord::Base.extend Dag
+end

data/lib/dag/columns.rb

@@ -0,0 +1,26 @@
+module Dag
+
+  #Methods that show columns
+  module Columns
+      def ancestor_id_column_name
+        acts_as_dag_options[:ancestor_id_column]
+      end
+
+      def descendant_id_column_name
+        acts_as_dag_options[:descendant_id_column]
+      end
+
+      def direct_column_name
+        acts_as_dag_options[:direct_column]
+      end
+
+      def count_column_name
+        acts_as_dag_options[:count_column]
+      end
+
+      def acts_as_dag_polymorphic?
+        acts_as_dag_options[:polymorphic]
+      end
+    end
+
+end

data/lib/dag/dag.rb

@@ -0,0 +1,296 @@
+module Dag
+
+  #Sets up a model to act as dag links for models specified under the :for option
+  def acts_as_dag_links(options = {})
+    conf = {
+            :ancestor_id_column => 'ancestor_id',
+            :ancestor_type_column => 'ancestor_type',
+            :descendant_id_column => 'descendant_id',
+            :descendant_type_column => 'descendant_type',
+            :direct_column => 'direct',
+            :count_column => 'count',
+            :polymorphic => false,
+            :node_class_name => nil}
+    conf.update(options)
+
+    unless conf[:polymorphic]
+      if conf[:node_class_name].nil?
+        raise ActiveRecord::ActiveRecordError, 'ERROR: Non-polymorphic graphs need to specify :node_class_name with the receiving class like belong_to'
+      end
+    end
+
+    write_inheritable_attribute :acts_as_dag_options, conf
+    class_inheritable_reader :acts_as_dag_options
+
+    extend Columns
+    include Columns
+
+    #access to _changed? and _was for (edge,count) if not default
+    unless direct_column_name == 'direct'
+      module_eval <<-"end_eval", __FILE__, __LINE__
+						def direct_changed?
+							self.#{direct_column_name}_changed?
+						end
+						def direct_was
+							self.#{direct_column_name}_was
+						end
+      end_eval
+    end
+
+    unless count_column_name == 'count'
+      module_eval <<-"end_eval", __FILE__, __LINE__
+						def count_changed?
+							self.#{count_column_name}_changed?
+						end
+						def count_was
+							self.#{count_column_name}_was
+						end
+      end_eval
+    end
+
+    internal_columns = [ancestor_id_column_name, descendant_id_column_name]
+    edge_class_name = self.to_s
+
+    direct_column_name.intern
+    count_column_name.intern
+
+    #links to ancestor and descendant
+    if acts_as_dag_polymorphic?
+      extend PolyColumns
+      include PolyColumns
+
+      internal_columns << ancestor_type_column_name
+      internal_columns << descendant_type_column_name
+
+      belongs_to :ancestor, :polymorphic => true
+      belongs_to :descendant, :polymorphic => true
+
+      validates ancestor_type_column_name.to_sym,   :presence => true
+      validates descendant_type_column_name.to_sym, :presence => true
+      validates ancestor_id_column_name.to_sym,     :uniqueness => {:scope => [ancestor_type_column_name, descendant_type_column_name, descendant_id_column_name]}
+
+      scope :with_ancestor,         lambda { |ancestor|   where(ancestor_id_column_name => ancestor.id, ancestor_type_column_name => ancestor.class.to_s) }
+      scope :with_descendant,       lambda { |descendant| where(descendant_id_column_name => descendant.id, descendant_type_column_name => descendant.class.to_s) }
+
+      scope :with_ancestor_point,   lambda { |point|      where(ancestor_id_column_name => point.id, ancestor_type_column_name => point.type) }
+      scope :with_descendant_point, lambda { |point|      where(descendant_id_column_name => point.id, descendant_type_column_name => point.type) }
+
+      extend Polymorphic
+      include Polymorphic
+    else
+      belongs_to :ancestor,   :foreign_key => ancestor_id_column_name, :class_name => acts_as_dag_options[:node_class_name]
+      belongs_to :descendant, :foreign_key => descendant_id_column_name, :class_name => acts_as_dag_options[:node_class_name]
+
+      validates ancestor_id_column_name.to_sym, :uniqueness => {:scope => [descendant_id_column_name]}
+
+      scope :with_ancestor,         lambda { |ancestor|   where(ancestor_id_column_name => ancestor.id) }
+      scope :with_descendant,       lambda { |descendant| where(descendant_id_column_name => descendant.id) }
+
+      scope :with_ancestor_point,   lambda { |point|      where(ancestor_id_column_name => point.id) }
+      scope :with_descendant_point, lambda { |point|      where(descendant_id_column_name => point.id) }
+
+      extend Standard
+      include Standard
+    end
+
+    # TODO: rename? breaks when using 'where' query because :direct scope name and :direct => true parameter conflict?
+    scope :direct,            :conditions => {:direct => true}
+    scope :indirect,          :conditions => {:direct => false}
+
+    scope :ancestor_nodes,    :joins => :ancestor
+    scope :descendant_nodes,  :joins => :descendant
+
+    validates ancestor_id_column_name.to_sym,   :presence => true,
+                                                :numericality => true
+    validates descendant_id_column_name.to_sym, :presence => true,
+                                                :numericality => true
+
+    extend Edges
+    include Edges
+
+    before_destroy :destroyable!, :perpetuate
+    before_save :perpetuate
+    before_validation :field_check, :fill_defaults, :on => :update
+    before_validation :fill_defaults, :on => :create
+
+    include ActiveModel::Validations
+    validates_with CreateCorrectnessValidator, :on => :create
+    validates_with UpdateCorrectnessValidator, :on => :update
+
+
+    #internal fields
+    code = 'def field_check ' + "\n"
+    internal_columns.each do |column|
+      code +=  "if " + column + "_changed? \n" + ' raise ActiveRecord::ActiveRecordError, "Column: '+column+' cannot be changed for an existing record it is immutable"' + "\n end \n"
+    end
+    code += 'end'
+    module_eval code
+
+    [count_column_name].each do |column|
+      module_eval <<-"end_eval", __FILE__, __LINE__
+						def #{column}=(x)
+							raise ActiveRecord::ActiveRecordError, "ERROR: Unauthorized assignment to #{column}: it's an internal field handled by acts_as_dag code."
+						end
+      end_eval
+    end
+  end
+
+  def has_dag_links(options = {})
+    conf = {
+            :class_name => nil,
+            :prefix => '',
+            :ancestor_class_names => [],
+            :descendant_class_names => []
+    }
+    conf.update(options)
+
+    #check that class_name is filled
+    if conf[:link_class_name].nil?
+      raise ActiveRecord::ActiveRecordError, "has_dag_links must be provided with :link_class_name option"
+    end
+
+    #add trailing '_' to prefix
+    unless conf[:prefix] == ''
+      conf[:prefix] += '_'
+    end
+
+    prefix = conf[:prefix]
+    dag_link_class_name = conf[:link_class_name]
+    dag_link_class = conf[:link_class_name].constantize
+
+    if dag_link_class.acts_as_dag_polymorphic?
+      self.class_eval <<-EOL
+              has_many :#{prefix}links_as_ancestor, :as => :ancestor, :class_name => '#{dag_link_class_name}'
+              has_many :#{prefix}links_as_descendant, :as => :descendant, :class_name => '#{dag_link_class_name}'
+
+              has_many :#{prefix}links_as_parent, :as => :ancestor, :class_name => '#{dag_link_class_name}', :conditions => {'#{dag_link_class.direct_column_name}' => true}
+              has_many :#{prefix}links_as_child, :as => :descendant, :class_name => '#{dag_link_class_name}', :conditions => {'#{dag_link_class.direct_column_name}' => true}
+
+      EOL
+
+      ancestor_table_names = []
+      parent_table_names = []
+      conf[:ancestor_class_names].each do |class_name|
+        table_name = class_name.tableize
+        self.class_eval <<-EOL2
+                has_many :#{prefix}links_as_descendant_for_#{table_name}, :as => :descendant, :class_name => '#{dag_link_class_name}', :conditions => {'#{dag_link_class.ancestor_type_column_name}' => '#{class_name}'}
+                has_many :#{prefix}ancestor_#{table_name}, :through => :#{prefix}links_as_descendant_for_#{table_name}, :source => :ancestor, :source_type => '#{class_name}'
+                has_many :#{prefix}links_as_child_for_#{table_name}, :as => :descendant, :class_name => '#{dag_link_class_name}', :conditions => {'#{dag_link_class.ancestor_type_column_name}' => '#{class_name}','#{dag_link_class.direct_column_name}' => true}
+                has_many :#{prefix}parent_#{table_name}, :through => :#{prefix}links_as_child_for_#{table_name}, :source => :ancestor, :source_type => '#{class_name}'
+
+              	def #{prefix}root_for_#{table_name}?
+									self.links_as_descendant_for_#{table_name}.empty?
+            		end
+        EOL2
+        ancestor_table_names << (prefix+'ancestor_'+table_name)
+        parent_table_names << (prefix+'parent_'+table_name)
+        unless conf[:descendant_class_names].include?(class_name)
+          #this apparently is only one way is we can create some aliases making things easier
+          self.class_eval "has_many :#{prefix}#{table_name}, :through => :#{prefix}links_as_descendant_for_#{table_name}, :source => :ancestor, :source_type => '#{class_name}'"
+        end
+      end
+
+      unless conf[:ancestor_class_names].empty?
+        self.class_eval <<-EOL25
+								def #{prefix}ancestors
+									#{ancestor_table_names.join(' + ')}
+								end
+								def #{prefix}parents
+									#{parent_table_names.join(' + ')}
+								end
+        EOL25
+      else
+        self.class_eval <<-EOL26
+								def #{prefix}ancestors
+									a = []
+									#{prefix}links_as_descendant.each do |link|
+										a << link.ancestor
+									end
+									a
+								end
+								def #{prefix}parents
+									a = []
+									#{prefix}links_as_child.each do |link|
+										a << link.ancestor
+									end
+									a
+								end
+        EOL26
+      end
+
+      descendant_table_names = []
+      child_table_names = []
+      conf[:descendant_class_names].each do |class_name|
+        table_name = class_name.tableize
+        self.class_eval <<-EOL3
+                has_many :#{prefix}links_as_ancestor_for_#{table_name}, :as => :ancestor, :class_name => '#{dag_link_class_name}', :conditions => {'#{dag_link_class.descendant_type_column_name}' => '#{class_name}'}
+                has_many :#{prefix}descendant_#{table_name}, :through => :#{prefix}links_as_ancestor_for_#{table_name}, :source => :descendant, :source_type => '#{class_name}'
+
+                has_many :#{prefix}links_as_parent_for_#{table_name}, :as => :ancestor, :class_name => '#{dag_link_class_name}', :conditions => {'#{dag_link_class.descendant_type_column_name}' => '#{class_name}','#{dag_link_class.direct_column_name}' => true}
+                has_many :#{prefix}child_#{table_name}, :through => :#{prefix}links_as_parent_for_#{table_name}, :source => :descendant, :source_type => '#{class_name}'
+
+								def #{prefix}leaf_for_#{table_name}?
+                	self.links_as_ancestor_for_#{table_name}.empty?
+              	end
+        EOL3
+        descendant_table_names << (prefix+'descendant_'+table_name)
+        child_table_names << (prefix+'child_'+table_name)
+        unless conf[:ancestor_class_names].include?(class_name)
+          self.class_eval "has_many :#{prefix}#{table_name}, :through => :#{prefix}links_as_ancestor_for_#{table_name}, :source => :descendant, :source_type => '#{class_name}'"
+        end
+      end
+
+      unless conf[:descendant_class_names].empty?
+        self.class_eval <<-EOL35
+								def #{prefix}descendants
+									#{descendant_table_names.join(' + ')}
+								end
+								def #{prefix}children
+									#{child_table_names.join(' + ')}
+								end
+        EOL35
+      else
+        self.class_eval <<-EOL36
+								def #{prefix}descendants
+									d = []
+									#{prefix}links_as_ancestor.each do |link|
+										d << link.descendant
+									end
+									d
+								end
+								def #{prefix}children
+									d = []
+									#{prefix}links_as_parent.each do |link|
+										d << link.descendant
+									end
+									d
+								end
+        EOL36
+      end
+    else
+      self.class_eval <<-EOL4
+              has_many :#{prefix}links_as_ancestor, :foreign_key => '#{dag_link_class.ancestor_id_column_name}', :class_name => '#{dag_link_class_name}'
+              has_many :#{prefix}links_as_descendant, :foreign_key => '#{dag_link_class.descendant_id_column_name}', :class_name => '#{dag_link_class_name}'
+
+              has_many :#{prefix}ancestors, :through => :#{prefix}links_as_descendant, :source => :ancestor
+              has_many :#{prefix}descendants, :through => :#{prefix}links_as_ancestor, :source => :descendant
+
+              has_many :#{prefix}links_as_parent, :foreign_key => '#{dag_link_class.ancestor_id_column_name}', :class_name => '#{dag_link_class_name}', :conditions => {'#{dag_link_class.direct_column_name}' => true}
+              has_many :#{prefix}links_as_child, :foreign_key => '#{dag_link_class.descendant_id_column_name}', :class_name => '#{dag_link_class_name}', :conditions => {'#{dag_link_class.direct_column_name}' => true}
+
+              has_many :#{prefix}parents, :through => :#{prefix}links_as_child, :source => :ancestor
+              has_many :#{prefix}children, :through => :#{prefix}links_as_parent, :source => :descendant
+
+      EOL4
+    end
+    self.class_eval <<-EOL5
+            def #{prefix}leaf?
+              self.#{prefix}links_as_ancestor.empty?
+						end
+						def #{prefix}root?
+							self.#{prefix}links_as_descendant.empty?
+						end
+    EOL5
+  end
+
+end

data/lib/dag/edges.rb

@@ -0,0 +1,301 @@
+module Dag
+  module Edges
+
+    def self.included(base)
+      base.send :include, EdgeInstanceMethods
+    end
+
+    #Class methods that extend the link model for both polymorphic and non-polymorphic graphs
+    #Returns a new edge between two points
+    def build_edge(ancestor, descendant)
+      source = self::EndPoint.from(ancestor)
+      sink = self::EndPoint.from(descendant)
+      conditions = self.conditions_for(source, sink)
+      path = self.new(conditions)
+      path.make_direct
+      path
+    end
+
+    #Finds an edge between two points, Must be direct
+    def find_edge(ancestor, descendant)
+      source = self::EndPoint.from(ancestor)
+      sink = self::EndPoint.from(descendant)
+      self.find(:first, :conditions => self.conditions_for(source, sink).merge!({direct_column_name => true}))
+    end
+
+    #Finds a link between two points
+    def find_link(ancestor, descendant)
+      source = self::EndPoint.from(ancestor)
+      sink = self::EndPoint.from(descendant)
+      self.find(:first, :conditions => self.conditions_for(source, sink))
+    end
+
+    #Finds or builds an edge between two points
+    def find_or_build_edge(ancestor, descendant)
+      edge = self.find_edge(ancestor, descendant)
+      return edge unless edge.nil?
+      return build_edge(ancestor, descendant)
+    end
+
+    #Creates an edge between two points using save
+    def create_edge(ancestor, descendant)
+      link = self.find_link(ancestor, descendant)
+      if link.nil?
+        edge = self.build_edge(ancestor, descendant)
+        return edge.save
+      else
+        link.make_direct
+        return link.save
+      end
+    end
+
+    #Creates an edge between two points using save! Returns created edge
+    def create_edge!(ancestor, descendant)
+      link = self.find_link(ancestor, descendant)
+      if link.nil?
+        edge = self.build_edge(ancestor, descendant)
+        edge.save!
+        edge
+      else
+        link.make_direct
+        link.save!
+        link
+      end
+    end
+
+    #Alias for create_edge
+    def connect(ancestor, descendant)
+      self.create_edge(ancestor, descendant)
+    end
+
+    #Alias for create_edge!
+    def connect!(ancestor, descendant)
+      self.create_edge!(ancestor, descendant)
+    end
+
+    #Determines if a link exists between two points
+    def connected?(ancestor, descendant)
+      !self.find_link(ancestor, descendant).nil?
+    end
+
+    #Finds the longest path between ancestor and descendant returning as an array
+    def longest_path_between(ancestor, descendant, path=[])
+      longest = []
+      ancestor.children.each do |child|
+        if child == descendent
+          temp = path.clone
+          temp << child
+          if temp.length > longest.length
+            longest = temp
+          end
+        elsif self.connected?(child, descendant)
+          temp = path.clone
+          temp << child
+          temp = self.longest_path_between(child, descendant, temp)
+          if temp.length > longest.length
+            longest = temp
+          end
+        end
+      end
+      longest
+    end
+
+    #Determines if an edge exists between two points
+    def edge?(ancestor, descendant)
+      !self.find_edge(ancestor, descendant).nil?
+    end
+
+    #Alias for edge
+    def direct?(ancestor, descendant)
+      self.edge?(ancestor, descendant)
+    end
+
+    #Instance methods included into the link model for polymorphic and non-polymorphic DAGs
+    module EdgeInstanceMethods
+
+      attr_accessor :do_not_perpetuate
+
+      #Fill default direct and count values if necessary. In place of after_initialize method
+      def fill_defaults
+        self[direct_column_name] = true if self[direct_column_name].nil?
+        self[count_column_name] = 0 if self[count_column_name].nil?
+      end
+
+      #Whether the edge can be destroyed
+      def destroyable?
+        (self.count == 0) || (self.direct? && self.count == 1)
+      end
+
+      #Raises an exception if the edge is not destroyable. Otherwise makes the edge indirect before destruction to cleanup graph.
+      def destroyable!
+        raise ActiveRecord::ActiveRecordError, 'ERROR: cannot destroy this edge' unless destroyable?
+        #this triggers rewiring on destruction via perpetuate
+        if self.direct?
+          self[direct_column_name] = false
+        end
+        true
+      end
+
+      #Analyzes the changes in a model instance and rewires as necessary.
+      def perpetuate
+        #flag set by links that were modified in association
+        return true if self.do_not_perpetuate
+
+        #if edge changed this was manually altered
+        if direct_changed?
+          if self.direct?
+            self[count_column_name] += 1
+          else
+            self[count_column_name] -= 1
+          end
+          self.wiring
+        end
+      end
+
+      #Id of the ancestor
+      def ancestor_id
+        self[ancestor_id_column_name]
+      end
+
+      #Id of the descendant
+      def descendant_id
+        self[descendant_id_column_name]
+      end
+
+      #Count of the edge, ie the edge exists in X ways
+      def count
+        self[count_column_name]
+      end
+
+      #Changes the count of the edge. DO NOT CALL THIS OUTSIDE THE PLUGIN
+      def internal_count=(val)
+        self[count_column_name] = val
+      end
+
+      #Whether the link is direct, ie manually created
+      def direct?
+        self[direct_column_name]
+      end
+
+      #Whether the link is an edge?
+      def edge?
+        self[direct_column_name]
+      end
+
+      #Makes the link direct, ie an edge
+      def make_direct
+        self[direct_column_name] = true
+      end
+
+      #Makes an edge indirect, ie a link.
+      def make_indirect
+        self[direct_column_name] = false
+      end
+
+      #Source of the edge, creates if necessary
+      def source
+        @source = self.class::Source.from_edge(self) if @source.nil?
+        @source
+      end
+
+      #Sink (destination) of the edge, creates if necessary
+      def sink
+        @sink = self.class::Sink.from_edge(self) if @sink.nil?
+        @sink
+      end
+
+      #All links that end at the source
+      def links_to_source
+        self.class.with_descendant_point(self.source)
+      end
+
+      #all links that start from the sink
+      def links_from_sink
+        self.class.with_ancestor_point(self.sink)
+      end
+
+      protected
+
+      #Changes on a wire based on the count (destroy! or save!) (should not be called outside this plugin)
+      def push_associated_modification!(edge)
+        raise ActiveRecord::ActiveRecordError, 'ERROR: cannot modify our self in this way' if edge == self
+        edge.do_not_perpetuate = true
+        if edge.count == 0
+          edge.destroy!
+        else
+          edge.save!
+        end
+      end
+
+      #Updates the wiring of edges that dependent on the current one
+      def rewire_crossing(above_leg, below_leg)
+        if above_leg.count_changed?
+          was = above_leg.count_was
+          was = 0 if was.nil?
+          above_leg_count = above_leg.count - was
+          if below_leg.count_changed?
+            raise ActiveRecord::ActiveRecordError, 'ERROR: both legs cannot 0 normal count change'
+          else
+            below_leg_count = below_leg.count
+          end
+        else
+          above_leg_count = above_leg.count
+          if below_leg.count_changed?
+            was = below_leg.count_was
+            was = 0 if was.nil?
+            below_leg_count = below_leg.count - was
+          else
+            raise ActiveRecord::ActiveRecordError, 'ERROR: both legs cannot have count changes'
+          end
+        end
+        count = above_leg_count * below_leg_count
+        source = above_leg.source
+        sink = below_leg.sink
+        bridging_leg = self.class.find_link(source, sink)
+        if bridging_leg.nil?
+          bridging_leg = self.class.new(self.class.conditions_for(source, sink))
+          bridging_leg.make_indirect
+          bridging_leg.internal_count = 0
+        end
+        bridging_leg.internal_count = bridging_leg.count + count
+        bridging_leg
+      end
+
+      #Find the edges that need to be updated
+      def wiring
+        source = self.source
+        sink = self.sink
+        above_sources = []
+        self.links_to_source.each do |edge|
+          above_sources << edge.source
+        end
+        below_sinks = []
+        self.links_from_sink.each do |edge|
+          below_sinks << edge.sink
+        end
+        above_bridging_legs = []
+        #everything above me tied to my sink
+        above_sources.each do |above_source|
+          above_leg = self.class.find_link(above_source, source)
+          above_bridging_leg = self.rewire_crossing(above_leg, self)
+          above_bridging_legs << above_bridging_leg unless above_bridging_leg.nil?
+        end
+
+        #everything beneath me tied to my source
+        below_sinks.each do |below_sink|
+          below_leg = self.class.find_link(sink, below_sink)
+          below_bridging_leg = self.rewire_crossing(self, below_leg)
+          self.push_associated_modification!(below_bridging_leg)
+          above_bridging_legs.each do |above_bridging_leg|
+            long_leg = self.rewire_crossing(above_bridging_leg, below_leg)
+            self.push_associated_modification!(long_leg)
+          end
+        end
+        above_bridging_legs.each do |above_bridging_leg|
+          self.push_associated_modification!(above_bridging_leg)
+        end
+      end
+    end
+
+  end
+end