card 1.99.6 → 1.100.0

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

@@ -20,11 +20,14 @@ end
 
 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
-  if (existing = rel.take)
-    errors.add :name, tr(:error_name_exists, name: existing.name)
-  end
+
+  return unless (existing_id = Card::Lexicon.id key) && existing_id != id
+  # The above is a fast check but cannot detect if card is in trash
+
+  # TODO: perform the following as a remote-only fetch (not yet supported)
+  return unless (existing_card = Card.where(id: existing_id, trash: false).take)
+
+  errors.add :name, tr(:error_name_exists, name: existing_card.name)
 end
 
 event :validate_legality_of_name do
@@ -52,26 +55,54 @@ end
 # STAGE: store
 
 event :expire_old_name, :store, changed: :name, on: :update do
-  ActManager.expirees << name_before_act
+  Director.expirees << name_before_act
+end
+
+event :update_lexicon_on_create, :finalize, changed: :name, on: :create do
+  Card::Lexicon.add self
 end
 
-event :set_left_and_right, :store, changed: :name, on: :save do
-  if name.junction?
-    %i[left right].each do |side|
-      assign_side_id side
-    end
+event :update_lexicon_on_rename, :finalize, changed: :name, on: :update do
+  Card::Lexicon.update self
+end
+
+def lex
+  simple? ? name : [left_id, right_id]
+end
+
+def old_lex
+  if (old_left_id = left_id_before_act)
+    [old_left_id, right_id_before_act]
   else
-    self.left_id = self.right_id = nil
+    name_before_act
   end
 end
 
-# STAGE: finalize
+event :prepare_left_and_right, :store, changed: :name, on: :save do
+  return if name.simple?
+  prepare_side :left
+  prepare_side :right
+end
 
-event :name_change_finalized, :finalize, changed: :name, on: :save do
-  # The events to update references has to happen after :cascade_name_changes,
-  # but :cascade_name_changes is defined after the reference events and
-  # and additionaly it is defined on :update but some of the reference
-  # events are on :save. Hence we need this additional hook to organize these events.
+def prepare_side side
+  side_id = send "#{side}_id"
+  sidename = name.send "#{side}_name"
+  prepare_obstructed_side(side, side_id, sidename) ||
+    prepare_new_side(side, side_id, sidename)
+end
+
+def prepare_new_side side, side_id, sidename
+  return unless side_id == -1 || !Card[side_id]&.real?
+
+  sidecard = Director.card(sidename) || add_subcard(sidename)
+  send "#{side}_id=", sidecard
+end
+
+def prepare_obstructed_side side, side_id, sidename
+  return unless side_id && side_id == id
+  clear_name sidename
+  send "#{side}_id=", add_subcard(sidename)
+  true
 end
 
 private
@@ -89,21 +120,15 @@ def changing_name_to_junction?
   name.junction? && simple?
 end
 
-def assign_side_id side
-  sidename = name.send "#{side}_name"
-  sidecard = Card[sidename] || ActManager.card(sidename)
-
-  # eg, renaming A to A+B
-  old_name_in_way = (sidecard&.id && sidecard&.id == id)
-  suspend_name(sidename) if old_name_in_way
-  send "#{side}_id=", side_id_or_card(old_name_in_way, sidecard, sidename)
+def old_name_in_way? sidecard
+  real? && sidecard&.simple? && id == sidecard&.id
 end
 
-def side_id_or_card old_name_in_way, sidecard, sidename
-  if !sidecard || old_name_in_way
-    add_subcard(sidename.s)
-  else
-    # if sidecard doesn't have an id, it's already part of this act
-    sidecard.id || sidecard
-  end
+def clear_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.where(id: id).update_all(name: nil, key: nil, left_id: nil, right_id: nil)
+  Card.expire name
+  Card::Lexicon.cache.reset # probably overkill, but this for an edge case...
+  # Card::Lexicon.delete id, key
 end

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

@@ -1,42 +1,37 @@
+def patterns?
+  defined? @patterns
+end
 
-def patterns
-  @patterns ||= set_patterns.map { |sub| sub.new self }.compact
+def all_patterns
+  @all_patterns ||= set_patterns.map { |sub| sub.new self }.compact
 end
 
-def patterns_with_new
-  new_card? ? patterns_without_new[1..-1] : patterns_without_new
+# new cards do not
+def patterns
+  @patterns ||= (new_card? ? all_patterns[1..-1] : all_patterns)
 end
-alias_method_chain :patterns, :new
 
 def reset_patterns
-  @patterns = nil
+  # Rails.logger.info "resetting patterns: #{name}"
+  @patterns = @all_patterns = nil
   @template = @virtual = nil
   @set_mods_loaded = @set_modules = @set_names = @rule_set_keys = nil
   @junction_only = nil # only applies to set cards
   true
 end
 
-def reset_patterns_if_rule _saving=false
-  return unless real? && is_rule? && (set = left)
-
-  set.reset_patterns
-  set.include_set_modules
-  set
-end
-
 def safe_set_keys
   patterns.map(&:safe_key).reverse * " "
 end
 
 def set_modules
-  @set_modules ||=
-    patterns_without_new[0..-2].reverse.map(&:module_list).flatten.compact
+  @set_modules ||= all_patterns[0..-2].reverse.map(&:module_list).flatten.compact
 end
 
 def set_format_modules klass
   @set_format_modules ||= {}
   @set_format_modules[klass] =
-    patterns_without_new[0..-2].reverse.map do |pattern|
+    all_patterns[0..-2].reverse.map do |pattern|
       pattern.format_module_list klass
     end.flatten.compact
 end

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
@@ -52,30 +47,21 @@ 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
@@ -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,39 +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
-  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
-    # 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
+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
 
-private
+def changed_from_simple_to_compound?
+  name.compound? && name_before_act.to_name.simple?
+end
 
-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?
+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