card 1.99.5 → 1.99.6

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

@@ -123,7 +123,7 @@ end
 
 def renew mark, new_opts
   return self if new_opts.blank?
-  opts = new_opts.clone.merge name: mark
+  opts = new_opts.clone.reverse_merge name: mark
   copy = dup
   handle_default_content opts
   copy.newish opts

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
 
@@ -123,8 +113,10 @@ module ClassMethods
       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
     # must include_set_modules before checking `card.known?`,
     # in case, eg, set modules override #virtual?

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

@@ -61,12 +61,12 @@ 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
+  @set_mods_loaded = true
   self
 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/rename.rb

@@ -23,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 = #{SetID}
-    AND settings.type_id = #{SettingID}
-    AND (settings.codename != 'follow' OR rules.db_content != '')
-    AND    rules.trash is false
-    AND     sets.trash is false
-    AND settings.trash is false;
-)
-
-# 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 = #{ReadID}
-    AND       sets.type_id  = #{SetID}
-    AND read_rules.trash is false
-    AND       sets.trash is false;
-)
-
-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     = #{SetID}
-    AND settings.type_id = #{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;
-)
 
 def is_rule?
   is_standard_rule? || is_preference?
@@ -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 = #{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

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

@@ -9,8 +9,9 @@ format :html do
     card.each_item_name_with_options(_render_raw) do |name, options|
       construct_tab tabs, name, options
     end
-    lazy_loading_tabs tabs[:paths], tabs[:active][:name],
-                      tabs[:active][:content], type: tab_type
+    tabs tabs[:paths], tabs[:active][:name], tab_type: tab_type, load: :lazy do
+      tabs[:active][:content]
+    end
   end
 
   def construct_tab tabs, name, explicit_options
@@ -45,6 +46,6 @@ format :html do
     card.item_cards.each do |item|
       tabs[item.name] = nest item, item_view_options(args)
     end
-    static_tabs tabs, tab_type
+    tabs tabs, nil, tab_type: tab_type
   end
 end

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

@@ -3,7 +3,7 @@
 # the reference stuff.  we need to organize a bit!
 
 event :update_rule_cache, :finalize, when: :is_rule? do
-  self.class.clear_rule_cache
+  Card::Rule.clear_rule_cache
 end
 
 event :expire_related, :finalize do

data/mod/core/set_pattern/08_type_plus_right.rb

@@ -28,6 +28,5 @@ def prototype_args anchor
 end
 
 def anchor_name card
-  type_name = card.left(new: {})&.type_name || Card.default_type_id.cardname
-  "#{type_name}+#{card.name.tag}"
+  "#{left_type(card)}+#{card.name.tag}"
 end

data/mod/core/spec/set/all/event_conditions_spec.rb

@@ -192,16 +192,16 @@ RSpec.describe Card::Set::All::EventConditions do
         end
       end
 
-      specify "skip_event condition" do
+      specify "skip condition" do
         expect_skipping({ content: "changed" }, [], "A executed", for_name: "A")
       end
 
-      specify "skip_event condition in subcard" do
+      specify "skip condition in subcard" do
         expect_skipping({ content: "changed", subcards: { "+B" => "changed +B" } },
                         [], "A+B executed", for_name: "A+B")
       end
 
-      specify "skip_event_in_action condition" do
+      specify "skip_in_action condition" do
         expect_skipping({ content: "changed", subcards: { "+B" => "changed +B" } },
                         ["A+B executed"],
                         ["A executed", "A+B executed", "A+B executed"],

data/mod/core/spec/set/all/fetch_helper_spec.rb

@@ -8,6 +8,12 @@ RSpec.describe Card::Set::All::FetchHelper do
     Card.send :retrieve_existing, "A".to_name, opts
   end
 
+  describe "#controller fetch" do
+    it "removes underscores from new card names" do
+      expect(Card.controller_fetch(mark: "no_un_der_score").name).to eq("no un der score")
+    end
+  end
+
   describe "retrieve_existing" do
     it "looks for non-cached card in database" do
       expect_db_retrieval_with(:key, "a", nil) { retrieve }

data/mod/core/spec/set/all/references_spec.rb

@@ -49,5 +49,14 @@ RSpec.describe Card::Set::All::References do
       Card["A"].update! name: "AAA", update_referers: true
       expect(Card["X"].content).to eq("[[AAA]] [[AAA+B]] [[T]]")
     end
+
+    # FIXME: following should pass!
+    xit "handles reference loops" do
+      Card["A"].update! content: "[[A+B]] refers to me"
+      Card["A+B"].update! content: "[[A]] refers to me, too"
+      Card["A"].update! name: "AAA", update_referers: true
+      expect(Card["AAA+B"].content).to eq("[[AAA]] refers to me, too")
+      expect(Card["AAA"].content).to eq("[[AAA+B]] refers to me")
+    end
   end
 end