card 1.101.1 → 1.101.6

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

@@ -5,7 +5,7 @@ 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
+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)
@@ -78,6 +78,10 @@ def include_set_modules
   self
 end
 
+def set_mods_loaded?
+  @set_mods_loaded == true
+end
+
 def uncacheable?
   @uncacheable == true
 end

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

@@ -10,121 +10,119 @@ def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/name
 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 ~~

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/ethan/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/ethan/dev/decko/gem/card/mod/core/set/all/reference_events.rb ~~

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

@@ -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?

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

@@ -5,110 +5,10 @@ class Card; module Set; class All
 module Subcards;
 extend Card::Set
 def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/subcards.rb"; end
-def field tag, opts={}
-  Card.fetch name.field(tag), opts
-end
-
-def subcard card_name
-  subcards.card card_name
-end
-
-def subfield field_name
-  subcards.field field_name
-end
-
-def field? tag
-  field(tag) || subfield(tag)
-end
-
-def subcards
-  @subcards ||= Card::Subcards.new self
-end
-
-def subcards?
-  subcards.present?
-end
-
-def expire_subcards
-  subcards.clear
-end
-
-# phase_method :attach_subcard, before: :store do |name_or_card, args=nil|
-# TODO: handle differently in different stages
-def add_subcard name_or_card, args={}
-  subcards.add name_or_card, args
-end
-alias_method :attach_subcard, :add_subcard
-
-def add_subcard! name_or_card, args={}
-  subcard = subcards.add name_or_card, args
-  subcard.director.reset_stage
-  subcard
-end
-alias_method :attach_subcard!, :add_subcard!
-
-# phase_method :attach_subfield, before: :approve do |name_or_card, args=nil|
-def attach_subfield name_or_card, args={}
-  subcards.add_field name_or_card, args
-end
-alias_method :add_subfield, :attach_subfield
-
-def attach_subfield! name_or_card, args={}
-  subcard = subcards.add_field name_or_card, args
-  subcard.director.reset_stage
-  subcard
-end
-
-def detach_subcard name_or_card
-  subcards.remove name_or_card
-end
-alias_method :remove_subcard, :detach_subcard
-
-def detach_subfield name_or_card
-  subcards.remove_field name_or_card
-end
-alias_method :remove_subfield, :detach_subfield
-
-def clear_subcards
-  subcards.clear
-end
-
-# ensures subfield is present
-# does NOT override subfield content if already present
-def ensure_subfield field_name, args={}
-  if subfield_present? field_name
-    subfield field_name
-  else
-    add_subfield field_name, args
-  end
-end
-
-def subfield_present? field_name
-  subfield(field_name)&.content&.present?
-end
-
-def deep_clear_subcards
-  subcards.deep_clear
-end
-
-def handle_subcard_errors
-  subcards.each do |subcard|
-    subcard.errors.each do |error|
-      subcard_error subcard, error
-    end
-    subcard.errors.clear
-  end
-end
-
-def subcard_error subcard, error
-  msg = error.message
-  msg = "#{error.attribute} #{msg}" unless %i[content abort].member? error.attribute
-  errors.add subcard.name.from(name), msg
-end
-
 event :reject_empty_subcards, :prepare_to_validate do
   subcards.each_with_key do |subcard, key|
     next unless subcard.new? && subcard.unfilled?
+
     remove_subcard(key)
     director.subdirectors.delete(subcard)
   end