card 1.17.4 → 1.18.0

data/mod/01_core/set/all/references.rb

@@ -75,7 +75,7 @@ end
 
 # delete references from this card
 def delete_references_out
-  fail 'id required to delete references' if id.nil?
+  raise 'id required to delete references' if id.nil?
   Card::Reference.delete_all referer_id: id
 end
 
@@ -124,32 +124,32 @@ end
 protected
 
 # test for updating referer content & preload referer list
-event :prepare_referer_update, before: :approve, on: :update, changed: :name do
+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, after: :store, on: :save, changed: :name do
+event :refresh_references_in, :finalize, on: :save, changed: :name 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, after: :store, on: :save, changed: :content do
+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, after: :store, on: :delete do
+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,
-      after: :store, on: :update, changed: :name,
-      when: proc { |c| c.update_referers } do
+event :update_referer_content, :finalize,
+      on: :update, changed: :name,
+      when: proc { |card| card.update_referers } do
   # FIXME: break into correct stages
   Auth.as_bot do
     family_referers.each do |card|
@@ -165,8 +165,8 @@ end
 # that partial references are correctly tracked
 # 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,
-      after: :store, on: :update, changed: :name,
+event :update_referer_references_out, :finalize,
+      on: :update, changed: :name,
       when: proc { |c| !c.update_referers } do
   family_referers.map(&:update_references_out)
 end

data/mod/01_core/set/all/rules.rb

@@ -120,9 +120,7 @@ def related_sets with_self=false
   if known? && type_id == Card::CardtypeID # FIXME: belongs in type/cardtype
     sets << ["#{name}+*type", Card::TypeSet.label(name)]
   end
-  if with_self
-    sets << ["#{name}+*self", Card::SelfSet.label(name)]
-  end
+  sets << ["#{name}+*self", Card::SelfSet.label(name)] if with_self
   if known? && cardname.simple?
     sets << ["#{name}+*right", Card::RightSet.label(name)]
   end
@@ -240,7 +238,8 @@ module ClassMethods
 
   # all users that have a user-specific rule for a given rule key
   def user_ids_cache
-    Card.cache.read('USER_IDS') || begin
+    Card.cache.read('USER_IDS') ||
+      begin
       clear_rule_cache
       rule_cache
       @user_ids_hash

data/mod/01_core/set/all/stages.rb

@@ -0,0 +1,24 @@
+attr_writer :director
+delegate :stage, to: :director
+
+def director
+  @director ||= Card::DirectorRegister.fetch self
+end
+
+def identify_action
+  @action =
+    case
+    when trash     then :delete
+    when new_card? then :create
+    else :update
+    end
+end
+
+def current_act= act
+  raise Card::Error, 'not allowed to override current act' if Card.current_act
+  Card.current_act = act
+end
+
+def current_act
+  @current_act ||= Card.current_act
+end

data/mod/01_core/set/all/states.rb

@@ -1,8 +1,8 @@
 def new_card?
-  new_record? ||   # not yet in db (from ActiveRecord)
-  !!@from_trash    # in process of restoration from trash, not yet "re-created"
+  new_record? || # not yet in db (from ActiveRecord)
+    !!@from_trash    # in process of restoration from trash, not yet "re-created"
 end
-alias_method :new?, :new_card?
+alias new? new_card?
 
 def known?
   real? || virtual?
@@ -18,5 +18,5 @@ end
 
 def pristine?
   # has not been edited directly by human users.  bleep blorp.
-  new_card? or !actions.joins(:act).where('card_acts.actor_id != ?', Card::WagnBotID).exists?
+  new_card? || !actions.joins(:act).where('card_acts.actor_id != ?', Card::WagnBotID).exists?
 end

data/mod/01_core/set/all/subcards.rb

@@ -10,11 +10,14 @@ def subfield field_name
   subcards.field field_name
 end
 
-phase_method :add_subcard, before: :approve do |name_or_card, args=nil|
+# phase_method :add_subcard, before: :store do |name_or_card, args=nil|
+# TODO: handle differently in different stages
+def add_subcard name_or_card, args=nil
   subcards.add name_or_card, args
 end
 
-phase_method :add_subfield, before: :approve do |name_or_card, args=nil|
+# phase_method :add_subfield, before: :approve do |name_or_card, args=nil|
+def add_subfield name_or_card, args=nil
   subcards.add_field name_or_card, args
 end
 
@@ -30,43 +33,30 @@ def clear_subcards
   subcards.clear
 end
 
+def deep_clear_subcards
+  subcards.deep_clear
+end
+
 def unfilled?
   (content.empty? || content.strip.empty?) &&
     (comment.blank? || comment.strip.blank?) &&
     !subcards.present?
 end
 
-event :approve_subcards, after: :approve, on: :save do
+event :handle_subcard_errors do
   subcards.each do |subcard|
-    if !subcard.valid_subcard?
-      subcard.errors.each do |field, err|
-        err = "#{field} #{err}" unless [:content, :abort].member? field
-        errors.add subcard.relative_name.s, err
-      end
+    subcard.errors.each do |field, err|
+      err = "#{field} #{err}" unless [:content, :abort].member? field
+      errors.add subcard.relative_name.s, err
     end
   end
 end
 
-event :reject_empty_subcards, before: :approve_subcards do
+event :reject_empty_subcards, :prepare_to_validate do
   subcards.each_with_key do |subcard, key|
     if subcard.new? && subcard.unfilled?
-      remove_subcard key
+      remove_subcard(key)
+      director.subdirectors.delete(subcard)
     end
   end
 end
-
-# deprecated; left for compatibility reasons because other events refer to this
-# especially wikirate
-event :process_subcards, after: :reject_empty_subcards, on: :save do
-end
-
-event :store_subcards, after: :store do
-  subcards.each do |subcard|
-    subcard.save! validate: false if subcard != self # unless @draft
-  end
-
-  # ensures that a supercard can access subcards of self
-  # eg. <user> creates <user+*account> creates <user+*account+*status>
-  # <user> changes <user+*account+*status> in event activate_account
-  Card.write_to_soft_cache self
-end

data/mod/01_core/set/all/templating.rb

@@ -59,9 +59,7 @@ end
 
 def virtual?
   return false unless new_card?
-  if @virtual.nil?
-    cardname.simple? ? (@virtual = false) : template
-  end
+  cardname.simple? ? (@virtual = false) : template if @virtual.nil?
   @virtual
 end
 

data/mod/01_core/set/all/tracked_attributes.rb

@@ -32,9 +32,7 @@ protected
 def extract_subcard_args! args
   subcards = args.delete('subcards') || {}
   args.keys.each do |key|
-    if key =~ /^\+/
-      subcards[key] = args.delete(key)
-    end
+    subcards[key] = args.delete(key) if key =~ /^\+/
   end
   subcards
 end
@@ -54,13 +52,13 @@ def extract_type_id! args={}
       return nil
     end
 
-  if !type_id
+  unless type_id
     errors.add :type, "#{args[:type] || args[:type_code]} is not a known type."
   end
   type_id
 end
 
-event :set_content, before: :store, on: :save do
+event :set_content, :store, on: :save do
   self.db_content = content || '' # necessary?
   self.db_content = Card::Content.clean!(db_content) if clean_html?
   @selected_action_id = @selected_content = nil
@@ -71,7 +69,7 @@ end
 # FIXME: the following don't really belong here, but they have to come after
 # the reference stuff.  we need to organize a bit!
 
-event :update_ruled_cards, after: :store do
+event :update_ruled_cards, :finalize do
   if is_rule?
     # warn "updating ruled cards for #{name}"
     self.class.clear_rule_cache
@@ -79,67 +77,68 @@ event :update_ruled_cards, after: :store do
     set.reset_set_patterns
 
     if right_id == Card::ReadID && (name_changed? || trash_changed?)
-      self.class.clear_read_rule_cache
-      Card.cache.reset # maybe be more surgical, just Auth.user related
-      expire # probably shouldn't be necessary,
-      # but was sometimes getting cached version when card should be in the
-      # trash.  could be related to other bugs?
-      in_set = {}
-      if !trash && set && (set_class = set.tag)
-        if (class_id =  set_class.id)
-          rule_class_ids = set_patterns.map &:pattern_id
-          # warn "rule_class_id #{class_id}, #{rule_class_ids.inspect}"
-
-          # first update all cards in set that aren't governed by narrower rule
-          Auth.as_bot do
-            cur_index = rule_class_ids.index Card[read_rule_class].id
-            if (rule_class_index = rule_class_ids.index(class_id))
-              set.item_cards(limit: 0).each do |item_card|
-                in_set[item_card.key] = true
-                next if cur_index < rule_class_index
-                if cur_index >= rule_class_index
-                  item_card.update_read_rule
-                end
-              end
-            else warn "No current rule index #{class_id}, " \
-                      "#{rule_class_ids.inspect}"
-            end
-          end
-
-        end
-      end
+      update_read_ruled_cards set
+    end
+  end
+end
 
-      # then find all cards with me as read_rule_id that were not just updated
-      # and regenerate their read_rules
-      if !new_card?
-        Card.search(read_rule_id: self.id) do |card|
-          card.update_read_rule unless in_set[card.key]
-        end
+def update_read_rules_of_set_members_not_governed_by_narrower_rules set
+  return {} if trash || !set || !(set_class = set.tag) ||
+               !(class_id = set_class.id)
+  in_set = {}
+  rule_class_ids = set_patterns.map(&:pattern_id)
+  Auth.as_bot do
+    cur_index = rule_class_ids.index Card[read_rule_class].id
+    if (rule_class_index = rule_class_ids.index(class_id))
+      set.item_cards(limit: 0).each do |item_card|
+        in_set[item_card.key] = true
+        next if cur_index < rule_class_index
+        item_card.update_read_rule if cur_index >= rule_class_index
       end
+    else
+      warn "No current rule index #{class_id}, #{rule_class_ids.inspect}"
     end
   end
+  in_set
 end
 
-event :process_read_rule_update_queue, after: :store do
+def update_read_ruled_cards set
+  self.class.clear_read_rule_cache
+  Card.cache.reset # maybe be more surgical, just Auth.user related
+  expire # probably shouldn't be necessary,
+  # but was sometimes getting cached version when card should be in the
+  # trash.  could be related to other bugs?
+
+  updated = update_read_rules_of_set_members_not_governed_by_narrower_rules set
+
+  # then find all cards with me as read_rule_id that were not just updated
+  # and regenerate their read_rules
+  return if new_card?
+  Card.search(read_rule_id: id) do |card|
+    card.update_read_rule unless updated[card.key]
+  end
+end
+
+event :process_read_rule_update_queue, :finalize do
   Array.wrap(@read_rule_update_queue).each(&:update_read_rule)
   @read_rule_update_queue = []
 end
 
-event :expire_related, after: :store do
+event :expire_related, :finalize do
   subcards.keys.each do |key|
     Card.cache.soft.delete key
   end
-  expire true
-
+  expire # FIXME: where do we put this. Here it deletes @stage
+  reset_patterns
   if is_structure?
     structuree_names.each do |name|
-      Card.expire name, true
+      Card.expire name
     end
   end
 end
 
 event :expire_related_names, before: :expire_related, changed: :name do
   # FIXME: look for opportunities to avoid instantiating the following
-  descendants.each { |c| c.expire(true) }
-  name_referers.each { |c| c.expire(true) }
+  descendants.each(&:expire)
+  name_referers.each(&:expire)
 end

data/mod/01_core/set/all/trash.rb

@@ -6,7 +6,7 @@ def delete!
   update_attributes! trash: true unless new_card?
 end
 
-event :pull_from_trash, before: :store, on: :create do
+event :pull_from_trash, :prepare_to_store, on: :create do
   if (trashed_card = Card.find_by_key_and_trash(key, true))
     # a. (Rails way) tried Card.where(key: 'wagn_bot').select(:id), but it
     # wouldn't work.  This #select generally breaks on cards. I think our
@@ -16,6 +16,7 @@ event :pull_from_trash, before: :store, on: :create do
     #    likely low ROI, but would be nice to have interface to retrieve cards
     #    from trash...m
     self.id = trashed_card.id
+    # update instead of create
     @from_trash = true
     @new_record = false
   end
@@ -23,13 +24,13 @@ event :pull_from_trash, before: :store, on: :create do
   true
 end
 
-event :validate_delete, before: :approve, on: :delete do
-  if !codename.blank?
+event :validate_delete, :validate, on: :delete do
+  unless codename.blank?
     errors.add :delete, "#{name} is is a system card. (#{codename})"
   end
 
   undeletable_all_rules_tags =
-    %w{ default style layout create read update delete }
+    %w( default style layout create read update delete )
   # FIXME: HACK! should be configured in the rule
 
   if junction? && (l = left) && l.codename == 'all' &&
@@ -37,20 +38,19 @@ event :validate_delete, before: :approve, on: :delete do
     errors.add :delete, "#{name} is an indestructible rule"
   end
 
-  if account && self.has_edits?
+  if account && has_edits?
     errors.add :delete, "Edits have been made with #{name}'s user account.\n" \
                         'Deleting this card would mess up our history.'
   end
 end
 
-event :validate_delete_children, after: :approve, on: :delete do
+event :validate_delete_children, :validate, on: :delete do
   children.each do |child|
     child.trash = true
     add_subcard child
-    unless child.valid?
-      child.errors.each do |field, message|
-        errors.add field, "can't delete #{child.name}: #{message}"
-      end
+    next if child.valid?
+    child.errors.each do |field, message|
+      errors.add field, "can't delete #{child.name}: #{message}"
     end
   end
 end

data/mod/01_core/set/all/type.rb

@@ -36,17 +36,15 @@ def get_type_id_from_structure
   t.type_id
 end
 
-event :validate_type_change, before: :approve, on: :update, changed: :type_id do
+event :validate_type_change, :validate, on: :update, changed: :type_id do
   if (c = dup) && c.action == :create && !c.valid?
-    errors.add :type, "of #{ name } can't be changed; errors creating new " \
-                      "#{ type_id }: #{ c.errors.full_messages * ', ' }"
+    errors.add :type, "of #{name} can't be changed; errors creating new " \
+                      "#{type_id}: #{c.errors.full_messages * ', '}"
   end
 end
 
-event :validate_type, before: :approve, changed: :type_id do
-  if !type_name
-    errors.add :type, 'No such type'
-  end
+event :validate_type, :validate, changed: :type_id do
+  errors.add :type, 'No such type' unless type_name
 
   if (rt = structure) && rt.assigns_type? && type_id != rt.type_id
     errors.add :type, "can't be changed because #{name} is hard templated " \
@@ -54,7 +52,10 @@ event :validate_type, before: :approve, changed: :type_id do
   end
 end
 
-event :reset_type_specific_fields, after: :store do
+event :reset_type_specific_fields, :finalize do
+  # Example: if you save a card of type Phrase
+  # then reset set patterns for update all
+  # "Phrase+Something+*type plus right" cards
   wql = { left: { left_id: type_id },
           right: { codename: 'type_plus_right' }
         }