card 1.17.4 → 1.18.0

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

@@ -5,78 +5,80 @@ describe Card::Set::All::Rules do
     Card::Auth.current_id = Card::WagnBotID
   end
 
-  describe "setting data setup" do
-    it "should make Set of +*type" do
-      Card.create! name: "SpeciForm", type: 'Cardtype'
-      expect(Card.create!( name: "SpeciForm+*type" ).type_code).to eq(:set)
+  describe 'setting data setup' do
+    it 'should make Set of +*type' do
+      Card.create! name: 'SpeciForm', type: 'Cardtype'
+      expect(Card.create!(name: 'SpeciForm+*type').type_code).to eq(:set)
     end
   end
 
-  describe "#rule" do
-    it "retrieves Set based value" do
-      Card.create name: "Book+*type+*add help", content: "authorize"
-      expect(Card.new( type: "Book" ).rule(:add_help, fallback: :help)).to eq("authorize")
+  describe '#rule' do
+    it 'retrieves Set based value' do
+      Card.create name: 'Book+*type+*add help', content: 'authorize'
+      add_help_rule = Card.new(type: 'Book').rule(:add_help, fallback: :help)
+      expect(add_help_rule).to eq('authorize')
     end
 
-    it "retrieves default values" do
-      #Card.create name: "all Basic cards", type: "Set", content: "{\"type\": \"Basic\"}"  #defaults should work when other Sets are present
-      assert c=Card.create(name: "*all+*add help", content: "lobotomize")
-#      Card.default_rule(:add_help, fallback: :help).should == "lobotomize"
-      expect(Card.new( type: "Basic" ).rule(:add_help, fallback: :help)).to eq("lobotomize")
+    it 'retrieves default values' do
+      # Card.create name: 'all Basic cards', type: 'Set',
+      #            content: "{\"type\": \"Basic\'}'
+      # defaults should work when other Sets are present
+      assert Card.create(name: '*all+*add help', content: 'lobotomize')
+      # Card.default_rule(:add_help, fallback: :help).should == 'lobotomize'
+      add_help_rule = Card.new(type: 'Basic').rule(:add_help, fallback: :help)
+      expect(add_help_rule).to eq('lobotomize')
     end
 
-    it "retrieves single values" do
-      Card.create! name: "banana+*self+*help", content: "pebbles"
-      expect(Card["banana"].rule(:help)).to eq("pebbles")
+    it 'retrieves single values' do
+      Card.create! name: 'banana+*self+*help', content: 'pebbles'
+      expect(Card['banana'].rule(:help)).to eq('pebbles')
     end
 
     context 'with fallback' do
       before do
-        Card.create name: "*all+*help", content: "edit any kind of card"
+        Card.create name: '*all+*help', content: 'edit any kind of card'
       end
-
-      it "retrieves default setting" do
-        expect(Card.new( type: "Book" ).rule(:add_help, fallback: :help)).to eq("edit any kind of card")
+      subject { Card.new(type: 'Book').rule(:add_help, fallback: :help) }
+      it 'retrieves default setting' do
+        expect(subject).to eq('edit any kind of card')
       end
 
-      it "retrieves primary setting" do
-        Card.create name: "*all+*add help", content: "add any kind of card"
-        expect(Card.new( type: "Book" ).rule(:add_help, fallback: :help)).to eq("add any kind of card")
+      it 'retrieves primary setting' do
+        Card.create name: '*all+*add help', content: 'add any kind of card'
+        expect(subject).to eq('add any kind of card')
       end
 
-      it "retrieves more specific default setting" do
-        Card.create name: "*all+*add help", content: "add any kind of card"
-        Card.create name: "*Book+*type+*help", content: "edit a Book"
-        expect(Card.new( type: "Book" ).rule(:add_help, fallback: :help)).to eq("add any kind of card")
+      it 'retrieves more specific default setting' do
+        Card.create name: '*all+*add help', content: 'add any kind of card'
+        Card.create name: '*Book+*type+*help', content: 'edit a Book'
+        expect(subject).to eq('add any kind of card')
       end
     end
   end
 
-
-  describe "#setting_codenames_by_group" do
+  describe '#setting_codenames_by_group' do
     before do
-      @pointer_settings =  [ :options, :options_label, :input ]
+      @pointer_settings = [:options, :options_label, :input]
     end
     it "doesn't fail on nonexistent trunks" do
-      expect(Card.new(name: 'foob+*right').setting_codenames_by_group.class).to eq(Hash)
+      codenames = Card.new(name: 'foob+*right').setting_codenames_by_group
+      expect(codenames.class).to eq(Hash)
     end
 
-    it "returns universal setting names for non-pointer set" do
-      skip "Different api, we should just put the tests in a new spec for that"
+    it 'returns universal setting names for non-pointer set' do
+      skip 'Different api, we should just put the tests in a new spec for that'
       snbg = Card.fetch('*star').setting_codenames_by_group
-      #warn "snbg #{snbg.class} #{snbg.inspect}"
+      # warn "snbg #{snbg.class} #{snbg.inspect}"
       expect(snbg.keys.length).to eq(4)
       expect(snbg.keys.first).to be_a Symbol
-      expect(snbg.keys.member?( :pointer )).not_to be_truthy
+      expect(snbg.keys.member?(:pointer)).not_to be_truthy
     end
 
-
-    it "returns pointer-specific setting names for pointer card" do
+    it 'returns pointer-specific setting names for pointer card' do
       c = Card.fetch 'Fruit+*type+*create+*self', new: {}
       snbg = c.setting_codenames_by_group
       expect(snbg[:pointer]).to eq(@pointer_settings)
     end
-
   end
 
   describe 'user specific rules' do
@@ -84,45 +86,50 @@ describe Card::Set::All::Rules do
       Card::Auth.current_id = Card.fetch('Joe User').id
     end
 
-    it "user rule is recognized as rule" do
+    it 'user rule is recognized as rule' do
       Card::Auth.as_bot do
-        card = Card.create(name: "Book+*type+Joe User+*follow", content: "[[*always]]")
+        card = Card.create name: 'Book+*type+Joe User+*follow',
+                           content: '[[*always]]'
         expect(card.is_rule?).to be_truthy
       end
     end
 
-    it "retrieves Set based value" do
+    it 'retrieves Set based value' do
       Card::Auth.as_bot do
-        Card.create name: "Book+*type+Joe User+*follow", content: "[[*always]]"
+        Card.create name: 'Book+*type+Joe User+*follow', content: '[[*always]]'
       end
-      expect(Card.new( type: "Book" ).rule(:follow)).to eq("[[*always]]")
+      expect(Card.new(type: 'Book').rule(:follow)).to eq('[[*always]]')
     end
 
-    it "retrieves user indepedent Set based value" do
+    it 'retrieves user indepedent Set based value' do
       Card::Auth.as_bot do
-        Card.create name: "Book+*type+*all+*follow", content: "[[Home]]"
+        Card.create name: 'Book+*type+*all+*follow', content: '[[Home]]'
       end
-      expect(Card.new( type: "Book" ).rule(:follow)).to eq("[[Home]]")
+      expect(Card.new(type: 'Book').rule(:follow)).to eq('[[Home]]')
     end
 
-    it "uses *all user rule when no super.s"
+    it 'uses *all user rule when no super.s'
 
-    it "user-specific value overwrites user-independent value" do
+    it 'user-specific value overwrites user-independent value' do
       Card::Auth.as_bot do
-        Card.create name: "Book+*type+Joe User+*follow", content: "[[*never]]"
-        Card.create name: "Book+*type+*all+*follow", content: "[[*always]]"
+        Card.create name: 'Book+*type+Joe User+*follow', content: '[[*never]]'
+        Card.create name: 'Book+*type+*all+*follow', content: '[[*always]]'
       end
-      expect(Card.new( type: "Book" ).rule(:follow)).to eq("[[*never]]")
+      expect(Card.new(type: 'Book').rule(:follow)).to eq('[[*never]]')
     end
 
     describe '#all_user_ids_with_rule_for' do
-      it "returns all user with values for the given Set and rule" do
+      it 'returns all user with values for the given Set and rule' do
         Card::Auth.as_bot do
-          Card.create(name: "Book+*type+Joe User+*follow", content: "[[Home]]")
+          Card.create(name: 'Book+*type+Joe User+*follow', content: '[[Home]]')
           Card::Auth.current_id = Card.fetch('Joe Admin').id
-          Card.create(name: "Book+*type+Joe Admin+*follow", content: "[[Home]]")
-          user_ids = Card.all_user_ids_with_rule_for( Card.fetch("Book+*type"), :follow ).sort
-          expect(user_ids).to eq [Card['Joe User'].id, Card['Joe Admin'].id].sort
+          Card.create(name: 'Book+*type+Joe Admin+*follow', content: '[[Home]]')
+          user_ids = Card.all_user_ids_with_rule_for(
+            Card.fetch('Book+*type'), :follow
+          )
+          expect(user_ids.sort).to eq(
+            [Card['Joe User'].id, Card['Joe Admin'].id].sort
+          )
         end
       end
     end

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

@@ -117,4 +117,3 @@ describe Card::Set::All::Templating do
     end
   end
 end
-

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

@@ -29,9 +29,9 @@ module RenameMethods
   end
 end
 
-include RenameMethods
-
 describe Card::Set::All::TrackedAttributes do
+  include RenameMethods
+
   describe 'set_name' do
     it 'should handle case variants' do
       @c = Card.create! name: 'chump'
@@ -266,7 +266,6 @@ describe Card::Set::All::TrackedAttributes do
       end
     end
 
-
     context 'blues' do
       before do
         Card::Auth.as_bot do
@@ -281,7 +280,7 @@ describe Card::Set::All::TrackedAttributes do
         end
       end
 
-      it 'test_updates_inclusions_when_renaming' do
+      it 'test_updates_nests_when_renaming' do
         c1 = Card['Blue']
         c2 = Card['blue includer 1']
         c3 = Card['blue includer 2']
@@ -291,7 +290,7 @@ describe Card::Set::All::TrackedAttributes do
         assert_equal '{{Red|closed;other:stuff}}', Card.find(c3.id).content
       end
 
-      it 'test_updates_inclusions_when_renaming_to_plus' do
+      it 'test_updates_nests_when_renaming_to_plus' do
         c1 = Card['Blue']
         c2 = Card['blue includer 1']
         c1.update_attributes name: 'blue includer 1+color',

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

@@ -40,6 +40,28 @@ describe Card::Set::All::Trash do
     end
   end
 
+  it 'deletes children under a set' do
+    Card::Auth.as_bot do
+      type = Card.create! name: 'Metric Value', type_id: Card::CardtypeID
+      Card.create! name: 'Metric value+value+*type plus right',
+                   type_id: Card::SetID
+      mv1_name = 'Richard Mills+Annual Sales+CA+2014'
+      mv2_name = 'Richard Mills+Annual Profits+CA+2014'
+      Card.create! name: mv1_name, type_id: type.id
+      Card.create! name: mv2_name, type_id: type.id
+      Card.create! name: "#{mv1_name}+value", type_id: Card::BasicID
+      Card.create! name: "#{mv2_name}+value", type_id: Card::BasicID
+
+      expect(Card['CA']).to be
+      Card['CA'].delete
+      expect(Card['CA']).not_to be
+      expect(Card[mv1_name]).not_to be
+      expect(Card["#{mv1_name}+value"]).not_to be
+      expect(Card[mv2_name]).not_to be
+      expect(Card["#{mv2_name}+value"]).not_to be
+    end
+  end
+
   it 'deletes account of user' do
     Card::Auth.as_bot do
       @signup = Card.create!(
@@ -51,7 +73,7 @@ describe Card::Set::All::Trash do
     Card::Cache.reset_all
 
     Card::Auth.as_bot do
-      expect(Card.search :right=>'*account').not_to be_empty
+      expect(Card.search right: '*account').not_to be_empty
       Card['born to die'].delete!
     end
     expect(Card['born to die+*account']).not_to be

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

@@ -6,7 +6,7 @@ describe Card::Set::All::Type do
       Card::Auth.as_bot do
         @type = Card.create! name: 'Hat', type: 'Cardtype'
       end
-      @hat =  Card.new type: 'Hat'
+      @hat = Card.new type: 'Hat'
     end
 
     it 'should have a type_name' do
@@ -24,10 +24,8 @@ describe Card::Set::All::Type do
     it 'should have a type_card' do
       expect(@hat.type_card).to eq(@type)
     end
-
   end
 
-
   describe 'card with structured type' do
     before do
       Card::Auth.as_bot do
@@ -37,7 +35,7 @@ describe Card::Set::All::Type do
       end
     end
 
-    it "should clear cache of structured nested card after saving" do
+    it 'should clear cache of structured nested card after saving' do
       Card::Auth.as_bot do
         expect(Card.fetch('t1+results', new: {}).type_name).to eq('Basic')
 
@@ -48,5 +46,4 @@ describe Card::Set::All::Type do
       end
     end
   end
-
 end

data/mod/01_history/lib/card/action.rb

@@ -15,7 +15,7 @@ class Card
                        }
 
     # replace with enum if we start using rails 4
-    TYPE = [:create, :update, :delete]
+    TYPE = [:create, :update, :delete].freeze
 
     def expire
       self.class.cache.delete id.to_s
@@ -40,9 +40,7 @@ class Card
       end
 
       def delete_old
-        Card.find_each do |card|
-          card.delete_old_actions
-        end
+        Card.find_each(&:delete_old_actions)
         Card::Act.delete_actionless
       end
     end
@@ -83,12 +81,12 @@ class Card
 
     def new_values
       @new_values ||=
-      {
-        content:  new_value_for(:db_content),
-        name:     new_value_for(:name),
-        cardtype: ((typecard = Card[new_value_for(:type_id).to_i]) &&
-                   typecard.name.capitalize)
-      }
+        {
+          content:  new_value_for(:db_content),
+          name:     new_value_for(:name),
+          cardtype: ((typecard = Card[new_value_for(:type_id).to_i]) &&
+                     typecard.name.capitalize)
+        }
     end
 
     def old_values

data/mod/01_history/set/all/actions.rb

@@ -25,15 +25,13 @@ def nth_action index
   index = index.to_i
   return unless id && index > 0
   Action.where("draft is not true AND card_id = #{id}")
-    .order(:id).limit(1).offset(index - 1).first
+        .order(:id).limit(1).offset(index - 1).first
 end
 
 def revision action
   # a "revision" refers to the state of all tracked fields
   # at the time of a given action
-  if action.is_a? Integer
-    action = Card::Action.fetch(action)
-  end
+  action = Card::Action.fetch(action) if action.is_a? Integer
   action && Card::TRACKED_FIELDS.inject({}) do |attr_changes, field|
     last_change = action.card_changes.find_by_field_name(field) ||
                   last_change_on(field, not_after: action)

data/mod/01_history/set/all/content_history.rb

@@ -1,10 +1,13 @@
 
-# if these aren't in a nested module, the methods just overwrite the base methods,
-# but we need a distict module so that super will be able to refer to the base methods.
+# if these aren't in a nested module, the methods just overwrite the base
+#  methods, but we need a distict module so that super will be able to refer to
+# the base methods.
 def content
   if @selected_action_id
     @selected_content ||= begin
-      (change = last_change_on( :db_content, not_after: @selected_action_id, including_drafts: true ) and change.value) || db_content
+      change = last_change_on :db_content, not_after: @selected_action_id,
+                                           including_drafts: true
+      (change && change.value) || db_content
     end
   else
     super
@@ -19,33 +22,33 @@ end
 def save_content_draft content
   super
   acts.create do |act|
-    act.actions.build(draft: true, card_id: id).card_changes.build(field: :db_content, value: content)
+    act.actions.build(draft: true, card_id: id)
+       .card_changes.build(field: :db_content, value: content)
   end
 end
 
-def last_change_on(field, opts={})
-  where_sql =  'card_actions.card_id = :card_id AND field = :field '
-  if !opts[:including_drafts]
-    where_sql += 'AND (draft is not true) '
-  end
+def last_change_on field, opts={}
+  where_sql = 'card_actions.card_id = :card_id AND field = :field '
+  where_sql += 'AND (draft is not true) ' unless opts[:including_drafts]
   where_sql += if opts[:before]
-    'AND card_action_id < :action_id'
-  elsif opts[:not_after]
-    'AND card_action_id <= :action_id'
-  else
-    ''
-  end
+                 'AND card_action_id < :action_id'
+               elsif opts[:not_after]
+                 'AND card_action_id <= :action_id'
+               else
+                 ''
+               end
 
   action_arg = opts[:before] || opts[:not_after]
-  action_id = action_arg.kind_of?(Card::Action) ? action_arg.id : action_arg
+  action_id = action_arg.is_a?(Card::Action) ? action_arg.id : action_arg
   field_index = Card::TRACKED_FIELDS.index(field.to_s)
-  Change.joins(:action).where( where_sql,
-    {card_id: id, field: field_index, action_id: action_id}
+  Change.joins(:action).where(
+    where_sql, card_id: id, field: field_index, action_id: action_id
   ).order(:id).last
 end
 
 def selected_action_id
-  @selected_action_id || (@current_action and @current_action.id) || last_action_id
+  @selected_action_id || (@current_action && @current_action.id) ||
+    last_action_id
 end
 
 def selected_action_id= action_id
@@ -54,7 +57,7 @@ def selected_action_id= action_id
 end
 
 def selected_action
-  selected_action_id and Action.fetch(selected_action_id)
+  selected_action_id && Action.fetch(selected_action_id)
 end
 
 def with_selected_action_id action_id
@@ -74,13 +77,14 @@ def selected_content_action_id
 end
 
 def new_content_action_id
-  if @current_action && (new_card? || @current_action.new_content? || db_content_changed?)
+  if @current_action && (new_card? || @current_action.new_content? ||
+     db_content_changed?)
     @current_action.id
   end
 end
 
 def last_action_id
-  la = last_action and la.id
+  (la = last_action) && la.id
 end
 
 def last_action
@@ -104,7 +108,9 @@ end
 def last_act
   if (action = last_action)
     last_act_on_self = acts.last
-    if last_act_on_self and ( action.act==last_act_on_self || last_act_on_self.acted_at>action.act.acted_at )
+    if last_act_on_self &&
+       (action.act == last_act_on_self ||
+       last_act_on_self.acted_at > action.act.acted_at)
       last_act_on_self
     else
       action.act
@@ -116,7 +122,6 @@ def acted_at
   last_act.acted_at
 end
 
-
 def previous_action action_id
   if action_id
     action_index = actions.find_index do |a|
@@ -127,15 +132,15 @@ def previous_action action_id
 end
 
 def revised_at
-  (last_action and act=last_action.act and act.acted_at) or Time.now
+  (last_action && (act = last_action.act) && act.acted_at) || Time.zone.now
 end
 
 def creator
-  Card[ creator_id ]
+  Card[creator_id]
 end
 
 def updater
-  Card[ updater_id ]
+  Card[updater_id]
 end
 
 def clean_html?
@@ -146,10 +151,11 @@ def draft_acts
   drafts.created_by(Card::Auth.current_id).map(&:act)
 end
 
-event :detect_conflict, before: :approve, on: :update, when: proc {|c| c.history? } do
-  if last_action_id_before_edit and last_action_id_before_edit.to_i != last_action_id and last_action.act.actor_id != Auth.current_id
-    errors.add :conflict, "changes not based on latest revision"
+event :detect_conflict, :validate,
+      on: :update, when: proc { |c| c.history? } do
+  if last_action_id_before_edit &&
+     last_action_id_before_edit.to_i != last_action_id &&
+     last_action.act.actor_id != Auth.current_id
+    errors.add :conflict, 'changes not based on latest revision'
   end
 end
-
-