card 1.99.2 → 1.100.0

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

@@ -49,11 +49,11 @@ def handle_set_modules args
 end
 
 def handle_type args
-  skip_type_lookup = args["skip_type_lookup"]
+  type_lookup = args["type_lookup"]
   @supercard = args.delete "supercard"
 
   yield
-  self.type_id = get_type_id_from_structure if !type_id && !skip_type_lookup
+  type_id_from_template if type_lookup == :force || (!type_id && type_lookup != :skip)
 end
 
 def initial_name name
@@ -61,12 +61,16 @@ def initial_name name
 end
 
 def include_set_modules
-  unless @set_mods_loaded
-    set_modules.each do |m|
-      singleton_class.send :include, m
-    end
-    assign_set_specific_attributes
-    @set_mods_loaded = true
+  return self if @set_mods_loaded
+
+  set_modules.each do |m|
+    singleton_class.send :include, m
   end
+  assign_set_specific_attributes
+  @uncacheable = @set_mods_loaded = true
   self
 end
+
+def uncacheable?
+  @uncacheable == true
+end

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

@@ -1,4 +1,4 @@
-event :discard_deleted_locations, in: :finalize, on: :delete do
+event :discard_deleted_locations, :finalize, on: :delete do
   Env.discard_locations_for self
   configure_successful_deletion if success.target == self
 end

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

@@ -21,35 +21,70 @@ module ClassMethods
 end
 
 def name
-  super.to_name
+  @name ||= left_id ? Card::Lexicon.lex_to_name([left_id, right_id]) : super.to_name
+end
+
+def key
+  @key ||= left_id ? name.key : super
 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
-  name
+  @name = superize_name newname.to_name
+  self.key = @name.key
+  update_subcard_names @name
+  write_attribute :name, (@name.simple? ? @name.s : nil)
+  assign_side_ids
+  @name
+end
+
+def assign_side_ids
+  if name.simple?
+    self.left_id = self.right_id = nil
+  else
+    assign_side_id :left_id=, :left_name
+    assign_side_id :right_id=, :right_name
+  end
+end
+
+# assigns left_id and right_id based on names.
+# if side card is new, id is temporarily stored as -1
+def assign_side_id side_id_equals, side_name
+  side_id = Card::Lexicon.id(name.send(side_name)) || -1
+  send side_id_equals, side_id
 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
+  update_superleft cardname
   cardname.absolute_name @supercard.name
 end
 
+def update_superleft cardname
+  @superleft = @supercard if cardname.field_of? @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
-  # reset the old name - should be handled in tracked_attributes!!
-  reset_patterns_if_rule
+  return if newkey == key
+  update_cache_key key do
+    write_attribute :key, (name.simple? ? newkey : nil)
+    @key = newkey
+  end
+  clean_patterns
+  @key
+end
+
+def clean_patterns
+  return unless patterns?
   reset_patterns
-  newkey
+  patterns
+end
+
+def update_cache_key oldkey
+  yield
+  was_in_cache = Card.cache.soft.delete oldkey
+  Card.write_to_soft_cache self if was_in_cache
 end
 
 def update_subcard_names new_name, name_to_replace=nil
@@ -78,7 +113,7 @@ def name_to_replace_for_subcard subcard, new_name
 end
 
 def autoname name
-  if Card.exists?(name) || ActManager.include?(name)
+  if Card.exists?(name) || Director.include?(name)
     autoname name.next
   else
     name
@@ -102,7 +137,7 @@ def left *args
   case
   when simple?    then nil
   when superleft then superleft
-  when attribute_is_changing?(:name) && name.to_name.trunk_name.key == name_before_act.to_name.key
+  when name_is_changing? && name.to_name.trunk_name == name_before_act.to_name
     nil # prevent recursion when, eg, renaming A+B to A+B+C
   else
     Card.fetch name.left, *args
@@ -135,103 +170,70 @@ def left_or_new args={}
   left(args) || Card.new(args.merge(name: name.left))
 end
 
-def fields
-  field_names.map { |name| Card[name] }
-end
+# NOTE: for all these helpers, method returns *all* fields/children/descendants.
+# (Not just those current user has permission to read.)
 
-def field_names parent_name=nil
-  child_names parent_name, :left
+def fields
+  field_ids.map { |id| Card[id] }
 end
 
-def children
-  child_names.map { |name| Card[name] }
+def field_names
+  field_ids.map { |id| Card::Name[id] }
 end
 
-def child_names parent_name=nil, side=nil
-  # eg, A+B is a child of A and B
-  parent_name ||= name
-  side ||= parent_name.to_name.simple? ? :part : :left
-  Card.search({ side => parent_name, return: :name },
-              "(#{side}) children of #{parent_name}")
+def field_ids
+  child_ids :left
 end
 
-# ids of children and children's children
-def descendant_ids parent_id=nil
-  return [] if new_card?
-  parent_id ||= id
-  Auth.as_bot do
-    child_ids = Card.search part: parent_id, return: :id
-    child_descendant_ids = child_ids.map { |cid| descendant_ids cid }
-    (child_ids + child_descendant_ids).flatten.uniq
+def each_child
+  child_ids.each do |id|
+    (child = Card[id]) && yield(child)
+    # check should not be needed (remove after fixing data problems)
   end
 end
 
-# children and children's children
-# NOTE - set modules are not loaded
-# -- should only be used for name manipulations
-def descendants
-  @descendants ||= descendant_ids.map { |id| Card.quick_fetch id }
-end
-
-def repair_key
+# eg, A+B is a child of A and B
+def child_ids side=nil
+  return [] unless id
+  side ||= name.simple? ? :part : :left_id
   Auth.as_bot do
-    correct_key = name.key
-    current_key = key
-    return self if current_key == correct_key
-
-    if (key_blocker = Card.find_by_key_and_trash(correct_key, true))
-      key_blocker.name = key_blocker.name + "*trash#{rand(4)}"
-      key_blocker.save
-    end
-
-    saved =   (self.key = correct_key) && save!
-    saved ||= (self.name = current_key) && save!
-
-    if saved
-      descendants.each(&:repair_key)
-    else
-      Rails.logger.debug "FAILED TO REPAIR BROKEN KEY: #{key}"
-      self.name = "BROKEN KEY: #{name}"
-    end
-    self
+    Card.search({ side => id, return: :id, limit: 0 }, "children of #{name}")
   end
-rescue StandardError
-  Rails.logger.info "BROKE ATTEMPTING TO REPAIR BROKEN KEY: #{key}"
-  self
 end
 
-def right_id= card_or_id
-  write_card_or_id :right_id, card_or_id
+def each_descendant &block
+  each_child do |child|
+    yield child
+    child.each_descendant(&block)
+  end
 end
 
-def left_id= card_or_id
-  write_card_or_id :left_id, card_or_id
+def right_id= cardish
+  write_card_or_id :right_id, cardish
 end
 
-def type_id= card_or_id
-  write_card_or_id :type_id, card_or_id
+def left_id= cardish
+  write_card_or_id :left_id, cardish
 end
 
-def write_card_or_id attribute, card_or_id
-  if card_or_id.is_a? Card
-    write_attribute_to_card attribute, card_or_id
-  else
-    write_attribute attribute, card_or_id
-  end
+def write_card_or_id attribute, cardish
+  when_id_exists(cardish) { |id| write_attribute attribute, id }
 end
 
-def write_attribute_to_card attribute, card
-  if card.id
-    write_attribute attribute, card.id
+def when_id_exists cardish, &block
+  if (card_id = Card.id cardish)
+    yield card_id
+  elsif cardish.is_a? Card
+    with_id_after_store cardish, &block
   else
-    add_subcard card
-    card.director.prior_store = true
-    with_id_when_exists(card) do |id|
-      write_attribute attribute, id
-    end
+    yield cardish # eg nil
   end
 end
 
-def with_id_when_exists card, &block
-  card.director.call_after_store(&block)
+# subcards are usually saved after super cards;
+# after_store forces it to save the subcard first
+# and callback afterwards
+def with_id_after_store subcard
+  add_subcard subcard
+  subcard.director.after_store { |card| yield card.id }
 end

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

@@ -18,13 +18,16 @@ event :validate_name, :validate, on: :save, changed: :name do
   validate_uniqueness_of_name
 end
 
-event :validate_uniqueness_of_name do
+event :validate_uniqueness_of_name, skip: :allowed do
   # validate uniqueness of name
-  rel = Card.where key: name.key, trash: false
-  rel = rel.where "id <> ?", id if id
-  if (existing = rel.take)
-    errors.add :name, tr(:error_name_exists, name: existing.name)
-  end
+
+  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)
 end
 
 event :validate_legality_of_name do
@@ -52,27 +55,54 @@ end
 # STAGE: store
 
 event :expire_old_name, :store, changed: :name, on: :update do
-  ActManager.expirees << name_before_act
+  Director.expirees << name_before_act
+end
+
+event :update_lexicon_on_create, :finalize, changed: :name, on: :create do
+  Card::Lexicon.add self
 end
 
-event :set_left_and_right, :store,
-      changed: :name, on: :save do
-  if name.junction?
-    %i[left right].each do |side|
-      assign_side_id side
-    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
-    self.left_id = self.right_id = nil
+    name_before_act
   end
 end
 
-# STAGE: finalize
+event :prepare_left_and_right, :store, changed: :name, on: :save do
+  return if name.simple?
+  prepare_side :left
+  prepare_side :right
+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.
+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
 
 private
@@ -90,21 +120,15 @@ def changing_name_to_junction?
   name.junction? && simple?
 end
 
-def assign_side_id side
-  sidename = name.send "#{side}_name"
-  sidecard = Card[sidename] || ActManager.card(sidename)
-
-  # eg, renaming A to A+B
-  old_name_in_way = (sidecard&.id && sidecard&.id == id)
-  suspend_name(sidename) if old_name_in_way
-  send "#{side}_id=", side_id_or_card(old_name_in_way, sidecard, sidename)
+def old_name_in_way? sidecard
+  real? && sidecard&.simple? && id == sidecard&.id
 end
 
-def side_id_or_card old_name_in_way, sidecard, sidename
-  if !sidecard || old_name_in_way
-    add_subcard(sidename.s)
-  else
-    # if sidecard doesn't have an id, it's already part of this act
-    sidecard.id || sidecard
-  end
+def clear_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.where(id: id).update_all(name: nil, key: nil, left_id: nil, right_id: nil)
+  Card.expire name
+  Card::Lexicon.cache.reset # probably overkill, but this for an edge case...
+  # Card::Lexicon.delete id, key
 end

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

@@ -1,42 +1,37 @@
+def patterns?
+  defined? @patterns
+end
 
-def patterns
-  @patterns ||= set_patterns.map { |sub| sub.new self }.compact
+def all_patterns
+  @all_patterns ||= set_patterns.map { |sub| sub.new self }.compact
 end
 
-def patterns_with_new
-  new_card? ? patterns_without_new[1..-1] : patterns_without_new
+# new cards do not
+def patterns
+  @patterns ||= (new_card? ? all_patterns[1..-1] : all_patterns)
 end
-alias_method_chain :patterns, :new
 
 def reset_patterns
-  @patterns = nil
+  # Rails.logger.info "resetting patterns: #{name}"
+  @patterns = @all_patterns = nil
   @template = @virtual = nil
   @set_mods_loaded = @set_modules = @set_names = @rule_set_keys = nil
   @junction_only = nil # only applies to set cards
   true
 end
 
-def reset_patterns_if_rule _saving=false
-  return unless real? && is_rule? && (set = left)
-
-  set.reset_patterns
-  set.include_set_modules
-  set
-end
-
 def safe_set_keys
   patterns.map(&:safe_key).reverse * " "
 end
 
 def set_modules
-  @set_modules ||=
-    patterns_without_new[0..-2].reverse.map(&:module_list).flatten.compact
+  @set_modules ||= all_patterns[0..-2].reverse.map(&:module_list).flatten.compact
 end
 
 def set_format_modules klass
   @set_format_modules ||= {}
   @set_format_modules[klass] =
-    patterns_without_new[0..-2].reverse.map do |pattern|
+    all_patterns[0..-2].reverse.map do |pattern|
       pattern.format_module_list klass
     end.flatten.compact
 end