card 1.18.6 → 1.19.0

data/mod/history/lib/card/action/admin.rb

@@ -0,0 +1,30 @@
+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} not associated with a
+      # {Change change}
+      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
+
+      # permanently delete all {Action actions} associate with non-current
+      # {Change changes}
+      def delete_old
+        Card.find_each(&:delete_old_actions)
+        Card::Act.delete_actionless
+      end
+    end
+  end
+end

data/mod/history/lib/card/action/differ.rb

@@ -0,0 +1,53 @@
+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
+
+      # @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
+
+      # @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
+
+      # 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
+
+      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
+          diff_object :content, diff_args
+        end
+      end
+    end
+  end
+end

data/mod/history/lib/card/change.rb

@@ -0,0 +1,68 @@
+# -*- encoding : utf-8 -*-
+class Card
+  # A _change_ is an alteration to a card's name, type, content, or trash state.
+  # 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
+  # card, that would be recorded as one {Action action} with two
+  # {Change changes}.
+  #
+  # A {Change} records:
+  #
+  # * the _field_ changed
+  # * the new _value_ of that field
+  # * the {Action action} of which the change is part
+  #
+  class Change < ActiveRecord::Base
+    belongs_to :action, foreign_key: :card_action_id,
+                        inverse_of: :card_changes
+
+    # lists the database fields for which changes are recorded
+    TRACKED_FIELDS = %w(name type_id db_content trash).freeze
+
+    class << self
+      # delete all {Change changes} not associated with an {Action action}
+      # (janitorial)
+      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
+
+      # Change fields are recorded as integers. #field_index looks up the
+      # integer associated with a given field name.
+      # @param value [String, Symbol]
+      # @return [Integer]
+      def field_index value
+        value.is_a?(Integer) ? value : TRACKED_FIELDS.index(value.to_s)
+      end
+
+      # look up changes based on field name
+      # @param value [String, Symbol]
+      # @return [Change]
+      def find_by_field_name value
+        find_by_field field_index(value)
+      end
+    end
+
+    # set field value (integer)
+    # @param value [String, Symbol]
+    def field= value
+      write_attribute(:field, TRACKED_FIELDS.index(value.to_s))
+    end
+
+    # retrieve field name
+    # @return [String]
+    def field
+      TRACKED_FIELDS[read_attribute(:field)]
+    end
+  end
+end

data/mod/history/set/all/actions.rb

@@ -0,0 +1,53 @@
+# -*- 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 args[:rev_id].is_a?(Integer) || 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/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
+  return unless action
+  Card::Change::TRACKED_FIELDS.each_with_object({}) do |field, attr_changes|
+    last_change = action.change(field) ||
+                  last_change_on(field, not_after: action)
+    attr_changes[field.to_sym] = (last_change ? last_change.value : self[field])
+  end
+end
+
+def delete_old_actions
+  Card::Change::TRACKED_FIELDS.each do |field|
+    # assign previous changes on each tracked field to the last action
+    next unless (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
+  actions.where("id != ?", last_action_id).delete_all
+end

data/mod/history/set/all/content_history.rb

@@ -0,0 +1,161 @@
+
+# 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

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

@@ -0,0 +1,400 @@
+ACTS_PER_PAGE = Card.config.acts_per_page
+
+def history?
+  true
+end
+
+# must be called on all actions and before :set_name, :process_subcards and
+# :validate_delete_children
+
+def actionable?
+  history? || respond_to?(:attachment)
+end
+
+event :assign_action, :initialize,
+      when: proc { |c| c.actionable? } do
+  @current_act = director.need_act
+  @current_action = Card::Action.create(
+    card_act_id: @current_act.id,
+    action_type: @action,
+    draft: (Env.params["draft"] == "true")
+  )
+  if @supercard && @supercard != self
+    @current_action.super_action = @supercard.current_action
+  end
+end
+
+def finalize_action?
+  actionable? && 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, :finalize,
+      when: proc { |c| c.finalize_action? } do
+  @changed_fields = Card::Change::TRACKED_FIELDS.select do |f|
+    changed_attributes.member? f
+  end
+  if @changed_fields.present?
+    # FIXME: should be one bulk insert
+    @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
+    @current_action = nil
+  end
+end
+
+event :finalize_act,
+      after: :finalize_action,
+      when: proc { |c|  c.act_card? } do
+  # removed subcards can leave behind actions without card id
+  if @current_act.actions(true).empty?
+    @current_act.delete
+    @current_act = nil
+  else
+    @current_act.update_attributes! card_id: id
+  end
+end
+
+def act_card?
+  self == DirectorRegister.act_card
+end
+
+event :rollback_actions, :prepare_to_validate,
+      on: :update,
+      when: proc { |c| c.rollback_request? } do
+  revision = { subcards: {} }
+  rollback_actions = Env.params["action_ids"].map do |a_id|
+    Action.fetch(a_id) || nil
+  end
+  rollback_actions.each do |action|
+    if action.card_id == id
+      revision.merge!(revision(action))
+    else
+      revision[:subcards][action.card.name] = revision(action)
+    end
+  end
+  Env.params["action_ids"] = nil
+  update_attributes! revision
+  rollback_actions.each do |action|
+    action.card.try :symlink_to, action.id
+  end
+  clear_drafts
+  abort :success
+end
+
+def rollback_request?
+  history? && Env && Env.params["action_ids"] &&
+    Env.params["action_ids"].class == Array
+end
+
+# all acts with actions on self and on cards that are descendants of self and
+# included in self
+def intrusive_family_acts args={}
+  @intrusive_family_acts ||= begin
+    Act.find_all_with_actions_on((included_descendant_card_ids << id), args)
+  end
+end
+
+# all acts with actions on self and on cards included in self
+def intrusive_acts args={ with_drafts: true }
+  @intrusive_acts ||= begin
+    Act.find_all_with_actions_on((included_card_ids << id), args)
+  end
+end
+
+def current_rev_nr
+  @current_rev_nr ||= begin
+    if intrusive_acts.first.actions.last.draft
+      @intrusive_acts.size - 1
+    else
+      @intrusive_acts.size
+    end
+  end
+end
+
+def included_card_ids
+  @included_card_ids ||=
+    Card::Reference.select(:referee_id).where(
+      ref_type: "I", referer_id: id
+    ).pluck("referee_id").compact.uniq
+end
+
+def descendant_card_ids parent_ids=[id]
+  more_ids = Card.where("left_id IN (?)", parent_ids).pluck("id")
+  more_ids += descendant_card_ids more_ids unless more_ids.empty?
+  more_ids
+end
+
+def included_descendant_card_ids
+  included_card_ids & descendant_card_ids
+end
+
+format :html do
+  view :history do |args|
+    frame args.merge(body_class: "history-slot list-group", content: true) do
+      [history_legend, _render_act_list]
+    end
+  end
+
+  def default_history_args args
+    args[:optional_toolbar] ||= :show
+  end
+
+  view :act_list do |args|
+    page = params["page"] || 1
+    count = card.intrusive_acts.size + 1 - (page.to_i - 1) * ACTS_PER_PAGE
+    card.intrusive_acts.page(page).per(ACTS_PER_PAGE).map do |act|
+      count -= 1
+      render_act args.merge(act: act, act_seq: count)
+    end.join
+  end
+
+  def history_legend
+    intr = card.intrusive_acts.page(params["page"]).per(ACTS_PER_PAGE)
+    render_haml intr: intr do
+      <<-HAML.strip_heredoc
+        .history-header
+          %span.slotter
+            = paginate intr, remote: true, theme: 'twitter-bootstrap-3'
+          %div.history-legend
+            %span.glyphicon.glyphicon-plus-sign.diff-green
+            %span
+              = Card::Content::Diff.render_added_chunk('Added')
+              |
+            %span.glyphicon.glyphicon-minus-sign.diff-red
+            %span
+              = Card::Content::Diff.render_deleted_chunk('Deleted')
+      HAML
+    end
+  end
+
+  def default_act_args args
+    act = (args[:act]  ||= Act.find(params["act_id"]))
+    args[:act_seq]     ||= params["act_seq"]
+    args[:hide_diff]   ||= hide_diff?
+    args[:slot_class]  ||= "revision-#{act.id} history-slot list-group-item"
+    args[:action_view] ||= action_view
+    args[:actions]     ||= action_list args
+  end
+
+  def action_list args
+    act = args[:act]
+    actions =
+      if act_context(args) == :absolute
+        act.actions
+      else
+        act.actions_affecting(card)
+      end
+    actions.select { |a| a.card && a.card.ok?(:read) }
+    # FIXME: should not need to test for presence of card here.
+  end
+
+  def act_context args
+    args[:act_context] =
+      (args[:act_context] || params["act_context"] || :relative).to_sym
+  end
+
+  def hide_diff?
+    params["hide_diff"].to_s.strip == "true"
+  end
+
+  def action_view
+    (params["action_view"] || "summary").to_sym
+  end
+
+  view :act do |args|
+    wrap(args) do
+      render_haml args.merge(card: card, args: args) do
+        <<-HAML.strip_heredoc
+          .act{style: "clear:both;"}
+            - show_header = act_context == :absolute ? :show : :hide
+            = optional_render :act_header, args, show_header
+            .head
+              = render :act_metadata, args
+            .toggle
+              = fold_or_unfold_link args
+            .action-container
+              - actions.each do |action|
+                = render "action_#{args[:action_view]}", args.merge(action: action)
+        HAML
+      end
+    end
+  end
+
+  view :act_header do |_args|
+    %(<h5 "class=act-header">#{card_link card}</h5>)
+  end
+
+  view :act_metadata do |args|
+    render_haml args.merge(card: card, args: args) do
+      <<-HAML.strip_heredoc
+        - unless act_context == :absolute
+          .nr
+            = '#' + act_seq.to_s
+        .title
+          .actor
+            = link_to act.actor.name, card_url(act.actor.cardname.url_key)
+          .time.timeago
+            = time_ago_in_words(act.acted_at)
+            ago
+            - if act.id == card.last_act.id
+              %em.label.label-info Current
+            - if action_view == :expanded
+              - unless act.id == card.last_act.id
+                = rollback_link act.actions_affecting(card)
+              = show_or_hide_changes_link args
+      HAML
+    end
+  end
+
+  view :action_summary do |args|
+    view_action :summary, args
+  end
+
+  view :action_expanded do |args|
+    view_action :expanded, args
+  end
+
+  def view_action action_view, args
+    action = args[:action] || card.last_action
+    hide_diff = args[:hide_diff] || hide_diff?
+
+    render_haml action: action,
+                action_view: action_view,
+                name_diff: name_diff(action, hide_diff),
+                type_diff: type_diff(action, hide_diff),
+                content_diff: content_diff(action, action_view, hide_diff) do
+      <<-HAML.strip_heredoc
+        .action
+          .summary
+            %span.ampel
+              = glyphicon 'minus-sign', (action.red? ? 'diff-red' : 'diff-invisible')
+              = glyphicon 'plus-sign', (action.green? ? 'diff-green' : 'diff-invisible')
+            = wrap_diff :name, name_diff
+            = wrap_diff :type, type_diff
+            -if content_diff
+              = glyphicon 'arrow-right', 'arrow'
+              -if action_view == :summary
+                = wrap_diff :content, content_diff
+          -if content_diff and action_view == :expanded
+            .expanded
+              = wrap_diff :content, content_diff
+      HAML
+    end
+  end
+
+  def name_diff action, hide_diff
+    if action.card == card
+      name_changes(action, hide_diff)
+    else
+      link_path = path(
+        view: :related,
+        related: { view: "history", name: action.card.name }
+      )
+      link_to name_changes(action, hide_diff), link_path,
+              class: "slotter label label-default",
+              "data-slot-selector" => ".card-slot.history-view",
+              remote: true
+    end
+  end
+
+  def type_diff action, hide_diff
+    action.new_type? && type_changes(action, hide_diff)
+  end
+
+  def content_diff action, action_view, hide_diff
+    action.new_content? && action.card.format.render_content_changes(
+      action: action, diff_type: action_view, hide_diff: hide_diff
+    )
+  end
+
+  def wrap_diff field, content
+    return "" unless content.present?
+    %(
+       <span class="#{field}-diff">
+       #{content}
+       </span>
+    )
+  end
+
+  def name_changes action, hide_diff=false
+    old_name = (name = action.previous_value :name) && showname(name).to_s
+    if action.new_name?
+      new_name = showname(action.value(:name)).to_s
+      if hide_diff
+        new_name
+      else
+        Card::Content::Diff.complete(old_name, new_name)
+      end
+    else
+      old_name
+    end
+  end
+
+  def type_changes action, hide_diff=false
+    change = hide_diff ? action.value(:cardtype) : action.cardtype_diff
+    "(#{change})"
+  end
+
+  view :content_changes do |args|
+    if args[:hide_diff]
+      args[:action].value :db_content
+    else
+      args[:action].content_diff(args[:diff_type])
+    end
+  end
+
+  def fold_or_unfold_link args
+    path_opts = {
+      act_id:      args[:act].id,
+      act_seq:     args[:act_seq],
+      hide_diff:   args[:hide_diff],
+      act_context: args[:act_context],
+      action_view: (args[:action_view] == :expanded ? :summary : :expanded)
+    }
+    arrow_dir = args[:action_view] == :expanded ? "arrow-down" : "arrow-right"
+    view_link "", :act, path_opts: path_opts,
+                        class: "slotter revision-#{args[:act_id]} #{arrow_dir}"
+  end
+
+  def rollback_link actions
+    not_current =
+      actions.select { |action| action.card.last_action_id != action.id }
+    return unless card.ok?(:update) && not_current.present?
+    link_path = path action: :update, view: :open, action_ids: not_current
+    link = link_to(
+      "Save as current", link_path,
+      class: "slotter", "data-slot-selector" => ".card-slot.history-view",
+      remote: true, method: :post, rel: "nofollow"
+    )
+    %(<div class="act-link">#{link}</div>)
+  end
+
+  def show_or_hide_changes_link args
+    toggle = args[:hide_diff] ? "Show" : "Hide"
+    path_opts = {
+      act_id: args[:act].id,
+      act_seq: args[:act_seq],
+      hide_diff: !args[:hide_diff],
+      action_view: :expanded,
+      act_context: args[:act_context]
+    }
+    link = view_link("#{toggle} changes", :act,
+                     path_opts: path_opts, class: "slotter", remote: true)
+    %(<div class="act-link">#{link}</div>)
+  end
+end
+
+def diff_args
+  { format: :text }
+end
+
+def has_edits?
+  Card::Act.where(actor_id: id).where("card_id IS NOT NULL").present?
+end