card-mod-history 0.11.0

data/lib/card/act/act_renderer/relative_act_renderer.rb

@@ -0,0 +1,59 @@
+class Card
+  class Act
+    class ActRenderer
+      # Use for the history for one specific card
+      # It shows only the actions of an act that are relevant
+      # for the card of the format that renders the act.
+      class RelativeActRenderer < ActRenderer
+        def title
+          "<span class=\"nr\">##{@args[:act_seq]}</span>" +
+            accordion_expand_link(@act.actor.name) +
+            " " +
+            wrap_with(:small, edited_ago)
+        end
+
+        def subtitle
+          return "" unless @act.card_id != @format.card.id
+
+          wrap_with :small, "act on #{absolute_title}"
+        end
+
+        def act_links
+          return unless (content = rollback_or_edit_link)
+
+          wrap_with :small, content
+        end
+
+        def rollback_or_edit_link
+          if @act.draft?
+            autosaved_draft_link text: "continue editing",
+                                 class: "collapse #{collapse_id}"
+          elsif show_rollback_link?
+            rollback_link
+          end
+        end
+
+        def show_rollback_link?
+          !current_act?
+        end
+
+        def current_act?
+          return unless @format.card.last_act && @act
+
+          @act.id == @format.card.last_act.id
+        end
+
+        def actions
+          @actions ||= @act.actions_affecting(@card)
+        end
+
+        def revert_link
+          revert_actions_link "revert to this",
+                              { revert_actions: actions.map(&:id) },
+                              class: "_close-modal",
+                              "data-slotter-mode": "update-modal-origin"
+        end
+      end
+    end
+  end
+end

data/lib/card/action.rb

@@ -0,0 +1,230 @@
+# -*- encoding : utf-8 -*-
+
+class Card
+  # An _action_ is a group of {Card::Change changes} to a single {Card card}
+  # that is recorded during an {Card::Act act}.
+  # Together, {Act acts}, {Action actions}, and {Change changes} comprise a
+  # comprehensive {Card card} history tracking system.
+  #
+  # For example, if a given web submission changes both the name and type of
+  # a given card, that would be recorded as one {Action action} with two
+  # {Change changes}. If there are multiple cards changed, each card would
+  # have its own {Action action}, but the whole submission would still comprise
+  # just one single {Act act}.
+  #
+  # An {Action} records:
+  #
+  # * the _card_id_ of the {Card card} acted upon
+  # *  the _card_act_id_ of the {Card::Act act} of which the action is part
+  # * the _action_type_ (create, update, or delete)
+  # * a boolean indicated whether the action is a _draft_
+  # * a _comment_ (where applicable)
+  #
+  class Action < ApplicationRecord
+    include Differ
+    extend Admin
+
+    belongs_to :act, foreign_key: :card_act_id, inverse_of: :ar_actions
+    belongs_to :ar_card, foreign_key: :card_id, inverse_of: :actions, class_name: "Card"
+    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
+                       }
+
+    # these are the three possible values for action_type
+    TYPE_OPTIONS = %i[create update delete].freeze
+
+    after_save :expire
+
+    class << self
+      # retrieve action from cache if available
+      # @param id [id of Action]
+      # @return [Action, nil]
+      def fetch id
+        cache.fetch id.to_s do
+          find id.to_i
+        end
+      end
+
+      # cache object for actions
+      # @return [Card::Cache]
+      def cache
+        Card::Cache[Action]
+      end
+
+      def all_with_cards
+        joins :ar_card
+      end
+
+      def all_viewable
+        all_with_cards.where Query::CardQuery.viewable_sql
+      end
+    end
+
+    # each action is associated with on and only one card
+    # @return [Card]
+    def card
+      Card.fetch card_id, look_in_trash: true
+
+      # I'm not sure what the rationale for the following was/is, but it was causing
+      # problems in cases where slot attributes are overridden (eg see #wrap_data in
+      # sources on wikirate).  The problem is the format object had the set modules but
+      # the card didn't.
+      #
+      # My guess is that the need for the following had something to do with errors
+      # associated with changed types. If so, the solution probably needs to handle
+      # including the set modules associated with the type at the time of the action
+      # rather than including no set modules at all.
+      #
+      # What's more, we _definitely_ don't want to hard code special behavior for
+      # specific types in here!
+
+      # , skip_modules: true
+      # return res unless res && res.type_id.in?([Card::FileID, Card::ImageID])
+      # res.include_set_modules
+    end
+
+    # remove action from action cache
+    def expire
+      self.class.cache.delete id.to_s
+    end
+
+    # assign action_type (create, update, or delete)
+    # @param value [Symbol]
+    # @return [Integer]
+    def action_type= value
+      write_attribute :action_type, TYPE_OPTIONS.index(value)
+    end
+
+    # retrieve action_type (create, update, or delete)
+    # @return [Symbol]
+    def action_type
+      return :draft if draft
+
+      TYPE_OPTIONS[read_attribute(:action_type)]
+    end
+
+    def previous_action
+      Card::Action.where("id < ? AND card_id = ?", id, card_id).last
+    end
+
+    # value set by action's {Change} to given field
+    # @see #interpret_field #interpret_field for field param
+    # @see #interpret_value #interpret_value for return values
+    def value field
+      return unless (change = change field)
+
+      interpret_value field, change.value
+    end
+
+    # value of field set by most recent {Change} before this one
+    # @see #interpret_field #interpret_field for field param
+    # @see #interpret_field  #interpret_field for field param
+    def previous_value field
+      return if action_type == :create
+      return unless (previous_change = previous_change field)
+
+      interpret_value field, previous_change.value
+    end
+
+    # action's {Change} object for given field
+    # @see #interpret_field #interpret_field for field param
+    # @return [Change]
+    def change field
+      changes[interpret_field field]
+    end
+
+    # most recent change to given field before this one
+    # @see #interpret_field #interpret_field for field param
+    # @return [Change]
+    def previous_change field
+      return nil if action_type == :create
+
+      field = interpret_field field
+      if @previous_changes&.key?(field)
+        @previous_changes[field]
+      else
+        @previous_changes ||= {}
+        @previous_changes[field] = card.last_change_on field, before: self
+      end
+    end
+
+    def all_changes
+      self.class.cache.fetch("#{id}-changes") do
+        # using card_changes causes caching problem
+        Card::Change.where(card_action_id: id).to_a
+      end
+    end
+
+    # all action {Change changes} in hash form. { field1: Change1 }
+    # @return [Hash]
+    def changes
+      @changes ||=
+        if sole?
+          current_changes
+        else
+          all_changes.each_with_object({}) do |change, hash|
+            hash[change.field.to_sym] = change
+          end
+        end
+    end
+
+    # all changed values in hash form. { field1: new_value }
+    def changed_values
+      @changed_values ||= changes.each_with_object({}) do |(key, change), h|
+        h[key] = change.value
+      end
+    end
+
+    # @return [Hash]
+    def current_changes
+      return {} unless card
+
+      @current_changes ||=
+        Card::Change::TRACKED_FIELDS.each_with_object({}) do |field, hash|
+          hash[field.to_sym] = Card::Change.new field: field,
+                                                value: card.send(field),
+                                                card_action_id: id
+        end
+    end
+
+    # translate field into fieldname as referred to in database
+    # @see Change::TRACKED_FIELDS
+    # @param field [Symbol] can be :type_id, :cardtype, :db_content, :content,
+    #     :name, :trash
+    # @return [Symbol]
+    def interpret_field field
+      case field
+      when :content then :db_content
+      when :cardtype then :type_id
+      else field.to_sym
+      end
+    end
+
+    # value in form prescribed for specific field name
+    # @param value [value of {Change}]
+    # @return [Integer] for :type_id
+    # @return [String] for :name, :db_content, :content, :cardtype
+    # @return [True/False] for :trash
+    def interpret_value field, value
+      case field.to_sym
+      when :type_id
+        value&.to_i
+      when :cardtype
+        Card.fetch_name(value&.to_i)
+      else value
+      end
+    end
+
+    def sole?
+      all_changes.empty? &&
+        (action_type == :create || Card::Action.where(card_id: card_id).count == 1)
+    end
+  end
+end

data/lib/card/action/action_renderer.rb

@@ -0,0 +1,94 @@
+class Card
+  class Action
+    class ActionRenderer
+      attr_reader :action, :header
+      def initialize format, action, header=true, action_view=:summary, hide_diff=false
+        @format = format
+        @action = action
+        @header = header
+        @action_view = action_view
+        @hide_diff = hide_diff
+      end
+
+      include ::Bootstrapper
+      def method_missing method_name, *args, &block
+        if block_given?
+          @format.send(method_name, *args, &block)
+        else
+          @format.send(method_name, *args)
+        end
+      end
+
+      def respond_to_missing? method_name, _include_private=false
+        @format.respond_to? method_name
+      end
+
+      def render
+        classes = @format.classy("action-list")
+        bs_layout container: true, fluid: true do
+          row do
+            html <<-HTML
+              <ul class="#{classes} w-100">
+                <li class="#{action.action_type}">
+                  #{action_panel}
+                </li>
+              </ul>
+            HTML
+          end
+        end
+      end
+
+      def action_panel
+        bs_panel do
+          if header
+            heading do
+              div type_diff, class: "float-right"
+              div name_diff
+            end
+          end
+          body do
+            content_diff
+          end
+        end
+      end
+
+      def name_diff
+        if @action.card == @format.card
+          name_changes
+        else
+          link_to_view(
+            :related, name_changes,
+            path: { slot: { items: { view: "history", nest_name: @action.card.name } } },
+            # "data-slot-selector" => ".card-slot.history-view"
+          )
+        end
+      end
+
+      def content_diff
+        return @action.raw_view if @action.action_type == :delete
+
+        @format.subformat(@action.card).render_action_summary action_id: @action.id
+      end
+
+      def type_diff
+        return "" unless @action.new_type?
+
+        @hide_diff ? @action.value(:cardtype) : @action.cardtype_diff
+      end
+
+      def name_changes
+        return old_name unless @action.new_name?
+
+        @hide_diff ? new_name : Card::Content::Diff.complete(old_name, new_name)
+      end
+
+      def old_name
+        (name = @action.previous_value :name) && title_in_context(name)
+      end
+
+      def new_name
+        title_in_context @action.value(:name)
+      end
+    end
+  end
+end

data/lib/card/action/admin.rb

@@ -0,0 +1,36 @@
+class Card
+  class Action
+    # methods for administering card actions
+    module Admin
+      # permanently delete all {Action actions} not associated with a {Card}
+      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
+
+      # permanently delete all {Action actions} associate with non-current
+      # {Change changes}
+      def delete_old
+        Card::Change.delete_all
+        Card.find_each(&:delete_old_actions)
+        Card::Act.delete_actionless
+      end
+
+      # If an act is given then all remaining actions will be attached to that act.
+      # Otherwise the actions keep their acts.
+      def make_current_state_the_initial_state act=nil
+        Card::Change.delete_all
+        Card.find_each(&:delete_old_actions)
+        action_update = { action_type: Card::Action::TYPE_OPTIONS.index(:create) }
+        action_update[:card_act_id] = act.id if act
+        Card::Action.update_all action_update
+
+        if act
+          Card::Act.where("id != :id", id: act.id).delete_all
+        else
+          Card::Act.delete_actionless
+        end
+      end
+    end
+  end
+end

data/lib/card/action/differ.rb

@@ -0,0 +1,89 @@
+class Card
+  class Action
+    # a collection of methods for comparing actions
+    module Differ
+      # compare action's name value with previous name value
+      # @return [rendered diff]
+      def name_diff opts={}
+        return unless new_name?
+
+        diff_object(:name, opts).complete
+      end
+
+      # does action change card's name?
+      # @return [true/false]
+      def new_name?
+        !value(:name).nil?
+      end
+
+      # @return [rendered diff]
+      # compare action's cardtype value with previous cardtype value
+      def cardtype_diff opts={}
+        return unless new_type?
+
+        diff_object(:cardtype, opts).complete
+      end
+
+      # does action change card's type?
+      # @return [true/false]
+      def new_type?
+        !value(:type_id).nil?
+      end
+
+      # @return [rendered diff]
+      # compare action's content value with previous content value
+      def content_diff diff_type=:expanded, opts=nil
+        return unless new_content?
+
+        dobj = content_diff_object(opts)
+        diff_type == :summary ? dobj.summary : dobj.complete
+      end
+
+      # does action change card's content?
+      # @return [true/false]
+      def new_content?
+        !value(:db_content).nil?
+      end
+
+      # test whether content was visibly removed
+      # @return [true/false]
+      def red?
+        content_diff_object.red?
+      end
+
+      # test whether content was visibly added
+      # @return [true/false]
+      def green?
+        content_diff_object.green?
+      end
+
+      def raw_view content=nil
+        original_content = card.db_content
+        card.db_content = content || value(:db_content)
+        card.format.render_raw
+      ensure
+        card.db_content = original_content
+      end
+
+      def summary_diff_omits_content?
+        content_diff_object.summary_omits_content?
+      end
+
+      private
+
+      def diff_object field, opts
+        Card::Content::Diff.new previous_value(field), value(field), opts
+      end
+
+      def content_diff_object opts=nil
+        @diff ||= begin
+          diff_args = opts || card.include_set_modules.diff_args
+          previous_value = previous_value(:content)
+          previous = previous_value ? raw_view(previous_value) : ""
+          current = raw_view
+          Card::Content::Diff.new previous, current, diff_args
+        end
+      end
+    end
+  end
+end