card 1.101.2 → 1.102.0

data/tmpsets/set/mod002-core/all/debug.rb

@@ -4,29 +4,26 @@ class Card; module Set; class All
 #
 module Debug;
 extend Card::Set
-def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/debug.rb"; end
+def self.source_location; "/Users/ezl5238/dev/decko/gem/card/mod/core/set/all/debug.rb"; end
 def to_s
   "#<#{self.class.name}[#{debug_type}]#{attributes['name']}>"
 end
 
 def inspect
-  tags = []
-  tags << "trash"    if trash
-  tags << "new"      if new_card?
-  tags << "frozen"   if frozen?
-  tags << "readonly" if readonly?
-  tags << "virtual"  if @virtual
-  tags << "set_mods_loaded" if @set_mods_loaded
-
   error_messages = errors.any? ? "<E*#{errors.full_messages * ', '}*>" : ""
-
-  "#<Card##{id}[#{debug_type}](#{name})#{error_messages}{#{tags * ','}}"
+  "#<Card##{id}[#{debug_type}](#{name})#{error_messages}{#{inspect_tags * ','}}"
 end
 
 private
 
+def inspect_tags
+  %w[trash new frozen readonly virtual set_mods_loaded].map do |tag|
+    tag if send "#{tag}?"
+  end.compact
+end
+
 def debug_type
   "#{type_code || ''}:#{type_id}"
 end
 end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/debug.rb ~~
+# ~~ generated from /Users/ezl5238/dev/decko/gem/card/mod/core/set/all/debug.rb ~~

data/tmpsets/set/mod002-core/all/initialize.rb

@@ -4,8 +4,8 @@ class Card; module Set; class All
 #
 module Initialize;
 extend Card::Set
-def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/initialize.rb"; end
-JUNK_INIT_ARGS = %w[missing skip_virtual id].freeze
+def self.source_location; "/Users/ezl5238/dev/decko/gem/card/mod/core/set/all/initialize.rb"; end
+JUNK_INIT_ARGS = %i[missing skip_virtual id].freeze
 
 module ClassMethods
   def new args={}, _options={}
@@ -15,7 +15,7 @@ module ClassMethods
   end
 
   def with_normalized_new_args args={}
-    args = (args || {}).stringify_keys
+    args = (args || {}).symbolize_keys
     delete_junk_args args
     normalize_type_args args
     normalize_content_args args
@@ -29,17 +29,17 @@ module ClassMethods
   end
 
   def normalize_type_args args
-    %w[type type_code].each { |k| args.delete(k) if args[k].blank? }
+    %i[type type_code].each { |k| args.delete(k) if args[k].blank? }
   end
 
   def normalize_content_args args
-    args.delete("content") if args["attach"] # should not be handled here!
-    args["db_content"] = args.delete "content" if args["content"]
+    args.delete(:content) if args[:attach] # should not be handled here!
+    args[:db_content] = args.delete :content if args[:content]
   end
 end
 
 def initialize args={}
-  args["name"] = initial_name args["name"]
+  args[:name] = initial_name args[:name]
 
   handle_set_modules args do
     handle_type args do
@@ -50,14 +50,14 @@ def initialize args={}
 end
 
 def handle_set_modules args
-  skip_modules = args.delete "skip_modules"
+  skip_modules = args.delete :skip_modules
   yield
   include_set_modules unless skip_modules
 end
 
 def handle_type args
-  type_lookup = args["type_lookup"]
-  @supercard = args.delete "supercard"
+  type_lookup = args[:type_lookup]
+  @supercard = args.delete :supercard
 
   yield
   type_id_from_template if type_lookup == :force || (!type_id && type_lookup != :skip)
@@ -71,15 +71,23 @@ def include_set_modules
   return self if @set_mods_loaded
 
   set_modules.each do |m|
-    singleton_class.send :include, m
+    include_set_module m
   end
   assign_set_specific_attributes
   @uncacheable = @set_mods_loaded = true
   self
 end
 
+def include_set_module m
+  singleton_class.send :include, m
+end
+
+def set_mods_loaded?
+  @set_mods_loaded == true
+end
+
 def uncacheable?
   @uncacheable == true
 end
 end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/initialize.rb ~~
+# ~~ generated from /Users/ezl5238/dev/decko/gem/card/mod/core/set/all/initialize.rb ~~

data/tmpsets/set/mod002-core/all/name_events.rb

@@ -5,126 +5,124 @@ class Card; module Set; class All
 # STAGE: validate
 module NameEvents;
 extend Card::Set
-def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/name_events.rb"; end
+def self.source_location; "/Users/ezl5238/dev/decko/gem/card/mod/core/set/all/name_events.rb"; end
 
 event :validate_name, :validate, on: :save, changed: :name, when: :no_autoname? do
   validate_legality_of_name
   return if errors.any?
+
   Card.write_to_soft_cache self
   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 * " ")
-  elsif changing_existing_tag_to_junction?
-    errors.add :name, tr(:error_name_tag, name: name)
+    errors.add :name, t(:core_error_banned_characters,
+                        banned: Card::Name.banned_array * " ")
+  elsif changing_existing_tag_to_compound?
+    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 :validate_renaming, :validate, on: :update, changed: :name, skip: :allowed do
+  return if name_before_act&.to_name == name # just changing to new variant
 
-event :set_autoname, :prepare_to_store, on: :create, when: :autoname? do
-  self.name = autoname rule(:autoname)
-  rule_card(:autoname).update_column :db_content, name
-  pull_from_trash!
-  Card.write_to_soft_cache self
+  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 :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
 
-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
+  existing_card.rename_as_trash_obstacle
 end
 
 event :prepare_left_and_right, :store, changed: :name, on: :save do
   return if name.simple?
+
   prepare_side :left
   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_compound?
+  return false unless changing_name_to_compound?
 
-def changing_existing_tag_to_junction?
-  return false unless changing_name_to_junction?
   name_in_use_as_tag?
 end
 
@@ -132,8 +130,8 @@ def name_in_use_as_tag?
   !Card.where(right_id: id, trash: false).take.nil?
 end
 
-def changing_name_to_junction?
-  name.junction? && simple?
+def changing_name_to_compound?
+  name.compound? && simple?
 end
 
 def old_name_in_way? sidecard
@@ -148,5 +146,27 @@ 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
 end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/name_events.rb ~~
+# ~~ generated from /Users/ezl5238/dev/decko/gem/card/mod/core/set/all/name_events.rb ~~

data/tmpsets/set/mod002-core/all/reference_events.rb

@@ -0,0 +1,78 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All
+# Set: All cards (ReferenceEvents)
+#
+# test for updating referer content
+module ReferenceEvents;
+extend Card::Set
+def self.source_location; "/Users/ezl5238/dev/decko/gem/card/mod/core/set/all/reference_events.rb"; end
+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
+end;end;end;end;
+# ~~ generated from /Users/ezl5238/dev/decko/gem/card/mod/core/set/all/reference_events.rb ~~

data/tmpsets/set/mod002-core/all/states.rb

@@ -11,7 +11,7 @@ class Card; module Set; class All
 #   etc. But we don't store all these cards in the database; we generate them dynamically
 module States;
 extend Card::Set
-def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/states.rb"; end
+def self.source_location; "/Users/ezl5238/dev/decko/gem/card/mod/core/set/all/states.rb"; end
 #   based on the names.
 # - *unknown* cards are everything else.
 #
@@ -24,8 +24,8 @@ module ClassMethods
   def real? mark
     quick_fetch(mark).present?
   end
-  alias exist? real?
-  alias exists? real?
+  alias_method :exist?, :real?
+  alias_method :exists?, :real?
 
   def known? mark
     fetch(mark).present?
@@ -78,8 +78,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?
@@ -90,4 +90,4 @@ def user_changes?
   actions.joins(:act).where("card_acts.actor_id != ?", WagnBotID).exists?
 end
 end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/states.rb ~~
+# ~~ generated from /Users/ezl5238/dev/decko/gem/card/mod/core/set/all/states.rb ~~