card 1.18.6 → 1.19.0

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

@@ -1,193 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-class Card
-  class Action < ActiveRecord::Base
-    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'
-
-    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
-                       }
-
-    # replace with enum if we start using rails 4
-    TYPE = [:create, :update, :delete].freeze
-
-    def expire
-      self.class.cache.delete id.to_s
-    end
-
-    after_save :expire
-
-    class << self
-      def cache
-        Card::Cache[Action]
-      end
-
-      def fetch id
-        cache.fetch id.to_s do
-          find id.to_i
-        end
-      end
-
-      def delete_cardless
-        left_join = 'LEFT JOIN cards ON card_actions.card_id = cards.id'
-        joins(left_join).where('cards.id IS NULL').delete_all
-      end
-
-      def delete_changeless
-        joins(
-          'LEFT JOIN card_changes '\
-          'ON card_changes.card_action_id = card_actions.id'
-        ).where(
-          'card_changes.id IS NULL'
-        ).delete_all
-      end
-
-      def delete_old
-        Card.find_each(&:delete_old_actions)
-        Card::Act.delete_actionless
-      end
-    end
-
-    #
-    # This is the main API from Cards to history
-    # 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
-    # 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 do |f|
-    #     Card::Change.create field: f, value: obj[f], card_action_id: id
-    #   end
-    # end
-
-    def value field
-      return unless (change = change field)
-      interpret_value field, change.value
-    end
-
-    def change field
-      changes[interpret_field field]
-    end
-
-    def changes
-      @changes ||=
-        card_changes.each_with_object({}) do |change, hash|
-          hash[change.field.to_sym] = change
-        end
-    end
-
-    def previous_value field
-      return if action_type == :create
-      return unless (previous_change = previous_change field)
-      interpret_value field, previous_change.value
-    end
-
-    def new_type?
-      value :type_id
-    end
-
-    def new_content?
-      value :db_content
-    end
-
-    def new_name?
-      value :name
-    end
-
-    def action_type= value
-      write_attribute :action_type, TYPE.index(value)
-    end
-
-    def action_type
-      TYPE[read_attribute(:action_type)]
-    end
-
-    def revision_nr
-      card.actions.index_of self
-    end
-
-    def red?
-      content_diff_object.red?
-    end
-
-    def green?
-      content_diff_object.green?
-    end
-
-    def name_diff opts={}
-      return unless new_name?
-      Card::Diff.complete previous_value(:name), value(:name), opts
-    end
-
-    def cardtype_diff opts={}
-      return unless new_type?
-      Card::Diff.complete previous_value(:cardtype), value(:cardtype), opts
-    end
-
-    def content_diff diff_type=:expanded, opts=nil
-      return unless new_content?
-      if diff_type == :summary
-        content_diff_object(opts).summary
-      else
-        content_diff_object(opts).complete
-      end
-    end
-
-    def card
-      Card.fetch card_id, look_in_trash: true, skip_modules: true
-    end
-
-    private
-
-    def content_diff_object opts=nil
-      @diff ||= begin
-        diff_args = opts || card.include_set_modules.diff_args
-        Card::Diff.new previous_value(:content), value(:content), diff_args
-      end
-    end
-
-    def previous_change field
-      field = interpret_field field
-      if @previous_changes && @previous_changes.key?(field)
-        @previous_changes[field]
-      else
-        @previous_changes ||= {}
-        @previous_changes[field] = card.last_change_on field, before: self
-      end
-    end
-
-    def interpret_field field
-      case field
-      when :content then :db_content
-      when :cardtype then :type_id
-      else field.to_sym
-      end
-    end
-
-    def interpret_value field, value
-      case field.to_sym
-      when :type_id
-        value && value.to_i
-      when :cardtype
-        type_card = value && Card.quick_fetch(value.to_i)
-        type_card && type_card.name.capitalize
-      else value
-      end
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card
-  class Change < ActiveRecord::Base
-    belongs_to :action, foreign_key: :card_action_id, inverse_of: :card_changes
-
-    class << self
-      def delete_actionless
-        joins(
-          'LEFT JOIN card_actions '\
-          'ON card_changes.card_action_id = card_actions.id '
-        ).where(
-          'card_actions.id is null'
-        ).find_in_batches do |group|
-          # used to be .delete_all here, but that was failing on large dbs
-          puts 'deleting batch of changes'
-          where("id in (#{group.map(&:id).join ','})").delete_all
-        end
-      end
-
-      def field_index value
-        value.is_a?(Integer) ? value : TRACKED_FIELDS.index(value.to_s)
-      end
-
-      def find_by_field_name value
-        find_by_field field_index(value)
-      end
-    end
-
-    def field= value
-      write_attribute(:field, TRACKED_FIELDS.index(value.to_s))
-    end
-
-    def field
-      TRACKED_FIELDS[read_attribute(:field)]
-    end
-
-    def find_by_field_name value
-      find_by_field self.class.field_index(value)
-    end
-  end
-end

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

@@ -1,54 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-def select_action_by_params params
-  return unless (action = find_action_by_params(params))
-  run_callbacks :select_action do
-    self.selected_action_id = action.id
-  end
-end
-
-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])) && action.card_id == id
-      action
-    end
-  # 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
-  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
-  action = Card::Action.fetch(action) if action.is_a? Integer
-  action && Card::TRACKED_FIELDS.inject({}) do |attr_changes, field|
-    last_change = action.change(field) ||
-                  last_change_on(field, not_after: action)
-    attr_changes[field.to_sym] = (last_change ? last_change.value : self[field])
-    attr_changes
-  end
-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(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
-end

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

@@ -1,161 +0,0 @@
-
-# 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
-      (change && change.value) || db_content
-    end
-  else
-    super
-  end
-end
-
-def content= value
-  @selected_content = nil
-  super
-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)
-  end
-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]
-  if opts[:before]
-    where_sql += ' AND card_action_id < :action_id'
-  elsif opts[:not_after]
-    where_sql += ' AND card_action_id <= :action_id'
-  end
-
-  action_arg = opts[:before] || opts[:not_after]
-  action_id = action_arg.is_a?(Card::Action) ? action_arg.id : action_arg
-  Change.joins(:action).where(
-    where_sql, card_id: id,
-               field: Card::Change.field_index(field),
-               action_id: action_id
-  ).order(:id).last
-end
-
-def selected_action_id
-  @selected_action_id || (@current_action && @current_action.id) ||
-    last_action_id
-end
-
-def selected_action_id= action_id
-  @selected_content = nil
-  @selected_action_id = action_id
-end
-
-def selected_action
-  selected_action_id && Action.fetch(selected_action_id)
-end
-
-def with_selected_action_id action_id
-  current_action_id = @selected_action_id
-  run_callbacks :select_action do
-    self.selected_action_id = action_id
-  end
-  result = yield
-  run_callbacks :select_action do
-    self.selected_action_id = current_action_id
-  end
-  result
-end
-
-def selected_content_action_id
-  @selected_action_id || new_content_action_id || last_content_action_id
-end
-
-def new_content_action_id
-  if @current_action && (new_card? || @current_action.new_content? ||
-     db_content_changed?)
-    @current_action.id
-  end
-end
-
-def last_action_id
-  (la = last_action) && la.id
-end
-
-def last_action
-  actions.where('id IS NOT NULL').last
-end
-
-def last_content_action
-  l_c = last_change_on :db_content
-  l_c && l_c.action
-end
-
-def last_content_action_id
-  l_c = last_change_on :db_content
-  l_c && l_c.card_action_id
-end
-
-def last_actor
-  last_act.actor
-end
-
-def last_act
-  @last_act ||=
-    if (action = last_action)
-      last_act_on_self = acts.last
-      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
-      end
-    end
-end
-
-def acted_at
-  last_act.acted_at
-end
-
-def previous_action action_id
-  if action_id
-    action_index = actions.find_index do |a|
-      a.id == action_id
-    end
-    actions[action_index - 1] if action_index.to_i != 0
-  end
-end
-
-def revised_at
-  (last_action && (act = last_action.act) && act.acted_at) || Time.zone.now
-end
-
-def creator
-  Card[creator_id]
-end
-
-def updater
-  Card[updater_id]
-end
-
-def clean_html?
-  true
-end
-
-def draft_acts
-  drafts.created_by(Card::Auth.current_id).map(&:act)
-end
-
-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