card 1.99.4 → 1.99.5

data/tmpsets/set/{mod015-settings/right/read.rb → mod002-core/all/update_read_rules.rb}

@@ -1,30 +1,49 @@
 # -*- encoding : utf-8 -*-
-class Card; module Set; class Right
-# Set: All "+Read" cards
-#
-module Read;
-extend Card::Set
-def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/settings/set/right/read.rb"; end
-include Abstract::Permission
+class Card; module Set; class All; module UpdateReadRules; extend Card::Set
+# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/update_read_rules.rb ~~
 
-format :html do include Abstract::Permission::HtmlFormat end
+# FIXME: the following don't really belong here, but they have to come after
+# the reference stuff.  we need to organize a bit!
 
-event :cascade_read_rule, :finalize, after: :update_rule_cache,
-                                     when: :is_rule? do
-  return unless name_is_changing? || trash_is_changing?
+event :update_ruled_cards, :finalize do
+  if is_rule?
+    # warn "updating ruled cards for #{name}"
+    self.class.clear_rule_cache
+    set = rule_set
 
-  update_read_ruled_cards rule_set
+    if right_id == Card::ReadID && (name_changed? || trash_changed?)
+      update_read_ruled_cards set
+    end
+  end
 end
 
-def reset_patterns_if_rule saving=false
-  return unless (set = super)
-  add_to_read_rule_update_queue set.item_cards(limit: 0) if saving
+def update_read_rules_not_overridden_by_narrower_rules cur_index,
+                                                       rule_class_index, set
+  set.item_cards(limit: 0).each_with_object(::Set.new) do |item_card, in_set|
+    in_set << item_card.key
+    next if cur_index < rule_class_index
+    item_card.update_read_rule
+  end
 end
 
-# TODO: the following really needs a refactor.
-#
-# It was written (long ago) to handle different kinds of changes, but this
-# could be significantly simplified with smarter events.
+def update_read_rules_of_set_members set
+  return ::Set.new if trash || !(class_id = id_of_set_class(set))
+  rule_class_ids = set_patterns.map(&:pattern_id)
+  Auth.as_bot do
+    if (rule_class_index = rule_class_ids.index(class_id))
+      cur_index = rule_class_ids.index Card[read_rule_class].id
+      update_read_rules_not_overridden_by_narrower_rules cur_index,
+                                                         rule_class_index, set
+    else
+      warn "No current rule index #{class_id}, #{rule_class_ids.inspect}"
+      ::Set.new
+    end
+  end
+end
+
+def id_of_set_class set
+  set && (set_class = set.tag) && set_class.id
+end
 
 def update_read_ruled_cards set
   self.class.clear_read_rule_cache
@@ -38,41 +57,35 @@ def update_read_ruled_cards set
   # then find all cards with me as read_rule_id that were not just updated
   # and regenerate their read_rules
   return if new_card?
-
   Card.search(read_rule_id: id) do |card|
     card.update_read_rule unless updated.include?(card.key)
   end
 end
 
-def update_read_rules_not_overridden_by_narrower_rules cur_index,
-                                                       rule_class_index, set
-  set.item_cards(limit: 0).each_with_object(::Set.new) do |item_card, in_set|
-    in_set << item_card.key
-    next if cur_index < rule_class_index
-
-    item_card.update_read_rule
-  end
-end
-
 event :process_read_rule_update_queue, :finalize do
   Array.wrap(@read_rule_update_queue).each(&:update_read_rule)
   @read_rule_update_queue = []
 end
 
-def update_read_rules_of_set_members set
-  return ::Set.new if trash || !(class_id = id_of_set_class(set))
-
-  rule_class_ids = set_patterns.map(&:pattern_id)
-  Auth.as_bot do
-    if (rule_class_index = rule_class_ids.index(class_id))
-      cur_index = rule_class_ids.index Card[read_rule_class].id
-      update_read_rules_not_overridden_by_narrower_rules cur_index,
-                                                         rule_class_index, set
-    else
-      warn "No current rule index #{class_id}, #{rule_class_ids.inspect}"
-      ::Set.new
+event :expire_related, :finalize do
+  subcards.keys.each do |key|
+    Card.cache.soft.delete key
+  end
+  expire # FIXME: where do we put this. Here it deletes @stage
+  reset_patterns
+  if is_structure?
+    structuree_names.each do |name|
+      Card.expire name
     end
   end
 end
+
+event :expire_related_names, before: :expire_related, changed: :name do
+  # FIXME: look for opportunities to avoid instantiating the following
+  descendants.each(&:expire)
+  name_referers.each(&:expire)
+end
+
+
+# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/update_read_rules.rb ~~
 end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/settings/set/right/read.rb ~~

data/tmpsets/set/mod002-core/all/utils.rb

@@ -0,0 +1,62 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All; module Utils; extend Card::Set
+# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/utils.rb ~~
+module ClassMethods
+  def delete_tmp_files id=nil
+    dir = Cardio.paths["files"].existent.first + "/tmp"
+    dir += "/#{id}" if id
+    FileUtils.rm_rf dir, secure: true
+  rescue
+    Rails.logger.info "failed to remove tmp files"
+  end
+
+  def merge_list attribs, opts={}
+    unmerged = []
+    attribs.each do |row|
+      result = begin
+        merge row["name"], row, opts
+      end
+      unmerged.push row unless result == true
+    end
+
+    if unmerged.empty?
+      Rails.logger.info "successfully merged all!"
+    else
+      unmerged_json = JSON.pretty_generate unmerged
+      report_unmerged_json unmerged_json, opts[:output_file]
+    end
+    unmerged
+  end
+
+  def report_unmerged_json unmerged_json, output_file
+    if output_file
+      ::File.open output_file, "w" do |f|
+        f.write unmerged_json
+      end
+    else
+      Rails.logger.info "failed to merge:\n\n#{unmerged_json}"
+    end
+  end
+
+  def merge name, attribs={}, opts={}
+    puts "merging #{name}"
+    card = fetch name, new: {}
+    [:image, :file].each do |attach|
+      next unless attribs[attach] && attribs[attach].is_a?(String)
+      attribs[attach] = ::File.open(attribs[attach])
+    end
+    if opts[:pristine] && !card.pristine?
+      false
+    else
+      card.update_attributes! attribs
+    end
+  end
+
+  def seed_test_db
+    system "env RAILS_ENV=test bundle exec rake db:fixtures:load"
+  end
+end
+
+
+# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/utils.rb ~~
+end;end;end;end;

data/tmpsets/set/mod002-core/all/view_cache.rb

@@ -0,0 +1,16 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All; module ViewCache; extend Card::Set
+# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/view_cache.rb ~~
+event :clear_view_cache, :finalize do
+  Card::Cache::ViewCache.reset
+end
+
+format do
+  def view_caching?
+    false
+  end
+end
+
+
+# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/view_cache.rb ~~
+end;end;end;end;

data/tmpsets/set/mod003-history/all/actions.rb

@@ -0,0 +1,60 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All; module Actions; extend Card::Set
+# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/history/set/all/actions.rb ~~
+# -*- 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
+
+
+# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/history/set/all/actions.rb ~~
+end;end;end;end;

data/tmpsets/set/mod003-history/all/content_history.rb

@@ -0,0 +1,168 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All; module ContentHistory; extend Card::Set
+# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/history/set/all/content_history.rb ~~
+
+# 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
+
+
+# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/history/set/all/content_history.rb ~~
+end;end;end;end;

data/tmpsets/set/mod003-history/all/history.rb

@@ -0,0 +1,408 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All; module History; extend Card::Set
+# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/history/set/all/history.rb ~~
+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|
+    # rollback file and image cards
+    action.card.try :rollback_to, action
+  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
+
+
+# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/history/set/all/history.rb ~~
+end;end;end;end;