card 1.16.8 → 1.16.9

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

@@ -0,0 +1,70 @@
+def field tag
+  Card[cardname.field(tag)]
+end
+
+def subcard card_name
+  subcards.card card_name
+end
+
+def subfield field_name
+  subcards.field field_name
+end
+
+phase_method :add_subcard, before: :approve do |name_or_card, args=nil|
+  subcards.add name_or_card, args
+end
+
+phase_method :add_subfield, before: :approve do |name_or_card, args=nil|
+  subcards.add_field name_or_card, args
+end
+
+def remove_subcard name_or_card
+  subcards.remove name_or_card
+end
+
+def remove_subfield name_or_card
+  subcards.remove_field name_or_card
+end
+
+def clear_subcards
+  subcards.clear
+end
+
+def unfilled?
+  (content.empty? || content.strip.empty?) && !subcards.present?
+end
+
+event :reject_empty_subcards, after: :approve, on: :save do
+  subcards.each_with_key do |subcard, key|
+    if subcard.new? && subcard.unfilled?
+      remove_subcard key
+    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 :approve_subcards, after: :process_subcards 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
+    end
+  end
+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_local_cache self
+end

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

@@ -1,4 +1,3 @@
-#fixme -this is called by both initialize and update_attributes.  really should be optimized for new!
 def assign_attributes args={}
   if args
     args = args.stringify_keys
@@ -8,123 +7,148 @@ def assign_attributes args={}
       @set_specific[key] = args.delete(key) if args[key]
     end
 
-    if newtype = args.delete('type')
-      args['type_id'] = Card.fetch_id newtype
-    end
-    @subcards = extract_subcard_args! args
+    new_type_id = extract_type_id! args unless args.delete('skip_type_lookup')
+    subcard_args = extract_subcard_args! args
+    args['type_id'] = new_type_id if new_type_id
     reset_patterns
   end
   params = ActionController::Parameters.new(args)
   params.permit!
   super params
+  return unless args && subcard_args.present?
+  # name= must come before process subcards
+  subcards.add subcard_args
 end
 
 def assign_set_specific_attributes
-  if @set_specific && @set_specific.present?
-    @set_specific.each_pair do |name, value|
-      self.send "#{name}=", value
-    end
+  return unless @set_specific && @set_specific.present?
+  @set_specific.each_pair do |name, value|
+    send "#{name}=", value
   end
 end
 
-def extract_subcard_args! args={}
-  extracted_subcards = args.delete('subcards') || {}
+protected
+
+def extract_subcard_args! args
+  subcards = args.delete('subcards') || {}
   args.keys.each do |key|
     if key =~ /^\+/
-      val = args.delete key
-      val = { 'content' => val } if String === val
-      extracted_subcards[key] = val
+      subcards[key] = args.delete(key)
     end
   end
-  extracted_subcards
+  subcards
 end
 
+def extract_type_id! args={}
+  type_id =
+    case
+    when args['type_id']
+      id = args.delete('type_id').to_i
+      # type_id can come in as 0,'' or nil
+      id == 0 ? nil : id
+    when args['type_code']
+      Card.fetch_id args.delete('type_code').to_sym
+    when args['type']
+      Card.fetch_id args.delete('type')
+    else
+      return nil
+    end
 
-protected
+  if !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
-  self.db_content = content || '' #necessary?
-  self.db_content = Card::Content.clean! self.db_content if clean_html?
+  self.db_content = content || '' # necessary?
+  self.db_content = Card::Content.clean!(db_content) if clean_html?
   @selected_action_id = @selected_content = nil
   clear_drafts
   reset_patterns_if_rule saving=true
 end
 
-
-#fixme - the following don't really belong here, but they have to come after the reference stuff.  we need to organize a bit!
+# 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
   if is_rule?
-#      warn "updating ruled cards for #{name}"
+    # warn "updating ruled cards for #{name}"
     self.class.clear_rule_cache
     set = rule_set
     set.reset_set_patterns
 
-    if right_id==Card::ReadID and (name_changed? or trash_changed?)
+    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?
+      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 !(self.trash)
-        if class_id = (set and set_class=set.tag and set_class.id)
+      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
+          # 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
-             # elsif rule_class_index = rule_class_ids.index( 0 )
- #               in_set[trunk.key] = true
- #               #warn "self rule update: #{trunk.inspect}, #{rule_class_index}, #{cur_index}"
- #   trunk.update_read_rule if cur_index > rule_class_index
-             else warn "No current rule index #{class_id}, #{rule_class_ids.inspect}"
-             end
+              end
+            # elsif rule_class_index = rule_class_ids.index( 0 )
+            #   in_set[trunk.key] = true
+            #   #warn "self rule update: #{trunk.inspect}, #{rule_class_index},
+            #   #{cur_index}"
+            #   trunk.update_read_rule if cur_index > rule_class_index
+            else warn "No current rule index #{class_id}, " \
+                      "#{rule_class_ids.inspect}"
+            end
           end
 
         end
       end
 
-      #then find all cards with me as read_rule_id that were not just updated and regenerate their read_rules
+      # then find all cards with me as read_rule_id that were not just updated
+      # and regenerate their read_rules
       if !new_record?
-        Card.where( read_rule_id: self.id, trash: false ).reject do |w|
-          in_set[ w.key ]
-        end.each &:update_read_rule
+        Card.where(read_rule_id: self.id, trash: false).reject do |w|
+          in_set[w.key]
+        end.each(&:update_read_rule)
       end
     end
-
   end
 end
 
 event :process_read_rule_update_queue, after: :store do
-  Array.wrap(@read_rule_update_queue).each { |card| card.update_read_rule }
+  Array.wrap(@read_rule_update_queue).each(&:update_read_rule)
   @read_rule_update_queue = []
 end
 
 #  set_callback :store, :after, :process_read_rule_update_queue, prepend: true
 
 event :expire_related, after: :store do
-  self.expire
+  subcards.keys.each do |key|
+    Card.cache.delete_local key
+  end
+  expire true
 
   if self.is_structure?
-    self.structuree_names.each do |name|
-      Card.expire name
+    structuree_names.each do |name|
+      Card.expire name, true
     end
   end
-  # FIXME really shouldn't be instantiating all the following bastards.  Just need the key.
+
+  # FIXME: really shouldn't be instantiating all the following bastards.
+  # Just need the key.
   # fix in id_cache branch
-  self.dependents.each       { |c| c.expire }
-  # self.referencers.each      { |c| c.expire }
-  self.name_referencers.each { |c| c.expire }
+  dependents.each       { |c| c.expire(true) }
+  # self.referencers.each      { |c| c.expire(true) }
+  name_referencers.each { |c| c.expire(true) }
   # FIXME: this will need review when we do the new defaults/templating system
 end
-

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

@@ -6,13 +6,15 @@ def delete!
   update_attributes! trash: true unless new_card?
 end
 
-
 event :pull_from_trash, before: :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 initialization process screws with something
-    # b. (Wagn way) we could get card directly from fetch if we add :include_trashed (eg).
-    #    likely low ROI, but would be nice to have interface to retrieve cards from trash...
+  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
+    # initialization process screws with something
+    # b. (Wagn way) we could get card directly from fetch if we add
+    # :include_trashed (eg).
+    #    likely low ROI, but would be nice to have interface to retrieve cards
+    #    from trash...m
     self.id = trashed_card.id
     @from_trash = true
     @new_record = false
@@ -27,20 +29,21 @@ event :validate_delete, before: :approve, on: :delete do
   end
 
   undeletable_all_rules_tags = %w{ default style layout create read update delete }
-  if junction? and l=left and l.codename == 'all' and undeletable_all_rules_tags.member? right.codename
+  if junction? && (l = left) && l.codename == 'all' &&
+     undeletable_all_rules_tags.member?(right.codename)
     errors.add :delete, "#{name} is an indestructible rule"
   end
 
-  if account && Card::Act.find_by_actor_id( self.id )
-    errors.add :delete, "Edits have been made with #{name}'s user account.\nDeleting this card would mess up our history."
+  if account && self.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
   children.each do |child|
-    child.supercard = self
-    subcards[child.name]=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}"
@@ -48,4 +51,3 @@ event :validate_delete_children, after: :approve, on: :delete do
     end
   end
 end
-

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

@@ -26,34 +26,13 @@ def type= type_name
   self.type_id = Card.fetch_id type_name
 end
 
-def get_type_id args={}
-  return if args[:type_id] # type_id was set explicitly.  no need to set again.
-
-  type_id = case
-    when args[:type_code]
-      if code=args[:type_code]
-        Card::Codename[code] || ( c=Card[code] and c.id)
-      end
-    when args[:type]
-      Card.fetch_id args[:type]
-    else :noop
-    end
-
-  case type_id
-  when :noop
-  when false, nil
-    errors.add :type, "#{args[:type] || args[:type_code]} is not a known type."
-  else
-    return type_id
-  end
-
-  if name && t=template
-    reset_patterns #still necessary even with new template handling?
+def get_type_id_from_structure
+  if name && (t = template)
+    reset_patterns # still necessary even with new template handling?
     t.type_id
   end
 end
 
-
 event :validate_type_change, before: :approve, on: :update, changed: :type_id do
   if c = dup and c.action == :create and !c.valid?
     errors.add :type, "of #{ name } can't be changed; errors creating new #{ type_id }: #{ c.errors.full_messages * ', ' }"

data/mod/01_core/spec/set/all/initialize_spec.rb

@@ -1,14 +1,14 @@
 # -*- encoding : utf-8 -*-
 
 describe Card::Set::All::Initialize do
-  describe "new" do
-    it "handles explicit nil as parameters" do
+  describe 'new' do
+    it 'handles explicit nil as parameters' do
       c = Card.new nil
       expect(c).to be_instance_of(Card)
       expect(c.name).to eq('')
     end
 
-    it "handles nil name" do
+    it 'handles nil name' do
       c = Card.new name: nil
       expect(c).to be_instance_of(Card)
       expect(c.name).to eq('')
@@ -19,38 +19,68 @@ describe Card::Set::All::Initialize do
       expect(c).to be_instance_of(Card)
       expect(c.name).to eq('Ceee')
     end
-  end
 
+    it 'handles no type' do
+      c = Card.new
+      expect(c.type_id).to eq(Card::BasicID)
+    end
+
+    it 'handles nil type_id' do
+      c = Card.new name: 'Ceee', type_id: nil
+      expect(c.type_id).to eq(Card::BasicID)
+    end
+
+    it 'handles empty string type_id' do
+      c = Card.new type_id: ''
+      expect(c.type_id).to eq(Card::BasicID)
+    end
+
+    it 'handles cardtype name and casespace variant as type' do
+      expect(Card.new(type: 'Phrase').type_id).to eq(Card::PhraseID)
+      expect(Card.new(type: 'PHRASE').type_id).to eq(Card::PhraseID)
+      expect(Card.new(type: 'phrase').type_id).to eq(Card::PhraseID)
+      expect(Card.new(type: 'phrase??').type_id).to eq(Card::PhraseID)
+    end
+
+    it 'handles type_code' do
+      expect(Card.new(type_code: 'phrase').type_id).to eq(Card::PhraseID)
+      expect(Card.new(type_code: :phrase).type_id).to eq(Card::PhraseID)
+    end
+
+    it 'handles type_id' do
+      expect(Card.new(type_id: Card::PhraseID).type_code).to eq(:phrase)
+    end
+  end
 
-  describe "module inclusion" do
+  describe 'module inclusion' do
     context '(search)' do
       before do
         @c = Card.new type: 'Search', name: 'Module Inclusion Test Card'
       end
 
-      it "happens after new" do
-        expect(@c.respond_to?( :get_query )).to be_truthy
+      it 'happens after new' do
+        expect(@c.respond_to?(:get_query)).to be_truthy
       end
 
-      it "happens after save" do
-        expect(@c.respond_to?( :get_query )).to be_truthy
+      it 'happens after save' do
+        expect(@c.respond_to?(:get_query)).to be_truthy
         @c.save!
-        expect(@c.respond_to?( :get_query )).to be_truthy
+        expect(@c.respond_to?(:get_query)).to be_truthy
       end
 
-      it "happens after fetch" do
+      it 'happens after fetch' do
         @c.save!
         c = Card.fetch(@c.name)
-        expect(c.respond_to?( :get_query )).to be_truthy
+        expect(c.respond_to?(:get_query)).to be_truthy
       end
     end
 
     context '(pointer)' do
-      it "happens with explicit pointer setting" do
+      it 'happens with explicit pointer setting' do
         expect(Card.new(type: 'Pointer').respond_to?(:add_item)).to be_truthy
       end
 
-      it "happens with implicit pointer setting (from template)" do
+      it 'happens with implicit pointer setting (from template)' do
         expect(Card.new(name: 'Home+*cc').respond_to?(:add_item)).to be_truthy
       end
     end