card 1.99.2 → 1.100.0

data/tmpsets/set/mod003-core/all/fetch.rb

@@ -29,16 +29,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
@@ -56,16 +49,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]
@@ -87,19 +71,17 @@ module ClassMethods
     end
   end
 
-  # @param mark - see #fetch
+  # @param args - 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
@@ -112,8 +94,8 @@ module ClassMethods
 
   # @param mark - see #fetch
   # @return [Integer]
-  def fetch_type_id *mark
-    (card = quick_fetch(mark)) && card.type_id
+  def fetch_type_id mark
+    quick_fetch(mark)&.type_id
   end
 end
 
@@ -121,30 +103,20 @@ end
 # INSTANCE METHODS
 # fetching from the context of a card
 
-def fetch opts={}
-  traits = opts.delete(:trait)
-  return unless traits
-  # should this fail as an incorrect api call?
-  traits = Array.wrap traits
-  traits.inject(self) do |card, trait|
+def fetch traits, opts={}
+  opts[:new][:supercard] = self if opts[:new]
+  Array.wrap(traits).inject(self) do |card, trait|
     Card.fetch card.name.trait(trait), opts
   end
 end
 
-def renew args={}
-  opts = args[:new].clone
-  handle_default_content opts
-  opts[:name] ||= name
-  opts[:skip_modules] = args[:skip_modules]
-  Card.new opts
-end
-
-def handle_default_content opts
-  if (default_content = opts.delete(:default_content)) && db_content.blank?
-    opts[:content] ||= default_content
-  elsif db_content.present? && !opts[:content]
-    # don't overwrite existing content
-    opts[:content] = db_content
+def newish opts
+  reset_patterns
+  Card.with_normalized_new_args opts do |norm_opts|
+    handle_type norm_opts do
+      assign_attributes norm_opts
+      self.name = name # trigger superize_name
+    end
   end
 end
 

data/tmpsets/set/mod003-core/all/fetch_helper.rb

@@ -20,143 +20,25 @@ module ClassMethods
     end
   end
 
-  def safe_param param
-    if param.respond_to? :to_unsafe_h
-      # clone doesn't work for Parameters
-      param.to_unsafe_h
-    else
-      # clone so that original params remain unaltered.  need deeper clone?
-      (param || {}).clone
-    end
-  end
-
   private
 
   def standard_controller_fetch args, card_opts
     mark = args[:mark] || card_opts[:name]
-    card = Card.fetch mark, look_in_trash: args[:look_in_trash], new: card_opts
+    card = Card.fetch mark, skip_modules: true,
+                            look_in_trash: args[:look_in_trash],
+                            new: card_opts
     card.assign_attributes card_opts if args[:assign] && card&.real?
+    card&.include_set_modules
     card
   end
 
   def controller_fetch_opts args
-    opts = safe_param args[:card]
+    opts = Env.hash args[:card]
     opts[:type] ||= args[:type] if args[:type]
     # for /new/:type shortcut.  we should handle in routing and deprecate this
-    opts[:name] ||= Card::Name.url_key_to_standard(args[:mark])
+    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
-    case
-      when opts[:new].present? then return card.renew(opts)
-      when opts[:new] # noop for empty hash
-      when opts[:skip_virtual] then return nil
-    end
-    card.assign_name_from_fetched_mark! mark, opts
-    finalize_fetch_results card, opts
-    card if opts[:new] || 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
 end;end;end;end;
 # ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/fetch_helper.rb ~~

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

@@ -9,47 +9,77 @@ JUNK_INIT_ARGS = %w[missing skip_virtual id].freeze
 
 module ClassMethods
   def new args={}, _options={}
+    with_normalized_new_args args do |normalized_args|
+      super normalized_args
+    end
+  end
+
+  def with_normalized_new_args args={}
     args = (args || {}).stringify_keys
+    delete_junk_args args
+    normalize_type_args args
+    normalize_content_args args
+    yield args
+  end
+
+  private
+
+  def delete_junk_args args
     JUNK_INIT_ARGS.each { |a| args.delete(a) }
+  end
+
+  def normalize_type_args args
     %w[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!
-    super args
+    args["db_content"] = args.delete "content" if args["content"]
   end
 end
 
 def initialize args={}
   args["name"] = initial_name args["name"]
-  args["db_content"] = args.delete "content" if args["content"]
-  @supercard = args.delete "supercard" # must come before name=
 
-  handle_skip_args args do
-    super args # ActiveRecord #initialize
+  handle_set_modules args do
+    handle_type args do
+      super args # ActiveRecord #initialize
+    end
   end
   self
 end
 
-def handle_skip_args args
+def handle_set_modules args
   skip_modules = args.delete "skip_modules"
-  skip_type_lookup = args["skip_type_lookup"]
   yield
-  self.type_id = get_type_id_from_structure if !type_id && !skip_type_lookup
   include_set_modules unless skip_modules
 end
 
+def handle_type args
+  type_lookup = args["type_lookup"]
+  @supercard = args.delete "supercard"
+
+  yield
+  type_id_from_template if type_lookup == :force || (!type_id && type_lookup != :skip)
+end
+
 def initial_name name
-  return name if name.is_a? String
-  Card::Name[name].to_s
+  name.is_a?(String) ? name : Card::Name[name].to_s
 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
 end;end;end;end;
 # ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/initialize.rb ~~

data/tmpsets/set/mod003-core/all/item.rb

@@ -27,29 +27,39 @@ def item_count args={}
   item_names(args).size
 end
 
+def items_to_content array
+  items = array.map { |i| standardize_item i }.reject(&:blank?)
+  self.content = items.to_pointer_content
+end
+
+def standardize_item item
+  Card::Name[item]
+end
+
 def include_item? item
-  key = item.is_a?(Card) ? item.name.key : item.to_name.key
-  item_names.map { |name| name.to_name.key }.member? key
+  item_names.include? Card::Name[item]
 end
 
 def add_item item
   return if include_item? item
-  self.content = "#{content}\n#{item}"
+  items_to_content(items_strings << item)
 end
 
 def drop_item item
+  item = Card::Name[item]
   return unless include_item? item
-  new_names = item_names.reject { |i| i == item }
-  self.content = new_names.empty? ? "" : new_names.join("\n")
+  items_to_content(item_names.reject { |i| i == item })
 end
 
 def insert_item index, name
   new_names = item_names
   new_names.delete name
   new_names.insert index, name
-  self.content = new_names.join "\n"
+  items_to_content new_names
 end
 
+# I think the following should work as add_item...
+#
 def add_id id
   add_item "~#{id}"
 end

data/tmpsets/set/mod003-core/all/location_history.rb

@@ -19,7 +19,7 @@ end
 def configure_successful_deletion
   if Env.ajax?
     success.card = self
-    success.view = :missing unless success.view
+    success.view = :unknown unless success.view
   else
     success.target = :previous
   end

data/tmpsets/set/mod003-core/all/name.rb

@@ -28,55 +28,94 @@ 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
   return unless @subcards
   subcards.each do |subcard|
-    # if subcard has a relative name like +C
-    # and self is a subcard as well that changed from +B to A+B then
-    # +C should change to A+B+C. #replace doesn't work in this case
-    # because the old name +B is not a part of +C
-    name_to_replace ||=
-      if subcard.name.junction? &&
-         subcard.name.parts.first.empty? &&
-         new_name.parts.first.present?
-        # replace the empty part
-        "".to_name
-      else
-        name
-      end
-    subcard.name = subcard.name.swap name_to_replace, new_name.s
-    subcard.update_subcard_names new_name, name
+    update_subcard_name subcard, new_name, name_to_replace if subcard.new?
+  end
+end
+
+def update_subcard_name subcard, new_name, name_to_replace
+  name_to_replace ||= name_to_replace_for_subcard subcard, new_name
+  subcard.name = subcard.name.swap name_to_replace, new_name.s
+  subcard.update_subcard_names new_name, name # needed?  shouldn't #name= trigger this?
+end
+
+def name_to_replace_for_subcard subcard, new_name
+  # if subcard has a relative name like +C
+  # and self is a subcard as well that changed from +B to A+B then
+  # +C should change to A+B+C. #replace doesn't work in this case
+  # because the old name +B is not a part of +C
+  if subcard.name.starts_with_joint? && new_name.parts.first.present?
+    "".to_name
+  else
+    name
   end
 end
 
@@ -104,8 +143,8 @@ end
 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 superleft then superleft
+  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
@@ -138,69 +177,42 @@ def left_or_new args={}
   left(args) || Card.new(args.merge(name: name.left))
 end
 
+# NOTE: for all these helpers, method returns *all* fields/children/descendants.
+# (Not just those current user has permission to read.)
+
 def fields
-  field_names.map { |name| Card[name] }
+  field_ids.map { |id| Card[id] }
 end
 
-def field_names parent_name=nil
-  child_names parent_name, :left
+def field_names
+  field_ids.map { |id| Card::Name[id] }
 end
 
-def children
-  child_names.map { |name| Card[name] }
+def field_ids
+  child_ids :left
 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 each_child
+  child_ids.each do |id|
+    (child = Card[id]) && yield(child)
+    # check should not be needed (remove after fixing data problems)
+  end
 end
 
-# ids of children and children's children
-def descendant_ids parent_id=nil
-  return [] if new_card?
-  parent_id ||= id
+# 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
-    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
+    Card.search({ side => id, return: :id, limit: 0 }, "children of #{name}")
   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
-  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
+def each_descendant &block
+  each_child do |child|
+    yield child
+    child.each_descendant(&block)
   end
-rescue StandardError
-  Rails.logger.info "BROKE ATTEMPTING TO REPAIR BROKEN KEY: #{key}"
-  self
 end
 
 def right_id= card_or_id
@@ -211,10 +223,6 @@ def left_id= card_or_id
   write_card_or_id :left_id, card_or_id
 end
 
-def type_id= card_or_id
-  write_card_or_id :type_id, card_or_id
-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