references.rb in card-1.96.0

- old
+ new

@@ -7,40 +7,46 @@
 
 PARTIAL_REF_CODE = "P".freeze
 
 # cards that refer to self
 def referers
-  references_in.map(&:referer_id).map(&Card.method(:fetch)).compact
+  referer_cards_from_references references_in
 end
 
 # cards that include self
-def includers
-  refs = references_in.where(ref_type: "I")
-  refs.map(&:referer_id).map(&Card.method(:fetch)).compact
+def nesters
+  referer_cards_from_references references_in.where(ref_type: "I")
 end
 
+def referer_cards_from_references references
+  references.map(&:referer_id).uniq.map(&Card.method(:fetch)).compact
+end
+
 # cards that self refers to
 def referees
-  references_out.map { |ref| Card.fetch ref.referee_key, new: {} }
+  referees_from_references references_out
 end
 
 # cards that self includes
-def includees
-  refs = references_out.where(ref_type: "I")
-  refs.map { |ref| Card.fetch ref.referee_key, new: {} }
+def nestees
+  referees_from_references references_out.where(ref_type: "I")
 end
 
+def referees_from_references references
+  references.map(&:referee_key).uniq.map { |key| Card.fetch key, new: {} }
+end
+
 # cards that refer to self by name
 # (finds cards not yet linked by id)
 def name_referers
   Card.joins(:references_out).where card_references: { referee_key: key }
 end
 
 # cards that refer to self or any descendant
 def family_referers
   @family_referers ||= ([self] + descendants).map(&:referers).flatten.uniq
-  # TODO: make this more efficient!
+  # TODO: make this more efficient using partial references!
 end
 
 # replace references in card content
 def replace_reference_syntax old_name, new_name
   obj_content = Card::Content.new content, self
@@ -155,26 +161,29 @@
 end
 
 # on rename, update names in cards that refer to self by name (as directed)
 event :update_referer_content, :finalize,
       on: :update, after: :name_change_finalized,
-      when: proc { |card| card.update_referers } do
+      when: :update_referers  do
   # FIXME: break into correct stages
   Auth.as_bot do
-    family_referers.each do |card|
+    referers.each do |card|
       next if card == self || card.structure
-      card = card.refresh
-      card.db_content = card.replace_reference_syntax name_before_last_save, name
-      card.save!
+      new_content = card.replace_reference_syntax name_before_last_save, name
+      card.refresh.update_attributes! content: new_content
     end
   end
 end
 
 # on rename, when NOT updating referer content, update references to ensure
 # that partial references are correctly tracked
 # eg.  A links to X+Y.  if X+Y is renamed and we're not updating the link in A,
 # then we need to be sure that A has a partial reference
 event :update_referer_references_out, :finalize,
       on: :update, after: :name_change_finalized,
-      when: proc { |c| !c.update_referers } do
-  family_referers.map(&:update_references_out)
+      when: :not_update_referers do
+  referers.map(&:update_references_out)
+end
+
+def not_update_referers
+  !update_referers
 end