card 1.99.2 → 1.100.0

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

@@ -21,16 +21,20 @@ end
 event :validate_name, :validate, on: :save, changed: :name do
   validate_legality_of_name
   return if errors.any?
+  Card.write_to_soft_cache self
   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
-  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
@@ -57,28 +61,55 @@ end
 
 # STAGE: store
 
-event :set_name, :store, changed: :name do
-  expire
+event :expire_old_name, :store, changed: :name, on: :update do
+  ActManager.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 = ActManager.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
@@ -96,23 +127,17 @@ 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
 end;end;end;end;
 # ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/name_events.rb ~~

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

@@ -5,45 +5,40 @@ class Card; module Set; class All
 module Pattern;
 extend Card::Set
 def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/pattern.rb"; end
+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
@@ -60,5 +55,9 @@ end
 def rule_set_keys
   @rule_set_keys ||= patterns.map(&:rule_set_key).compact
 end
+
+def include_module? set
+  singleton_class&.include? set
+end
 end;end;end;end;
 # ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/pattern.rb ~~

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

@@ -30,22 +30,17 @@ end
 # options.
 
 def ok? action
-  # binding.pry if action == :create
-  @action_ok = true
-  send "ok_to_#{action}"
-  @action_ok
-end
-
-def ok_with_fetch? action, opts={}
-  card = opts[:trait].nil? ? self : fetch(opts)
-  card && 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
@@ -53,36 +48,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
@@ -104,7 +90,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
@@ -113,73 +99,65 @@ end
 
 def deny_because why
   @permission_errors << why if @permission_errors
-  @action_ok = false
+  false
 end
 
 def permitted? action
-  return if Card.config.read_only
-  return true if action != :comment && Auth.always_ok?
+  return false if Card.config.read_only # :read does not call #permit
+  return true if Auth.always_ok?
 
-  permitted_ids = who_can action
-  if action == :comment && Auth.always_ok?
-    # admin can comment if anyone can
-    !permitted_ids.empty?
-  else
-    Auth.as_card.among? permitted_ids
-  end
+  Auth.as_card.among? who_can(action)
 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.
-    next if side == :left && @superleft
+    next if side == :left && superleft
     part_card = send side, new: {}
     # if no card, there must be other errors
     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
   permit :delete
 end
 
-def ok_to_comment
-  permit :comment, "comment on"
-  return unless @action_ok
-  deny_because "No comments allowed on templates" if is_template?
-  deny_because "No comments allowed on structured content" if structure
-end
-
 # don't know why we introduced this
 # but we have to preserve read rules to make
 # delete acts visible in recent changes -pk
@@ -200,20 +178,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
 
@@ -249,7 +228,7 @@ event :check_permissions, :validate do
 end
 
 def action_for_permission_check
-  commenting? ? :comment : @action
+  commenting? ? :update : @action
 end
 
 def track_permission_errors
@@ -259,23 +238,5 @@ def track_permission_errors
   @permission_errors = nil
   result
 end
-
-module Accounts
-  # This is a short-term hack that is used in account-related cards to allow a
-  # permissions pattern where permissions are restricted to the owner of the
-  # account (and, by default, Admin)
-  # That pattern should be permitted by our card representation
-  # (without creating separate rules for each account holder) but is not yet.
-
-  def permit action, verb=nil
-    case action
-    when :comment then @action_ok = false
-    when :create  then @superleft ? true : super(action, verb)
-    # restricts account creation to subcard handling on permitted card
-    # (unless explicitly permitted)
-    else own_account? ? true : super(action, verb)
-    end
-  end
-end
 end;end;end;end;
 # ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/permissions.rb ~~

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

@@ -17,9 +17,5 @@ end
 delegate :validation_phase, to: :director
 delegate :storage_phase, to: :director
 delegate :integration_phase, to: :director
-
-# def clean_up
-#   Card::ActManager.clear
-# end
 end;end;end;end;
 # ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/phases.rb ~~