card 1.99.6 → 1.100.0

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

@@ -5,8 +5,10 @@ module ClassMethods
   end
 
   def retrieve_from_cache_by_id id, local_only=false
-    name = retrieve_from_cache "~#{id}", local_only
-    retrieve_from_cache name, local_only if name
+    key = Card::Lexicon.name(id)&.key
+    return unless key.present?
+
+    retrieve_from_cache key, local_only if key
   end
 
   def retrieve_from_cache_by_key key, local_only=false
@@ -33,15 +35,6 @@ module ClassMethods
     return unless (card = Card.cache.read key)
     card.expire
   end
-
-  def new_for_cache card, name, opts
-    return if name.is_a? Integer
-    return if name.blank? && !opts[:new]
-    return if card && (card.type_known? || skip_type_lookup?(opts))
-    new name: name,
-        skip_modules: true,
-        skip_type_lookup: skip_type_lookup?(opts)
-  end
 end
 
 def expire_pieces
@@ -96,7 +89,7 @@ def expire_views
 end
 
 def expire_names cache
-  [name, name_before_act].each do |name_version|
+  [name, name_before_act].uniq.each do |name_version|
     expire_name name_version, cache
   end
 end

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

@@ -8,7 +8,7 @@ event :validate_codename, :validate, on: :update, changed: :codename do
 end
 
 event :reset_codename_cache, :integrate, changed: :codename do
-  return if @action == :create && codename.nil?
+  return if action == :create && codename.nil?
 
   Card::Codename.reset_cache
   Card::Codename.generate_id_constants

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

@@ -1,5 +1,5 @@
 def content= value
-  self.db_content = value
+  self.db_content = standardize_content(value)
 end
 
 def content
@@ -15,6 +15,10 @@ def standard_content
   db_content || (new_card? && template.db_content)
 end
 
+def standardize_content value
+  value.is_a?(Array) ? value.join("\n") : value
+end
+
 def structured_content
   structure && template.db_content
 end
@@ -118,7 +122,6 @@ event :set_content, :store, on: :save do
   self.db_content = prepare_db_content
   @selected_action_id = @selected_content = nil
   clear_drafts
-  reset_patterns_if_rule true
 end
 
 event :save_draft, :store, on: :update, when: :draft? do

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

@@ -58,7 +58,7 @@ end
 
 def on_condition_applies? _event, actions
   actions = Array(actions).compact
-  actions.empty? ? true : actions.include?(@action)
+  actions.empty? ? true : actions.include?(action)
 end
 
 # if changing name/type, the old card has no-longer-applicable set modules, so we create
@@ -74,7 +74,7 @@ end
 
 # existing card is being changed in a way that alters its sets
 def updating_sets?
-  @action == :update && real? && (type_id_is_changing? || name_is_changing?)
+  action == :update && real? && (type_id_is_changing? || name_is_changing?)
 end
 
 # prevents locking in set_condition_card
@@ -93,7 +93,7 @@ def set_condition_card_with_new_set_modules
 end
 
 def changed_condition_applies? _event, db_columns
-  return true unless @action == :update
+  return true unless action == :update
   db_columns = Array(db_columns).compact
   return true if db_columns.empty?
   db_columns.any? { |col| single_changed_condition_applies? col }
@@ -124,13 +124,7 @@ end
 
 def single_changed_condition_applies? db_column
   return true unless db_column
-  db_column =
-    case db_column.to_sym
-    when :content then "db_content"
-    when :type    then "type_id"
-    else db_column.to_s
-    end
-  attribute_is_changing?(db_column)
+  send "#{db_column}_is_changing?"
 end
 
 def wrong_stage opts
@@ -142,9 +136,9 @@ def wrong_stage opts
   end
 end
 
-def wrong_action action
-  return false if on_condition_applies?(nil, action)
-  "on: #{action} method #{method} called on #{@action}"
+def wrong_action actn
+  return false if on_condition_applies?(nil, actn)
+  "on: #{actn} method #{method} called on #{action}"
 end
 
 def full_skip_hash

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

@@ -22,16 +22,9 @@ module ClassMethods
   #      new: { opts for Card#new }  Return a new card when not found
   # @return [Card]
   def fetch *args
-    mark, opts = normalize_fetch_args args
-    validate_fetch_opts! opts
-
-    card, needs_caching = retrieve_or_new mark, opts
-
-    return if card.nil?
-    write_to_cache card, opts[:local_only] if needs_caching
-    standard_fetch_results card, mark, opts
+    Card::Fetch.new(*args)&.retrieve_or_new
   rescue ActiveModel::RangeError => _e
-    return Card.new name: "card id out of range: #{mark}"
+    return Card.new name: "card id out of range: #{f.mark}"
   end
 
   # fetch only real (no virtual) cards
@@ -49,16 +42,7 @@ module ClassMethods
   # @param mark - see #fetch
   # @return [Card]
   def quick_fetch *mark
-    fetch mark, skip_virtual: true, skip_modules: true
-  end
-
-  # fetch only from the soft cache
-  #
-  # @param args - see #fetch
-  # @return [Card]
-  def fetch_soft *args
-    mark, opts = normalize_fetch_args args
-    fetch mark, opts.merge(local_only: true)
+    fetch(*mark, skip_virtual: true, skip_modules: true)
   end
 
   # @return [Card]
@@ -80,19 +64,17 @@ module ClassMethods
     end
   end
 
-  # @param mark - see #fetch
+  # @param mark_parts - see #fetch
   # @return [Integer]
-  def fetch_id *mark
-    mark, _opts = normalize_fetch_args mark
-    return mark if mark.is_a? Integer
-    card = quick_fetch mark.to_s
-    card && card.id
+  def fetch_id *mark_parts
+    mark = Card::Fetch.new(*mark_parts)&.mark
+    mark.is_a?(Integer) ? mark : quick_fetch(mark.to_s)&.id
   end
 
   # @param mark - see #fetch
   # @return [Card::Name]
   def fetch_name *mark
-    if (card = quick_fetch(mark))
+    if (card = quick_fetch(*mark))
       card.name
     elsif block_given?
       yield.to_name
@@ -105,7 +87,7 @@ module ClassMethods
 
   # @param mark - see #fetch
   # @return [Integer]
-  def fetch_type_id *mark
+  def fetch_type_id mark
     quick_fetch(mark)&.type_id
   end
 end
@@ -121,16 +103,8 @@ def fetch traits, opts={}
   end
 end
 
-def renew mark, new_opts
-  return self if new_opts.blank?
-  opts = new_opts.clone.reverse_merge name: mark
-  copy = dup
-  handle_default_content opts
-  copy.newish opts
-  copy
-end
-
 def newish opts
+  reset_patterns
   Card.with_normalized_new_args opts do |norm_opts|
     handle_type norm_opts do
       assign_attributes norm_opts
@@ -139,12 +113,6 @@ def newish opts
   end
 end
 
-def handle_default_content opts
-  return unless (default_content = opts.delete(:default_content)) && db_content.blank?
-
-  opts[:content] ||= default_content
-end
-
 def refresh force=false
   return self unless force || frozen? || readonly?
   return unless id

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

@@ -32,119 +32,4 @@ module ClassMethods
     opts[:name] ||= Card::Name.url_key_to_standard args[:mark]
     opts
   end
-
-  def validate_fetch_opts! opts
-    return unless opts[:new] && opts[:skip_virtual]
-    raise Card::Error, "fetch called with new args and skip_virtual"
-  end
-
-  def skip_type_lookup? opts
-    # if opts[:new] is not empty then we are initializing a variant that is
-    # different from the cached variant
-    # and can postpone type lookup for the cached variant
-    # if skipping virtual no need to look for actual type
-    opts[:skip_virtual] || opts[:new].present? || opts[:skip_type_lookup]
-  end
-
-  def retrieve_or_new mark, opts
-    card, needs_caching = retrieve_existing mark, opts
-    if (new_card = new_for_cache card, mark, opts)
-      [new_card, true]
-    else
-      [card, needs_caching]
-    end
-  end
-
-  # look in cache.  if that doesn't work, look in database
-  # @return [{Card}, {True/False}] Card object and "needs_caching" ruling
-  def retrieve_existing mark, opts
-    return [nil, false] unless mark.present?
-    mark_type, mark_key = retrievable_mark_type_and_value mark
-    if (card = retrieve_from_cache_by_mark mark_type, mark_key, opts)
-      # we have an acceptable card in the cache
-      # (and don't need to cache it again!)
-      [card, false]
-    else
-      # try to find the card in the database
-      card = retrieve_from_db mark_type, mark_key, opts[:look_in_trash]
-      [card, !(card.nil? || card.trash)]
-    end
-  end
-
-  def retrieve_from_cache_by_mark mark_type, mark_key, opts
-    card = send "retrieve_from_cache_by_#{mark_type}", mark_key, opts[:local_only]
-    return_cached_card?(card, opts[:look_in_trash]) ? card : nil
-  end
-
-  # In both the cache and the db, ids and keys are used to retrieve card data.
-  # This method identifies the kind of mark to use and its value
-  # @return [Array] first item is :id or :key, second is corresponding value
-  def retrievable_mark_type_and_value mark
-    # return mark_type and mark_value
-    if mark.is_a? Integer
-      [:id, mark]
-    else
-      [:key, mark.key]
-    end
-  end
-
-  def return_cached_card? card, look_in_trash
-    return false unless card
-    card.real? || !look_in_trash
-  end
-
-  # @return [Card, nil] Card object
-  def retrieve_from_db mark_type, mark_key, look_in_trash=false
-    query = { mark_type => mark_key }
-    query[:trash] = false unless look_in_trash
-    Card.where(query).take
-  end
-
-  def standard_fetch_results card, mark, opts
-    if card.new_card?
-      new_card_fetch_results card, mark, opts
-    else
-      finalize_fetch_results card, opts
-    end
-  end
-
-  def new_card_fetch_results card, mark, opts
-    if (new_opts = opts[:new])
-      card = card.renew mark, new_opts
-    elsif opts[:skip_virtual]
-      return nil
-    else
-      card.assign_name_from_fetched_mark! mark, opts
-    end
-    #
-    finalize_fetch_results card, opts
-    # must include_set_modules before checking `card.known?`,
-    # in case, eg, set modules override #virtual?
-    card if new_opts || card.known?
-  end
-
-  def finalize_fetch_results card, opts
-    card.include_set_modules unless opts[:skip_modules]
-    card
-  end
-
-  def normalize_fetch_args args
-    opts = args.last.is_a?(Hash) ? args.pop : {}
-    mark = id_or_name args
-    mark = absolutize_fetch_mark mark, opts.dig(:new, :supercard)
-    [mark, opts]
-  end
-
-  def absolutize_fetch_mark mark, supercard
-    return mark unless mark.name? && supercard
-    mark.to_name.absolute_name supercard.name
-  end
-end
-
-public
-
-def assign_name_from_fetched_mark! mark, opts
-  return if opts[:local_only]
-  return unless mark && mark.to_s != name
-  self.name = mark.to_s
 end

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
@@ -67,6 +67,10 @@ def include_set_modules
     singleton_class.send :include, m
   end
   assign_set_specific_attributes
-  @set_mods_loaded = true
+  @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