card 1.99.1 → 1.99.6

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

@@ -106,7 +106,7 @@ module ClassMethods
   # @param mark - see #fetch
   # @return [Integer]
   def fetch_type_id *mark
-    (card = quick_fetch(mark)) && card.type_id
+    quick_fetch(mark)&.type_id
   end
 end
 
@@ -114,33 +114,37 @@ 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
+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
-  opts[:name] ||= name
-  opts[:skip_modules] = args[:skip_modules]
-  Card.new opts
+  copy.newish opts
+  copy
 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
+  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
 
+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
@@ -148,4 +152,3 @@ def refresh force=false
   fresh_card.include_set_modules
   fresh_card
 end
-

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

@@ -13,16 +13,6 @@ 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
@@ -36,10 +26,10 @@ module ClassMethods
   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
 
@@ -119,14 +109,18 @@ module ClassMethods
   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
+    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
-    card.assign_name_from_fetched_mark! mark, opts
+    #
     finalize_fetch_results card, opts
-    card if opts[:new] || card.known?
+    # 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

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

@@ -2,45 +2,71 @@ 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"
+  yield
+  include_set_modules unless skip_modules
+end
+
+def handle_type args
   skip_type_lookup = args["skip_type_lookup"]
+  @supercard = args.delete "supercard"
+
   yield
   self.type_id = get_type_id_from_structure if !type_id && !skip_type_lookup
-  include_set_modules unless skip_modules
 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
+  @set_mods_loaded = true
   self
 end

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

@@ -20,29 +20,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/mod/core/set/all/name.rb

@@ -55,21 +55,25 @@ 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
 

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

@@ -18,7 +18,7 @@ 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
@@ -55,8 +55,7 @@ event :expire_old_name, :store, changed: :name, on: :update do
   ActManager.expirees << name_before_act
 end
 
-event :set_left_and_right, :store,
-      changed: :name, on: :save do
+event :set_left_and_right, :store, changed: :name, on: :save do
   if name.junction?
     %i[left right].each do |side|
       assign_side_id side

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

@@ -53,3 +53,7 @@ end
 def rule_set_keys
   @rule_set_keys ||= patterns.map(&:rule_set_key).compact
 end
+
+def include_module? set
+  singleton_class&.include? set
+end

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

@@ -29,8 +29,9 @@ def ok? action
 end
 
 def ok_with_fetch? action, opts={}
-  card = opts[:trait].nil? ? self : fetch(opts)
-  card && card.ok_without_fetch?(action)
+  trait = opts.delete :trait
+  card = trait.nil? ? self : fetch(trait, opts)
+  card&.ok_without_fetch? action
 end
 
 # note: method is chained so that we can return the instance variable @action_ok
@@ -45,7 +46,7 @@ def who_can action
 end
 
 def anyone_can? action
-  who_can(action).include? Card::AnyoneID
+  who_can(action).include? AnyoneID
 end
 
 def direct_rule_card action
@@ -96,7 +97,7 @@ def require_permission_rule! rule_id, action
 end
 
 def rule_class_name
-  trunk.type_id == Card::SetID ? name.trunk_name.tag : nil
+  trunk.type_id == SetID ? name.trunk_name.tag : nil
 end
 
 def you_cant what
@@ -179,20 +180,21 @@ event :set_field_read_rules,
   # (because of *type plus right)
   # skip if name is updated because will already be resaved
 
-  Auth.as_bot do
-    fields.each do |field|
-      field.refresh.update_read_rule
-    end
+  each_field_as_bot do |field|
+    field.refresh.update_read_rule
   end
 end
 
-# currently doing a brute force search for every card that may be impacted.
-# may want to optimize(?)
 def update_field_read_rules
+  return unless type_id_changed? || read_rule_id_changed?
+  each_field_as_bot do |field|
+    field.update_read_rule if field.rule(:read) == "_left"
+  end
+end
+
+def each_field_as_bot
   Auth.as_bot do
-    fields.each do |field|
-      field.update_read_rule if field.rule(:read) == "_left"
-    end
+    fields.each { |field| yield field }
   end
 end
 

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

@@ -15,6 +15,7 @@ def suspend_name name
 end
 
 event :validate_renaming, :validate, on: :update, changed: :name, skip: :allowed do
+  return if name_before_act&.to_name == name # just changing to new variant
   errors.add :content, tr(:cannot_change_content) if db_content_is_changing?
   errors.add :type, tr(:cannot_change_type) if type_id_is_changing?
 end
@@ -22,18 +23,22 @@ end
 event :cascade_name_changes, :finalize, on: :update, changed: :name,
                                         before: :name_change_finalized do
   @descendants = nil # reset
+  skip_rename_events! if act_card?
 
   children.each do |child|
     Rails.logger.debug "cascading name: #{child.name}"
     newname = child.name.swap name_before_last_save, name
-    # not sure if this is still needed since we attach the children as subcards
-    # (it used to be resolved right here without adding subcards)
-    ActManager.expirees << child.name
-    child.skip_event! :check_permissions
-
     # superleft has to be the first argument. Otherwise the call of `name=` in
     # `assign_attributes` can cause problems because `left` doesn't find the new left.
     attach_subcard child.name, superleft: self, name: newname,
                                update_referers: update_referers
   end
 end
+
+private
+
+def skip_rename_events!
+  # these are skipped for children, because they've already been called in the act card
+  skip_event! :validate_uniqueness_of_name, :validate_renaming, :check_permissions
+  skip_event! :set_read_rule if name.simple?
+end

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

@@ -1,60 +1,3 @@
-# frozen_string_literal: true
-
-RULE_SQL = %(
-  SELECT
-    rules.id      AS rule_id,
-    settings.id   AS setting_id,
-    sets.id       AS set_id,
-    sets.left_id  AS anchor_id,
-    sets.right_id AS set_tag_id
-  FROM cards rules
-  JOIN cards sets     ON rules.left_id  = sets.id
-  JOIN cards settings ON rules.right_id = settings.id
-  WHERE     sets.type_id = #{Card::SetID}
-    AND settings.type_id = #{Card::SettingID}
-    AND (settings.codename != 'follow' OR rules.db_content != '')
-    AND    rules.trash is false
-    AND     sets.trash is false
-    AND settings.trash is false;
-).freeze
-
-# FIXME: "follow" hardcoded above
-
-READ_RULE_SQL = %(
-  SELECT
-    refs.referee_id AS party_id,
-    read_rules.id   AS read_rule_id
-  FROM cards read_rules
-  JOIN card_references refs ON refs.referer_id    = read_rules.id
-  JOIN cards sets           ON read_rules.left_id = sets.id
-  WHERE read_rules.right_id = #{Card::ReadID}
-    AND       sets.type_id  = #{Card::SetID}
-    AND read_rules.trash is false
-    AND       sets.trash is false;
-).freeze
-
-PREFERENCE_SQL = %(
-  SELECT
-    preferences.id AS rule_id,
-    settings.id    AS setting_id,
-    sets.id        AS set_id,
-    sets.left_id   AS anchor_id,
-    sets.right_id  AS set_tag_id,
-    users.id       AS user_id
-  FROM cards preferences
-  JOIN cards user_sets ON preferences.left_id  = user_sets.id
-  JOIN cards settings  ON preferences.right_id = settings.id
-  JOIN cards users     ON user_sets.right_id   = users.id
-  JOIN cards sets      ON user_sets.left_id    = sets.id
-  WHERE sets.type_id     = #{Card::SetID}
-    AND settings.type_id = #{Card::SettingID}
-    AND (%s or users.codename = 'all')
-    AND sets.trash        is false
-    AND settings.trash    is false
-    AND users.trash       is false
-    AND user_sets.trash   is false
-    AND preferences.trash is false;
-).freeze
 
 def is_rule?
   is_standard_rule? || is_preference?
@@ -62,20 +5,20 @@ end
 
 def is_standard_rule?
   (r = right(skip_modules: true)) &&
-    r.type_id == Card::SettingID &&
+    r.type_id == SettingID &&
     (l = left(skip_modules: true)) &&
-    l.type_id == Card::SetID
+    l.type_id == SetID
 end
 
 # TODO: abstract so account doesn't have to have User type.
 def is_preference?
   name.parts.length > 2 &&
     (r = right(skip_modules: true)) &&
-    r.type_id == Card::SettingID &&
+    r.type_id == SettingID &&
     (set = self[0..-3, skip_modules: true]) &&
-    set.type_id == Card::SetID &&
+    set.type_id == SetID &&
     (user = self[-2, skip_modules: true]) &&
-    (user.type_id == Card::UserID || user.codename == :all)
+    (user.type_id == UserID || user.codename == :all)
 end
 
 def rule setting_code, options={}
@@ -96,8 +39,9 @@ def rule_card_id setting_code, options={}
   end
 
   rule_set_keys.each do |rule_set_key|
-    rule_id = self.class.rule_cache["#{rule_set_key}+#{setting_code}"]
-    rule_id ||= fallback && self.class.rule_cache["#{rule_set_key}+#{fallback}"]
+    rule_cache = Card::Rule.rule_cache
+    rule_id = rule_cache["#{rule_set_key}+#{setting_code}"]
+    rule_id ||= fallback && rule_cache["#{rule_set_key}+#{fallback}"]
     return rule_id if rule_id
   end
   nil
@@ -120,172 +64,3 @@ def related_sets with_self=false
   end
   sets
 end
-
-module ClassMethods
-  # User-specific rule use the pattern
-  # user+set+setting
-  def preference_sql user_id=nil
-    user_restriction =
-      if user_id
-        "users.id = #{user_id}"
-      else
-        "users.type_id = #{Card::UserID}"
-      end
-    PREFERENCE_SQL % user_restriction
-  end
-
-  def global_setting name
-    Auth.as_bot do
-      (card = Card[name]) && !card.db_content.strip.empty? && card.db_content
-    end
-  end
-
-  def toggle val
-    val.to_s.strip == "1"
-  end
-
-  def rule_cache_key row
-    return false unless (setting_code = Card::Codename[row["setting_id"].to_i])
-
-    anchor_id = row["anchor_id"]
-    set_class_id = anchor_id.nil? ? row["set_id"] : row["set_tag_id"]
-    return false unless (set_class_code = Card::Codename[set_class_id.to_i])
-
-    [anchor_id, set_class_code, setting_code].compact.map(&:to_s) * "+"
-  end
-
-  def interpret_simple_rules
-    ActiveRecord::Base.connection.select_all(RULE_SQL).each do |row|
-      next unless (key = rule_cache_key row)
-      @rule_hash[key] = row["rule_id"].to_i
-    end
-  end
-
-  def interpret_preferences
-    ActiveRecord::Base.connection.select_all(preference_sql).each do |row|
-      next unless (key = rule_cache_key row) && (user_id = row["user_id"])
-      add_preference_hash_values key, row["rule_id"].to_i, user_id.to_i
-    end
-  end
-
-  def add_preference_hash_values key, rule_id, user_id
-    @rule_hash[preference_key(key, user_id)] = rule_id
-    @user_ids_hash[key] ||= []
-    @user_ids_hash[key] << user_id
-    @rule_keys_hash[user_id] ||= []
-    @rule_keys_hash[user_id] << key
-  end
-
-  def cached_rule_keys_for user_id
-    rule_keys_cache[user_id] || []
-  end
-
-  def all_user_ids_with_rule_for set_card, setting_code
-    key =
-      if (l = set_card.left) && (r = set_card.right)
-        set_class_code = Card::Codename[r.id]
-        "#{l.id}+#{set_class_code}+#{setting_code}"
-      else
-        set_class_code = Card::Codename[set_card.id]
-        "#{set_class_code}+#{setting_code}"
-      end
-    user_ids = user_ids_cache[key] || []
-    if user_ids.include? AllID  # rule for all -> return all user ids
-      Card.where(type_id: UserID).pluck(:id)
-    else
-      user_ids
-    end
-  end
-
-  def preference_names user_name, setting_code
-    Card.search(
-      { right: { codename: setting_code },
-        left: {
-          left: { type_id: SetID }, right: user_name
-        },
-        return: :name }, "preference cards for user: #{user_name}"
-    )
-  end
-
-  def preference_cards user_name, setting_code
-    preference_names(user_name, setting_code).map { |name| Card.fetch name }
-  end
-
-  def rule_cache
-    Card.cache.read("RULES") || begin
-      @rule_hash = {}
-      @user_ids_hash = {}
-      @rule_keys_hash = {}
-
-      interpret_simple_rules
-      interpret_preferences
-
-      write_user_ids_cache @user_ids_hash
-      write_rule_keys_cache @rule_keys_hash
-      write_rule_cache @rule_hash
-    end
-  end
-
-  def preference_key key, user_id
-    "#{key}+#{user_id}"
-  end
-
-  # all users that have a user-specific rule for a given rule key
-  def user_ids_cache
-    Card.cache.read("USER_IDS") || begin
-      clear_rule_cache
-      rule_cache
-      @user_ids_hash
-    end
-  end
-
-  # all keys of user-specific rules for a given user
-  def rule_keys_cache
-    Card.cache.read("RULE_KEYS") || begin
-      clear_rule_cache
-      rule_cache
-      @rule_keys_hash
-    end
-  end
-
-  def clear_rule_cache
-    write_rule_cache nil
-    write_user_ids_cache nil
-    write_rule_keys_cache nil
-  end
-
-  def clear_preference_cache
-    # FIXME: too entwined!
-    clear_rule_cache
-  end
-
-  def write_rule_cache hash
-    Card.cache.write "RULES", hash
-  end
-
-  def write_user_ids_cache hash
-    Card.cache.write "USER_IDS", hash
-  end
-
-  def write_rule_keys_cache hash
-    Card.cache.write "RULE_KEYS", hash
-  end
-
-  def read_rule_cache
-    Card.cache.read("READRULES") || begin
-      hash = {}
-      Card.connection.select_all(
-        Card::Set::All::Rules::READ_RULE_SQL
-      ).each do |row|
-        party_id = row["party_id"].to_i
-        hash[party_id] ||= []
-        hash[party_id] << row["read_rule_id"].to_i
-      end
-      Card.cache.write "READRULES", hash
-    end
-  end
-
-  def clear_read_rule_cache
-    Card.cache.write "READRULES", nil
-  end
-end