mod/core/set/all/name.rb in card-1.91 vs mod/core/set/all/name.rb in card-1.92

@@ -1,42 +1,43 @@
 require "uuid"
 
 module ClassMethods
   def uniquify_name name, rename=:new
-    return name unless Card.exists?(name)
+    return name unless Card.exists? name
+    uniq_name = generate_alternative_name name
+    return uniq_name unless rename == :old
+    rename!(name, uniq_name)
+    name
+  end
+
+  def generate_alternative_name name
     uniq_name = "#{name} 1"
     uniq_name.next! while Card.exists?(uniq_name)
-    if rename == :old
-      # name conflict resolved; original name can be used
-      Card[name].update_attributes! name: uniq_name,
-                                    update_referers: true
-      name
-    else
-      uniq_name
-    end
+    uniq_name
   end
-end
 
-def name= newname
-  cardname = newname.to_name
-  if @supercard
-    @supercard.subcards.rename key, cardname.key
-    @contextual_name = cardname.to_s
-    relparts = cardname.parts
-    if relparts.size == 2 &&
-       (relparts.first.blank? || relparts.first.to_name.key == @supercard.key)
-      @superleft = @supercard
-    end
-    cardname = cardname.to_absolute_name @supercard.name
+  def rename! oldname, newname
+    Card[oldname].update_attributes! name: newname, update_referers: true
   end
+end
 
+def name= newname
+  cardname = superize_name newname.to_name
   newkey = cardname.key
   self.key = newkey if key != newkey
   update_subcard_names cardname
   write_attribute :name, cardname.s
 end
 
+def superize_name cardname
+  return cardname unless @supercard
+  @raw_name = cardname.s
+  @supercard.subcards.rename key, cardname.key
+  @superleft = @supercard if cardname.field_of? @supercard.name
+  cardname.absolute_name @supercard.name
+end
+
 def key= newkey
   was_in_cache = Card.cache.soft.delete key
   write_attribute :key, newkey
   # keep the soft cache up-to-date
   Card.write_to_soft_cache self if was_in_cache
@@ -69,10 +70,14 @@
 
 def cardname
   name.to_name
 end
 
+def codename
+  super&.to_sym
+end
+
 def autoname name
   if Card.exists?(name) || ActManager.include?(name)
     autoname name.next
   else
     name
@@ -86,17 +91,17 @@
 
 def junction?
   cardname.junction?
 end
 
-def contextual_name
-  @contextual_name || name
+def raw_name
+  @raw_name || name
 end
 
 def relative_name context_name=nil
   context_name ||= @supercard.cardname if @supercard
-  cardname.relative_name context_name
+  cardname.name_from context_name
 end
 
 def absolute_name context_name=nil
   context_name ||= @supercard.cardname if @supercard
   cardname.absolute_name context_name
@@ -104,11 +109,11 @@
 
 def left *args
   case
   when simple?    then nil
   when @superleft then @superleft
-  when name_changed? && name.to_name.trunk_name.key == name_was.to_name.key
+  when attribute_is_changing?(:name) && name.to_name.trunk_name.key == name_before_act.to_name.key
     nil # prevent recursion when, eg, renaming A+B to A+B+C
   else
     Card.fetch cardname.left, *args
   end
 end
@@ -238,38 +243,11 @@
   else
     self.left_id = self.right_id = nil
   end
 end
 
-event :rename, after: :set_name, on: :update do
-  if (existing_card = Card.find_by_key_and_trash(cardname.key, true)) &&
-     existing_card != self
-    existing_card.name = existing_card.name + "*trash"
-    existing_card.rename_without_callbacks
-    existing_card.save!
-  end
-end
-
-def suspend_name name
-  # move the current card out of the way, in case the new name will require
-  # re-creating a card with the current name, ie.  A -> A+B
-  Card.expire name
-  tmp_name = "tmp:" + UUID.new.generate
-  Card.where(id: id).update_all(name: tmp_name, key: tmp_name)
-end
-
-event :cascade_name_changes, :finalize, on: :update, changed: :name do
-  des = descendants
-  @descendants = nil # reset
-
-  des.each do |de|
-    # here we specifically want NOT to invoke recursive cascades on these
-    # cards, have to go this low level to avoid callbacks.
-    Rails.logger.info "cascading name: #{de.name}"
-    Card.expire de.name # old name
-    newname = de.cardname.replace name_was, name
-    Card.where(id: de.id).update_all name: newname.to_s, key: newname.key
-    de.update_referers = update_referers
-    de.refresh_references_in
-    Card.expire newname
-  end
+event :name_change_finalized, :finalize, changed: :name, on: :save do
+  # The events to update references has to happen after :cascade_name_changes,
+  # but :cascade_name_changes is defined after the reference events and
+  # and additionaly it is defined on :update but some of the reference
+  # events are on :save. Hence we need this additional hook to organize these events.
 end