card 1.99.2 → 1.100.0

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

@@ -23,22 +23,17 @@ end
 # options.
 
 def ok? action
-  @action_ok = true
-  send "ok_to_#{action}"
-  @action_ok
-end
-
-def ok_with_fetch? action, opts={}
-  trait = opts.delete :trait
-  card = trait.nil? ? self : fetch(trait, opts)
-  card&.ok_without_fetch? action
+  @ok ||= {}
+  aok = @ok[Auth.as_id] ||= {}
+  if (cached = aok[action])
+    cached
+  else
+    aok[action] = send "ok_to_#{action}"
+  end
 end
 
-# note: method is chained so that we can return the instance variable @action_ok
-alias_method_chain :ok?, :fetch
-
-def ok! action, opts={}
-  raise Card::Error::PermissionDenied, self unless ok? action, opts
+def ok! action
+  raise Card::Error::PermissionDenied, self unless ok? action
 end
 
 def who_can action
@@ -46,36 +41,27 @@ 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
   direct_rule_id = rule_card_id action
   require_permission_rule! direct_rule_id, action
-  Card.fetch direct_rule_id, skip_modules: true
+  Card.quick_fetch direct_rule_id
 end
 
 def permission_rule_id action
-  direct_rule = direct_rule_card action
-  applicable_permission_rule_id direct_rule, action
-end
-
-def permission_rule_id_and_class action
-  direct_rule = direct_rule_card action
-  [
-    applicable_permission_rule_id(direct_rule, action),
-    direct_rule.rule_class_name
-  ]
-end
-
-def applicable_permission_rule_id direct_rule, action
-  if junction? && direct_rule.db_content =~ /^\[?\[?_left\]?\]?$/
+  if junction? && rule(action).match?(/^\[?\[?_left\]?\]?$/)
     left_permission_rule_id action
   else
-    direct_rule.id
+    rule_card_id(action)
   end
 end
 
+def permission_rule_id_and_class action
+  [permission_rule_id(action), direct_rule_card(action).rule_class_name]
+end
+
 def left_permission_rule_id action
   lcard = left_or_new(skip_virtual: true, skip_modules: true)
   if action == :create && lcard.real? && lcard.action != :create
@@ -97,7 +83,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
@@ -106,7 +92,7 @@ end
 
 def deny_because why
   @permission_errors << why if @permission_errors
-  @action_ok = false
+  false
 end
 
 def permitted? action
@@ -118,16 +104,19 @@ end
 
 def permit action, verb=nil
   # not called by ok_to_read
-  deny_because "Currently in read-only mode" if Card.config.read_only
+  if Card.config.read_only
+    deny_because "Currently in read-only mode"
+    return false
+  end
 
-  return if permitted? action
+  return true if permitted? action
   verb ||= action.to_s
   deny_because you_cant("#{verb} #{name.present? ? name : 'this'}")
 end
 
 def ok_to_create
-  permit :create
-  return if !@action_ok || !junction?
+  return false unless permit :create
+  return true if simple?
 
   %i[left right].each do |side|
     # left is supercard; create permissions will get checked there.
@@ -137,23 +126,25 @@ def ok_to_create
     next unless part_card && part_card.new_card?
     unless part_card.ok? :create
       deny_because you_cant("create #{part_card.name}")
+      return false
     end
   end
+  true
 end
 
 def ok_to_read
-  return if Auth.always_ok?
-  @read_rule_id ||= permission_rule_id(:read)
-  return if Auth.as_card.read_rules.member? @read_rule_id
+  return true if Auth.always_ok?
+
+  self.read_rule_id ||= permission_rule_id :read
+  return true if Auth.as_card.read_rules_hash[read_rule_id]
+
   deny_because you_cant "read this"
 end
 
 def ok_to_update
-  permit :update
-  if @action_ok && type_id_changed? && !permitted?(:create)
-    deny_because you_cant("change to this type (need create permission)")
-  end
-  ok_to_read if @action_ok
+  return false unless permit(:update)
+  return true unless type_id_changed? && !permitted?(:create)
+  deny_because you_cant("change to this type (need create permission)")
 end
 
 def ok_to_delete
@@ -230,7 +221,7 @@ event :check_permissions, :validate do
 end
 
 def action_for_permission_check
-  commenting? ? :update : @action
+  commenting? ? :update : action
 end
 
 def track_permission_errors

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

@@ -41,12 +41,6 @@ def name_referers
   Card.joins(:references_out).where card_references: { referee_key: key }
 end
 
-# cards that refer to self or any descendant
-def family_referers
-  @family_referers ||= ([self] + descendants).map(&:referers).flatten.uniq
-  # TODO: make this more efficient using partial references!
-end
-
 # replace references in card content
 def replace_reference_syntax old_name, new_name
   obj_content = Card::Content.new content, self
@@ -86,7 +80,7 @@ end
 
 # interpretation phase helps to prevent duplicate references
 # results in hash like:
-# { referee1_key: [referee1_id, referee1_type1, referee1_type2],
+# { referee1_key: [referee1_id, referee1_type2],
 #   referee2_key...
 # }
 def interpret_reference ref_hash, referee_name, ref_type
@@ -95,7 +89,7 @@ def interpret_reference ref_hash, referee_name, ref_type
   referee_key = referee_name.key
   return if referee_key == key # don't create self reference
 
-  referee_id = Card.fetch_id(referee_name)
+  referee_id = Card::Lexicon.id referee_name
   ref_hash[referee_key] ||= [referee_id]
   ref_hash[referee_key] << ref_type
 
@@ -106,6 +100,7 @@ end
 # For example a link to virual card [[A+*self]] won't have a referee_id,
 # but when A's name is changed we have to find and update that link.
 def interpret_partial_references ref_hash, referee_name
+  return if referee_name.simple?
   [referee_name.left, referee_name.right].each do |sidename|
     interpret_reference ref_hash, sidename, PARTIAL_REF_CODE
   end
@@ -131,7 +126,7 @@ end
 # the reference name and reference type
 def each_reference_out
   content_object.find_chunks(Card::Content::Chunk::Reference).each do |chunk|
-    yield(chunk.referee_name, chunk.reference_code)
+    yield chunk.referee_name, chunk.reference_code
   end
 end
 
@@ -145,36 +140,17 @@ end
 
 protected
 
-# test for updating referer content & preload referer list
+# test for updating referer content
 event :prepare_referer_update, :validate, on: :update, changed: :name do
   self.update_referers = ![nil, false, "false"].member?(update_referers)
-  family_referers
-end
-
-# when name changes, update references to card
-event :refresh_references_in, :finalize, on: :save, after: :name_change_finalized do
-  Card::Reference.unmap_referees id if @action == :update && !update_referers
-  Card::Reference.map_referees key, id
-end
-
-# when content changes, update references to other cards
-event :refresh_references_out, :finalize, on: :save, changed: :content do
-  update_references_out
-end
-
-# clean up reference table when card is deleted
-event :clear_references, :finalize, on: :delete do
-  delete_references_out
-  Card::Reference.unmap_referees id
 end
 
 # on rename, update names in cards that refer to self by name (as directed)
-event :update_referer_content, :finalize,
-      on: :update, after: :name_change_finalized, when: :update_referers do
+event :update_referer_content, :finalize, on: :update, when: :update_referers do
   referers.each do |card|
     next if card.structure
     card.skip_event! :validate_renaming, :check_permissions
-    card.content = card.replace_reference_syntax name_before_last_save, name
+    card.content = card.replace_reference_syntax name_before_act, name
     attach_subcard card
   end
 end
@@ -184,10 +160,27 @@ end
 # eg.  A links to X+Y.  if X+Y is renamed and we're not updating the link in A,
 # then we need to be sure that A has a partial reference
 event :update_referer_references_out, :finalize,
-      on: :update, after: :name_change_finalized, when: :not_update_referers do
+      on: :update, when: :not_update_referers do
   referers.map(&:update_references_out)
 end
 
+# when name changes, update references to card
+event :refresh_references_in, :finalize, on: :save do
+  Card::Reference.unmap_referees id if action == :update && !update_referers
+  Card::Reference.map_referees key, id
+end
+
+# when content changes, update references to other cards
+event :refresh_references_out, :finalize, on: :save, changed: :content do
+  update_references_out
+end
+
+# clean up reference table when card is deleted
+event :clear_references, :finalize, on: :delete do
+  delete_references_out
+  Card::Reference.unmap_referees id
+end
+
 def not_update_referers
   !update_referers
 end

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

@@ -6,35 +6,28 @@ event :rename_in_trash, after: :expire_old_name, on: :update do
   existing_card.save!
 end
 
-def suspend_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.expire name
-  tmp_name = "tmp:" + UUID.new.generate
-  Card.where(id: id).update_all(name: tmp_name, key: tmp_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?
+  errors.add :content, tr(:cannot_change_content) if content_is_changing?
+  errors.add :type, tr(:cannot_change_type) if type_is_changing?
+  detect_illegal_compound_names
 end
 
-event :cascade_name_changes, :finalize, on: :update, changed: :name,
-                                        before: :name_change_finalized do
-  @descendants = nil # reset
+event :cascade_name_changes, :finalize, on: :update, changed: :name do
+  each_descendant do |d|
+    d.action = :update
+    update_referers ? d.update_referers : d.update_referer_references_out
+    d.refresh_references_in
+    d.refresh_references_out
+    d.expire
+  end
+end
 
-  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
+def changed_from_simple_to_compound?
+  name.compound? && name_before_act.to_name.simple?
+end
 
-    # 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
+def detect_illegal_compound_names
+  return unless changed_from_simple_to_compound? && child_ids(:right).present?
+  errors.add :name, "illegal name change; existing names end in +#{name_before_act}"
 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
@@ -106,7 +50,7 @@ end
 def preference_card_id_lookups setting_code, options={}
   user_id = options[:user_id] || options[:user]&.id || Auth.current_id
   return unless user_id
-  ["#{setting_code}+#{Card::AllID}", "#{setting_code}+#{user_id}"]
+  ["#{setting_code}+#{AllID}", "#{setting_code}+#{user_id}"]
 end
 
 def related_sets with_self=false
@@ -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? Card::AllID  # rule for all -> return all user ids
-      Card.where(type_id: Card::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: Card::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