card 1.16.14 → 1.16.15

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

@@ -28,7 +28,7 @@ module ClassMethods
       INNER JOIN cards ON card_actions.card_id = cards.id
       WHERE cards.type_id IN (#{Card::FileID}, #{Card::ImageID}) AND card_actions.draft = true"
     actions.each do |action|
-      if older_than_five_days? action.created_at && card = action.card # we don't want to delete uploads in progress
+      if older_than_five_days?(action.created_at) && card = action.card # we don't want to delete uploads in progress
         card.delete_files_for_action action
       end
     end
@@ -74,6 +74,11 @@ module ClassMethods
     end
   end
 
+
+  def older_than_five_days? time
+    Time.now - time > 432000
+  end
+
 end
 
 def debug_type

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

@@ -1,13 +1,13 @@
 # -*- encoding : utf-8 -*-
 
 describe Card::Set::All::Fetch do
-  describe ".fetch" do
-    it "returns and caches existing cards" do
-      card_double = class_double("Card")
-      expect(Card.fetch("A")).to be_instance_of(Card)
-      expect(Card.cache.read("a")).to be_instance_of(Card)
+  describe '.fetch' do
+    it 'returns and caches existing cards' do
+      card_double = class_double('Card')
+      expect(Card.fetch('A')).to be_instance_of(Card)
+      expect(Card.cache.read('a')).to be_instance_of(Card)
       expect(card_double).not_to receive(:find_by_key)
-      expect(Card.fetch("A")).to be_instance_of(Card)
+      expect(Card.fetch('A')).to be_instance_of(Card)
     end
 
     it "returns nil and caches missing cards" do

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

@@ -89,8 +89,8 @@ describe Card::Set::All::Permissions do
       expect(card.read_rule_id).to eq(@perm_card.id)
       expect(card.who_can(:read)).to eq([Card['joe_admin'].id])
       Card::Auth.as(:anonymous) { expect(card.ok?(:read)).to be_falsey }
-      Card::Auth.as(:joe_user)  { expect(card.ok?(:read)).to be_falsey }
-      Card::Auth.as(:joe_admin) { expect(card.ok?(:read)).to be_truthy  }
+      Card::Auth.as('joe_user')  { expect(card.ok?(:read)).to be_falsey }
+      Card::Auth.as('joe_admin') { expect(card.ok?(:read)).to be_truthy  }
       Card::Auth.as_bot         { expect(card.ok?(:read)).to be_truthy  }
     end
 
@@ -171,7 +171,7 @@ describe Card::Set::All::Permissions do
       end
       c = Card.new(name: 'Home+Heart')
       expect(c.who_can(:read)).to eq([Card::AnyoneSignedInID])
-      expect(c.permission_rule_card(:read).first.id).to eq(@perm_card.id)
+      expect(c.permission_rule_id_and_class(:read).first).to eq(@perm_card.id)
       c.save
       expect(c.read_rule_id).to eq(@perm_card.id)
     end
@@ -183,7 +183,7 @@ describe Card::Set::All::Permissions do
       end
       c = Card.new(name: 'Home+Heart')
       expect(c.who_can(:read)).to eq([Card::AnyoneID])
-      expect(c.permission_rule_card(:read).first.id).to(
+      expect(c.permission_rule_id_and_class(:read).first).to(
         eq(Card.fetch('*all+*read').id)
       )
       c.save
@@ -234,10 +234,10 @@ describe Card::Set::All::Permissions do
       Card::Auth.as_bot do
         expect(Card::Auth.always_ok?).to eq(true)
       end
-      Card::Auth.as(:joe_user) do
+      Card::Auth.as('joe_user') do
         expect(Card::Auth.always_ok?).to eq(false)
       end
-      Card::Auth.as(:joe_admin) do
+      Card::Auth.as('joe_admin') do
         expect(Card::Auth.always_ok?).to eq(true)
         Card.create! name: 'Hidden'
         Card.create name: 'Hidden+*self+*read', type: 'Pointer',
@@ -263,12 +263,12 @@ describe Card::Set::All::Permissions do
 
     it 'reader setting' do
       Card.where(trash: false).each do |ca|
-        rule_card, rule_class = ca.permission_rule_card(:read)
+        rule_id, rule_class = ca.permission_rule_id_and_class(:read)
         # warn "C #{c.inspect}, #{c.read_rule_id}, #{prc.first.id},
         # {c.read_rule_class}, #{prc.second}, #{prc.first.inspect}" unless
         # prc.last == c.read_rule_class && prc.first.id == c.read_rule_id
         expect(rule_class).to eq(ca.read_rule_class)
-        expect(rule_card.id).to eq(ca.read_rule_id)
+        expect(rule_id).to eq(ca.read_rule_id)
       end
     end
 
@@ -474,7 +474,7 @@ describe Card::Set::All::Permissions do
     end
 
     it 'should let joe user basic cards' do
-      Card::Auth.as :joe_user do
+      Card::Auth.as 'joe_user' do
         expect(@c.ok?(:read)).to be_truthy
       end
     end
@@ -503,10 +503,10 @@ describe Card::Set::All::Permissions do
     it 'should handle delete as a setting' do
       c = Card.new name: 'whatever'
       expect(c.who_can(:delete)).to eq([Card['joe_user'].id])
-      Card::Auth.as(:joe_user) do
+      Card::Auth.as('joe_user') do
         expect(c.ok?(:delete)).to eq(true)
       end
-      Card::Auth.as(:u1) do
+      Card::Auth.as('u1') do
         expect(c.ok?(:delete)).to eq(false)
       end
       Card::Auth.as(:anonymous) do

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

@@ -195,7 +195,7 @@ describe Card::Set::All::TrackedAttributes do
 
     it 'test_rename_should_not_fail_when_updating_inaccessible_referencer' do
       Card.create! name: 'Joe Card', content: 'Whattup'
-      Card::Auth.as :joe_admin do
+      Card::Auth.as 'joe_admin' do
         Card.create! name: 'Admin Card', content: '[[Joe Card]]'
       end
       c = Card['Joe Card']

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

@@ -1,17 +1,18 @@
 # -*- encoding : utf-8 -*-
 
 class Card
-
   class Action < ActiveRecord::Base
     belongs_to :card
     belongs_to :act,  foreign_key: :card_act_id, inverse_of: :actions
-    has_many   :card_changes, foreign_key: :card_action_id, inverse_of: :action,
-      dependent: :delete_all, class_name: "Card::Change"
+    has_many :card_changes, foreign_key: :card_action_id, inverse_of: :action,
+                            dependent: :delete_all, class_name: 'Card::Change'
 
-    belongs_to :super_action, class_name: "Action", inverse_of: :sub_actions
-    has_many   :sub_actions,  class_name: "Action", inverse_of: :super_action
+    belongs_to :super_action, class_name: 'Action', inverse_of: :sub_actions
+    has_many :sub_actions, class_name: 'Action', inverse_of: :super_action
 
-    scope :created_by, lambda { |actor_id| joins(:act).where('card_acts.actor_id = ?', actor_id) }
+    scope :created_by, lambda { |actor_id|
+                         joins(:act).where 'card_acts.actor_id = ?', actor_id
+                       }
 
     # replace with enum if we start using rails 4
     TYPE = [:create, :update, :delete]
@@ -28,13 +29,14 @@ class Card
       end
 
       def fetch id
-        cache.read(id.to_s) or begin
+        cache.read(id.to_s) || begin
           cache.write id.to_s, Action.find(id.to_i)
         end
       end
 
       def delete_cardless
-        Card::Action.joins('LEFT JOIN cards ON card_actions.card_id = cards.id').where('cards.id IS NULL').delete_all
+        left_join = 'LEFT JOIN cards ON card_actions.card_id = cards.id'
+        Card::Action.joins(left_join).where('cards.id IS NULL').delete_all
       end
 
       def delete_old
@@ -50,19 +52,21 @@ class Card
     # See also create_act_and_action, which needs to happen before this or we
     # don't have the action to call this method on.
     #
-    # When changes are stored for versioned attributes, this is the signal method
-    # By overriding this method in a module, the module takes over handling of
-    # changes.  Although the standard version stores the Changes in active record
-    # models (Act, Action and Change records), these could be /dev/nulled for a
-    # history-less implementation, or handled by an external service.
-    #
-    # If change streams are generated from database triggers, and we aren't writing
-    # here (disabled history), we still have to generate change stream events in
-    # another way.
+    # When changes are stored for versioned attributes, this is the signal
+    # method. By overriding this method in a module, the module takes over
+    # handling of changes.  Although the standard version stores the Changes in
+    # ActiveRecord models (Act, Action and Change records), these could be
+    # /dev/nulled for a history-less implementation, or handled by an external
+    # service.
     #
+    # If change streams are generated from database triggers, and we aren't
+    # writing here (disabled history), we still have to generate change stream
+    # events in another way.
+
     def changed_fields obj, changed_fields
-      #changed_fields.each{ |f| changes.build field: f, value: self[f] }
-      changed_fields.each{ |f| Card::Change.create field: f, value: obj[f], card_action_id: id }
+      changed_fields.each do |f|
+        Card::Change.create field: f, value: obj[f], card_action_id: id
+      end
     end
 
     def edit_info
@@ -82,7 +86,8 @@ class Card
       {
         content:  new_value_for(:db_content),
         name:     new_value_for(:name),
-        cardtype: ( typecard = Card[new_value_for(:type_id).to_i] and typecard.name.capitalize )
+        cardtype: ((typecard = Card[new_value_for(:type_id).to_i]) &&
+                   typecard.name.capitalize)
       }
     end
 
@@ -90,13 +95,15 @@ class Card
       @old_values ||= {
         content:  last_value_for(:db_content),
         name:     last_value_for(:name),
-        cardtype: ( value = last_value_for(:type_id) and
-                       typecard = Card.find(value) and  typecard.name.capitalize )
+        cardtype: ((value = last_value_for(:type_id)) &&
+                   (typecard = Card.find(value)) &&
+                   typecard.name.capitalize)
       }
     end
 
     def last_value_for field
-      ch = self.card.last_change_on(field, before: self) and ch.value
+      ch = card.last_change_on(field, before: self)
+      ch && ch.value
     end
 
     def field_index field
@@ -108,7 +115,8 @@ class Card
     end
 
     def new_value_for field
-      ch = card_changes.find_by(field: field_index(field)) and ch.value
+      ch = card_changes.find_by(field: field_index(field))
+      ch && ch.value
     end
 
     def change_for field
@@ -116,19 +124,19 @@ class Card
     end
 
     def new_type?
-      new_value_for(:type_id)
+      new_value_for :type_id
     end
 
     def new_content?
-      new_value_for(:db_content)
+      new_value_for :db_content
     end
 
     def new_name?
-      new_value_for(:name)
+      new_value_for :name
     end
 
-    def action_type=(value)
-      write_attribute(:action_type, TYPE.index(value))
+    def action_type= value
+      write_attribute :action_type, TYPE.index(value)
     end
 
     def action_type
@@ -136,11 +144,11 @@ class Card
     end
 
     def set_act
-      self.set_act ||= self.acts.last
+      self.set_act ||= acts.last
     end
 
     def revision_nr
-      self.card.actions.index_of(self)
+      card.actions.index_of self
     end
 
     def red?
@@ -156,38 +164,35 @@ class Card
     # end
 
     def name_diff opts={}
-      if new_name?
-        Card::Diff.complete old_values[:name], new_values[:name], opts
-      end
+      return unless new_name?
+      Card::Diff.complete old_values[:name], new_values[:name], opts
     end
 
     def cardtype_diff opts={}
-      if new_type?
-        Card::Diff.complete old_values[:cardtype], new_values[:cardtype], opts
-      end
+      return unless new_type?
+      Card::Diff.complete old_values[:cardtype], new_values[:cardtype], opts
     end
 
     def content_diff diff_type=:expanded, opts=nil
-      if new_content?
-        if diff_type == :summary
-          content_diff_builder(opts).summary
-        else
-          content_diff_builder(opts).complete
-        end
+      return unless new_content?
+      if diff_type == :summary
+        content_diff_builder(opts).summary
+      else
+        content_diff_builder(opts).complete
       end
     end
 
     def content_diff_builder opts=nil
       @content_diff_builder ||= begin
-        Card::Diff::DiffBuilder.new(old_values[:content], new_values[:content], opts || card.include_set_modules.diff_args)
+        diff_args = opts || card.include_set_modules.diff_args
+        Card::Diff::DiffBuilder.new(
+          old_values[:content], new_values[:content], diff_args
+        )
       end
     end
 
     def card
       Card.fetch card_id, look_in_trash: true
     end
-
   end
 end
-
-

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

@@ -1,10 +1,9 @@
 # -*- encoding : utf-8 -*-
 
 def select_action_by_params params
-  if (action = find_action_by_params(params))
-    run_callbacks :select_action do
-      self.selected_action_id = action.id
-    end
+  return unless (action = find_action_by_params(params))
+  run_callbacks :select_action do
+    self.selected_action_id = action.id
   end
 end
 
@@ -12,28 +11,32 @@ def find_action_by_params args
   if args[:rev]
     nth_action args[:rev]
   elsif Integer === args[:rev_id] || args[:rev_id] =~ /^\d+$/
-    if action = Action.fetch(args[:rev_id]) and action.card_id == id
+    if (action = Action.fetch(args[:rev_id])) && action.card_id == id
       action
     end
-  elsif args[:rev_id]  # revision id is probalby a mod (e.g. if you request files/:logo/05_standard.png)
+  # revision id is probalby a mod (e.g. if you request
+  # files/:logo/05_standard.png)
+  elsif args[:rev_id]
     last_action
   end
 end
 
 def nth_action index
   index = index.to_i
-  if id and index > 0
-    Action.where("draft is not true AND card_id = #{id}").order(:id).limit(1).offset(index-1).first
-  end
+  return unless id && index > 0
+  Action.where("draft is not true AND card_id = #{id}")
+    .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
+  # 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 and 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)
+  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)
     attr_changes[field.to_sym] = (last_change ? last_change.value : self[field])
     attr_changes
   end
@@ -42,11 +45,12 @@ end
 def delete_old_actions
   Card::TRACKED_FIELDS.each do |field|
     # assign previous changes on each tracked field to the last action
-    if (la = last_action) && !la.change_for(field).present? and (last_change = last_change_on(field))
-      last_change = Card::Change.find(last_change.id)   # last_change comes as readonly record
+    if (la = last_action) && !la.change_for(field).present? &&
+       (last_change = last_change_on(field))
+      # last_change comes as readonly record
+      last_change = Card::Change.find(last_change.id)
       last_change.update_attributes!(card_action_id: last_action_id)
     end
   end
-  actions.where('id != ?', last_action_id ).delete_all
+  actions.where('id != ?', last_action_id).delete_all
 end
-

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

@@ -23,18 +23,22 @@ event :assign_action, after: :assign_act do
   end
 end
 
+def finalize_action?
+  (history? || respond_to?(:attachment)) && current_action
+end
+
 # stores changes in the changes table and assigns them to the current action
 # removes the action if there are no changes
-event :finalize_action,
-      after: :stored,
-      when: proc { |c|
-        (c.history? || c.respond_to?(:attachment)) && c.current_action
-      } do
+event :finalize_action, after: :stored, when: proc { |c| c.finalize_action? } do
   @changed_fields = Card::TRACKED_FIELDS.select do |f|
     changed_attributes.member? f
   end
   if @changed_fields.present?
-    @changed_fields.each{ |f| Card::Change.create field: f, value: self[f], card_action_id: @current_action.id }
+    @changed_fields.each do |f|
+      Card::Change.create field: f,
+                          value: self[f],
+                          card_action_id: @current_action.id
+    end
     @current_action.update_attributes! card_id: id
   elsif @current_action.card_changes(true).empty?
     @current_action.delete
@@ -198,8 +202,10 @@ format :html do
                      card.current_rev_nr
     hide_diff = (params['hide_diff'] == ' true') || args[:hide_diff]
     args[:slot_class] = "revision-#{act.id} history-slot list-group-item"
+    draft = (last_action = act.actions.last) && last_action.draft
+
     wrap(args) do
-      render_haml card: card, act: act, act_view: act_view,
+      render_haml card: card, act: act, act_view: act_view, draft: draft,
                   current_rev_nr: current_rev_nr, rev_nr: rev_nr,
                   hide_diff: hide_diff do
         <<-HAML
@@ -213,7 +219,7 @@ format :html do
       .time.timeago
         = time_ago_in_words(act.acted_at)
         ago
-        - if act.actions.last.draft
+        - if draft
           |
           %em.info
             Autosave
@@ -221,14 +227,14 @@ format :html do
           %em.label.label-info
             Current
         - elsif act_view == :expanded
-          = rollback_link act.relevant_actions_for(card, act.actions.last.draft)
+          = rollback_link act.relevant_actions_for(card, draft)
           = show_or_hide_changes_link hide_diff, act_id: act.id, act_view: act_view, rev_nr: rev_nr, current_rev_nr: current_rev_nr
   .toggle
     = fold_or_unfold_link act_id: act.id, act_view: act_view, rev_nr: rev_nr, current_rev_nr: current_rev_nr
 
   .action-container{style: ("clear: left;" if act_view == :expanded)}
     - act.relevant_actions_for(card).each do |action|
-      = send("_render_action_#{ act_view }", action: action )
+      = send("_render_action_#{act_view}", action: action )
 HAML
       end
     end
@@ -242,7 +248,6 @@ HAML
     render_action :expanded, args
   end
 
-
   def render_action action_view, args
     action = args[:action] || card.last_action
     hide_diff = Env.params['hide_diff'] == 'true' || args[:hide_diff]
@@ -347,8 +352,8 @@ HAML
     toggled_view = args[:act_view] == :expanded ? :act_summary : :act_expanded
     arrow_dir = args[:act_view] == :expanded ? 'arrow-down' : 'arrow-right'
     link_to '', args.merge(view: toggled_view),
-              class: "slotter revision-#{args[:act_id]} #{arrow_dir}",
-              remote: true
+            class: "slotter revision-#{args[:act_id]} #{arrow_dir}",
+            remote: true
   end
 
   def show_or_hide_changes_link hide_diff, args