card 1.101.3 → 1.101.4

data/mod/core/set/all/codename.rb

@@ -19,11 +19,11 @@ private
 def validate_codename_permission
   return if Auth.always_ok? || Auth.as_id == creator_id
 
-  errors.add :codename, tr(:only_admins_codename)
+  errors.add :codename, t(:core_only_admins_codename)
 end
 
 def validate_codename_uniqueness
   return (self.codename = nil) if codename.blank?
   return if errors.present? || !Card.find_by_codename(codename)
-  errors.add :codename, tr(:error_code_in_use, codename: codename)
+  errors.add :codename, t(:core_error_code_in_use, codename: codename)
 end

data/mod/core/set/all/content.rb

@@ -1,30 +1,67 @@
-def content= value
-  self.db_content = standardize_content(value)
+event :set_content, :store, on: :save do
+  self.db_content = prepare_db_content
+  @selected_action_id = @selected_content = nil
+  clear_drafts
+end
+
+event :save_draft, :store, on: :update, when: :draft? do
+  save_content_draft content
+  abort :success
+end
+
+event :set_default_content,
+      :prepare_to_validate,
+      on: :create, when: :use_default_content? do
+  self.db_content = template.db_content
+end
+
+def draft?
+  Env.params["draft"] == "true"
+end
+
+def clean_html?
+  true
+end
+
+def use_default_content?
+  !db_content_changed? && template && template.db_content.present?
+end
+
+def unfilled?
+  blank_content? && blank_comment? && !subcards?
 end
 
-def content
-  structured_content || standard_content
+def blank_comment?
+  comment.blank? || comment.strip.blank?
 end
-alias raw_content content #DEPRECATED!
 
-def content?
-  content.present?
+def prepare_db_content
+  cont = standard_db_content || "" # necessary?
+  clean_html? ? Card::Content.clean!(cont) : cont
 end
 
-def standard_content
-  db_content || (new_card? && template.db_content)
+def standard_db_content
+  if structure
+    # do not override db_content with content from structure
+    db_content
+  else
+    standard_content
+  end
 end
 
-def standardize_content value
-  value.is_a?(Array) ? value.join("\n") : value
+# seems like this should be moved to format so we can fall back on title
+# rather than name. (In fact, name, title, AND label is a bit much.
+# Trim to 2?)
+def label
+  name
 end
 
-def structured_content
-  structure && template.db_content
+def creator
+  Card[creator_id]
 end
 
-def refresh_content
-  self.content = Card.find(id)&.db_content
+def updater
+  Card[updater_id]
 end
 
 format do
@@ -94,85 +131,3 @@ format :html do
     hidden_field :content, class: "d0-card-content"
   end
 end
-
-# seems like this should be moved to format so we can fall back on title
-# rather than name. (In fact, name, title, AND label is a bit much.
-# Trim to 2?)
-def label
-  name
-end
-
-def creator
-  Card[creator_id]
-end
-
-def updater
-  Card[updater_id]
-end
-
-def save_content_draft _content
-  clear_drafts
-end
-
-def clear_drafts
-  drafts.created_by(Card::Auth.current_id).each(&:delete)
-end
-
-def last_draft_content
-  drafts.last.card_changes.last.value
-end
-
-event :set_content, :store, on: :save do
-  self.db_content = prepare_db_content
-  @selected_action_id = @selected_content = nil
-  clear_drafts
-end
-
-event :save_draft, :store, on: :update, when: :draft? do
-  save_content_draft content
-  abort :success
-end
-
-event :set_default_content,
-      :prepare_to_validate,
-      on: :create, when: :use_default_content? do
-  self.db_content = template.db_content
-end
-
-def draft?
-  Env.params["draft"] == "true"
-end
-
-def prepare_db_content
-  cont = standard_db_content || "" # necessary?
-  clean_html? ? Card::Content.clean!(cont) : cont
-end
-
-def standard_db_content
-  if structure
-    # do not override db_content with content from structure
-    db_content
-  else
-    standard_content
-  end
-end
-
-def clean_html?
-  true
-end
-
-def use_default_content?
-  !db_content_changed? && template && template.db_content.present?
-end
-
-def unfilled?
-  blank_content? && blank_comment? && !subcards?
-end
-
-def blank_content?
-  content.blank? || content.strip.blank?
-end
-
-def blank_comment?
-  comment.blank? || comment.strip.blank?
-end

data/mod/core/set/all/name_events.rb

@@ -7,73 +7,58 @@ event :validate_name, :validate, on: :save, changed: :name, when: :no_autoname?
   validate_uniqueness_of_name
 end
 
+# called by validate_name
 event :validate_uniqueness_of_name, skip: :allowed do
-  # validate uniqueness of name
-
   return unless (existing_id = Card::Lexicon.id key) && existing_id != id
   # The above is a fast check but cannot detect if card is in trash
 
   # TODO: perform the following as a remote-only fetch (not yet supported)
   return unless (existing_card = Card.where(id: existing_id, trash: false).take)
 
-  errors.add :name, tr(:error_name_exists, name: existing_card.name)
+  errors.add :name, t(:core_error_name_exists, name: existing_card.name)
 end
 
+# called by validate_name
 event :validate_legality_of_name do
   if name.length > 255
-    errors.add :name, tr(:error_too_long, length: name.length)
+    errors.add :name, t(:core_error_too_long, length: name.length)
   elsif name.blank?
-    errors.add :name, tr(:error_blank_name)
+    errors.add :name, t(:core_error_blank_name)
   elsif name_incomplete?
-    errors.add :name, tr(:is_incomplete)
+    errors.add :name, t(:core_is_incomplete)
   elsif !name.valid?
-    errors.add :name, tr(:error_banned_characters, banned: Card::Name.banned_array * " ")
+    errors.add :name, t(:core_error_banned_characters,
+                        banned: Card::Name.banned_array * " ")
   elsif changing_existing_tag_to_junction?
-    errors.add :name, tr(:error_name_tag, name: name)
+    errors.add :name, t(:core_error_name_tag, name: name)
   end
 end
 
 event :validate_key, after: :validate_name, on: :save, when: :no_autoname? do
   if key.empty?
-    errors.add :key, tr(:error_blank_key) if errors.empty?
+    errors.add :key, t(:core_error_blank_key) if errors.empty?
   elsif key != name.key
-    errors.add :key, tr(:error_wrong_key, key: key, name: name)
+    errors.add :key, t(:core_error_wrong_key, key: key, name: name)
   end
 end
 
-# STAGE: store
-
-event :set_autoname, :prepare_to_store, on: :create, when: :autoname? do
-  self.name = autoname rule(:autoname)
-  autoname_card = rule_card :autoname
-  autoname_card.update_column :db_content, name
-  autoname_card.expire
-  pull_from_trash!
-  Card.write_to_soft_cache self
+event :validate_renaming, :validate, on: :update, changed: :name, skip: :allowed do
+  return if name_before_act&.to_name == name # just changing to new variant
+  errors.add :content, t(:core_cannot_change_content) if content_is_changing?
+  errors.add :type, t(:core_cannot_change_type) if type_is_changing?
+  detect_illegal_compound_names
 end
 
+# STAGE: store
+
 event :expire_old_name, :store, changed: :name, on: :update do
   Director.expirees << name_before_act
 end
 
-event :update_lexicon_on_create, :finalize, changed: :name, on: :create do
-  Card::Lexicon.add self
-end
-
-event :update_lexicon_on_rename, :finalize, changed: :name, on: :update do
-  Card::Lexicon.update self
-end
-
-def lex
-  simple? ? name : [left_id, right_id]
-end
-
-def old_lex
-  if (old_left_id = left_id_before_act)
-    [old_left_id, right_id_before_act]
-  else
-    name_before_act
-  end
+event :rename_in_trash, after: :expire_old_name, on: :update do
+  existing_card = Card.find_by_key_and_trash name.key, true
+  return if !existing_card || existing_card == self
+  existing_card.rename_as_trash_obstacle
 end
 
 event :prepare_left_and_right, :store, changed: :name, on: :save do
@@ -82,42 +67,47 @@ event :prepare_left_and_right, :store, changed: :name, on: :save do
   prepare_side :right
 end
 
-def prepare_side side
-  side_id = send "#{side}_id"
-  sidename = name.send "#{side}_name"
-  prepare_obstructed_side(side, side_id, sidename) ||
-    prepare_new_side(side, side_id, sidename)
+event :update_lexicon, :finalize, changed: :name, on: :save do
+  lexicon_action = @action == :create ? :add : :update
+  Card::Lexicon.send lexicon_action, self
 end
 
-def prepare_new_side side, side_id, sidename
-  return unless side_id == -1 || !Card[side_id]&.real?
+event :cascade_name_changes, :finalize, on: :update, changed: :name do
+  each_descendant { |d| d.rename_as_descendant update_referers }
+end
 
-  sidecard = Director.card(sidename) || add_subcard(sidename)
-  send "#{side}_id=", sidecard
+protected
+
+def rename_as_trash_obstacle
+  self.name = name + "*trash"
+  rename_in_trash_without_callbacks
+  save!
 end
 
-def prepare_obstructed_side side, side_id, sidename
-  return unless side_id && side_id == id
-  clear_name sidename
-  send "#{side}_id=", add_subcard(sidename)
-  true
+def rename_as_descendant referers=true
+  self.action = :update
+  referers ? update_referers : update_referer_references_out
+  refresh_references_in
+  refresh_references_out
+  expire
+  Card::Lexicon.update self
 end
 
+private
+
 def name_incomplete?
   name.parts.include?("") && !superleft&.autoname?
 end
 
-def no_autoname?
-  !autoname?
+def changed_from_simple_to_compound?
+  name.compound? && name_before_act.to_name.simple?
 end
 
-def autoname?
-  name.blank? &&
-    (@autoname_rule.nil? ? (@autoname_rule = rule(:autoname).present?) : @autoname_rule)
+def detect_illegal_compound_names
+  return unless changed_from_simple_to_compound? && child_ids(:right).present?
+  errors.add :name, "illegal name change; existing names end in +#{name_before_act}"
 end
 
-private
-
 def changing_existing_tag_to_junction?
   return false unless changing_name_to_junction?
   name_in_use_as_tag?
@@ -143,3 +133,24 @@ def clear_name name
   Card::Lexicon.cache.reset # probably overkill, but this for an edge case...
   # Card::Lexicon.delete id, key
 end
+
+def prepare_side side
+  side_id = send "#{side}_id"
+  sidename = name.send "#{side}_name"
+  prepare_obstructed_side(side, side_id, sidename) ||
+    prepare_new_side(side, side_id, sidename)
+end
+
+def prepare_new_side side, side_id, sidename
+  return unless side_id == -1 || !Card[side_id]&.real?
+
+  sidecard = Director.card(sidename) || add_subcard(sidename)
+  send "#{side}_id=", sidecard
+end
+
+def prepare_obstructed_side side, side_id, sidename
+  return unless side_id && side_id == id
+  clear_name sidename
+  send "#{side}_id=", add_subcard(sidename)
+  true
+end

data/mod/core/set/all/reference_events.rb

@@ -0,0 +1,67 @@
+# test for updating referer content
+event :prepare_referer_update, :validate, on: :update, changed: :name do
+  self.update_referers = ![nil, false, "false"].member?(update_referers)
+end
+
+# on rename, update names in cards that refer to self by name (as directed)
+event :update_referer_content, :finalize, on: :update, when: :update_referers do
+  referers.each do |card|
+    next if card.structure
+    card.skip_event! :validate_renaming, :check_permissions
+    card.content = card.replace_references name_before_act, name
+    attach_subcard card
+  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,
+      changed: :name, on: :update, when: :not_update_referers do
+  referers.map(&:update_references_out)
+end
+
+# when name changes, update references to card
+event :refresh_references_in, :finalize, changed: :name, on: :save do
+  Reference.unmap_referees id if action == :update && !update_referers
+  Reference.map_referees key, id
+end
+
+# when content changes, update references to other cards
+event :refresh_references_out, :finalize, on: :save, changed: :content do
+  update_references_out
+end
+
+# clean up reference table when card is deleted
+event :clear_references, :finalize, on: :delete do
+  delete_references_out
+  Reference.unmap_referees id
+end
+
+# replace references in card content
+def replace_references old_name, new_name
+  cont = content_object
+  cont.find_chunks(:Reference).each do |chunk|
+    next unless replace_reference chunk, old_name, new_name
+  end
+  cont.to_s
+end
+
+protected
+
+def not_update_referers
+  !update_referers
+end
+
+private
+
+def replace_reference chunk, old_name, new_name
+  return unless (old = chunk.referee_name) && (new = old.swap old_name, new_name)
+  chunk.referee_name = chunk.replace_reference old_name, new_name
+  update_reference old.key, new.key
+end
+
+def update_reference old_key, new_key
+  Reference.where(referee_key: old_key).update_all referee_key: new_key
+end

data/mod/core/set/all/states.rb

@@ -71,8 +71,8 @@ def new?
   new_record? ||       # not yet in db (from ActiveRecord)
     !@from_trash.nil?  # in process of restoration from trash
 end
-alias new_card? new?
-alias unreal? new?
+alias_method :new_card?, :new?
+alias_method :unreal?, :new?
 
 # has not been edited directly by human users.  bleep blorp.
 def pristine?