card 1.97.0.1 → 1.98.0

data/tmpsets/set/mod005-history/all/history/act_listing.rb

@@ -0,0 +1,133 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All; module History;
+# Set: All cards (History, ActListing)
+#
+module ActListing;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/history/set/all/history/act_listing.rb"; end
+ACTS_PER_PAGE = Card.config.acts_per_page
+
+module HtmlFormat; parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
+  def act_from_context
+    if (act_id = params["act_id"])
+      Act.find(act_id) || raise(Card::NotFound, "act not found")
+    else
+      card.last_action.act
+    end
+  end
+
+  # used (by history and recent)for rendering act lists with legend and paging
+  #
+  # @param acts [ActiveRecord::Relation] relation that will return acts objects
+  # @param context [Symbol] :relative or :absolute
+  # @param draft_legend [Symbol] :show or :hide
+  def acts_layout acts, context, draft_legend=:hide
+    bs_layout container: false, fluid: false do
+      html _render_act_legend(draft_legend => :draft_legend)
+      row(12) { act_list acts, context }
+      row(12) { act_paging acts, context }
+    end
+  end
+
+  def act_list acts, context
+    act_accordion acts, context do |act, seq|
+      fmt = context == :relative ? self : act.card.format(:html)
+      fmt.act_listing act, seq, context
+    end
+  end
+
+  def act_listing act, seq=nil, context=nil
+    opts = act_listing_opts_from_params(seq)
+    opts[:slot_class] = "revision-#{act.id} history-slot list-group-item"
+    context ||= (params[:act_context] || :absolute).to_sym
+    act_renderer(context).new(self, act, opts).render
+  end
+
+  # TODO: consider putting all these under one top-level param, eg:
+  # act: { seq: X, diff: [show/hide], action_view: Y }
+  def act_listing_opts_from_params seq
+    { act_seq: (seq || params["act_seq"]),
+      action_view: (params["action_view"] || "summary").to_sym,
+      hide_diff: params["hide_diff"].to_s.strip == "true" }
+  end
+
+  def act_accordion acts, context, &block
+    accordion_group acts_for_accordion(acts, context, &block), nil, class: "clear-both"
+  end
+
+  def acts_for_accordion acts, context
+    clean_acts(current_page_acts(acts)).map do |act|
+      with_act_seq(context, acts) do |seq|
+        yield act, seq
+      end
+    end
+  end
+
+  def with_act_seq context, acts
+    yield(context == :absolute ? nil : current_act_seq(acts))
+  end
+
+  def current_act_seq acts
+    @act_seq = @act_seq ? (@act_seq -= 1) : act_list_starting_seq(acts)
+  end
+
+  def clean_acts acts
+    # FIXME: if we get rid of bad act data, this will not be necessary
+    # The current
+    acts.select(&:card)
+  end
+
+  def current_page_acts acts
+    acts.page(acts_page_from_params).per acts_per_page
+  end
+
+  def act_list_starting_seq acts
+    acts.size - (acts_page_from_params - 1) * acts_per_page
+  end
+
+  def acts_per_page
+    @acts_per_page || ACTS_PER_PAGE
+  end
+
+  def acts_page_from_params
+    @acts_page_from_params ||= params["page"].present? ? params["page"].to_i : 1
+  end
+
+  def act_paging acts, context
+    wrap_with :span, class: "slotter" do
+      acts = current_page_acts acts
+      opts = { remote: true, theme: "twitter-bootstrap-4" }
+      opts[:total_pages] = 10 if limited_paging? context
+      paginate acts, opts
+    end
+  end
+
+  def limited_paging? context
+    context == :absolute && Act.count > 1000
+  end
+
+  def action_icon action_type, extra_class=nil
+    icon = case action_type
+           when :create then :add_circle
+           when :update then :pencil
+           when :delete then :remove_circle
+           when :draft then :wrench
+           end
+    icon_tag icon, extra_class
+  end
+
+  private
+
+  def act_renderer context
+    case context
+    when :absolute
+      Act::ActRenderer::AbsoluteActRenderer
+    when :bridge
+      Act::ActRenderer::BridgeActRenderer
+    else # relative
+      Act::ActRenderer::RelativeActRenderer
+    end
+  end
+end
+end;end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/history/set/all/history/act_listing.rb ~~

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

@@ -0,0 +1,133 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All; module History;
+# Set: All cards (History, Actions)
+#
+# -*- encoding : utf-8 -*-
+module Actions;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/history/set/all/history/actions.rb"; end
+
+def all_action_ids
+  Card::Action.where(card_id: id).pluck :id
+end
+
+def action_from_id action_id
+  return unless action_id.is_a?(Integer) || action_id =~ /^\d+$/
+
+  # if not an integer revision id is probably a mod (e.g. if you request
+  # files/:logo/standard.png)
+  action = Action.fetch action_id
+  return unless action.card_id == id
+
+  action
+end
+
+def old_actions
+  actions.where("id != ?", last_action_id)
+end
+
+def create_action
+  @create_action ||= actions.first
+end
+
+def nth_action index
+  index = index.to_i
+  return unless id && index.positive?
+
+  Action.where("draft is not true AND card_id = #{id}")
+        .order(:id).limit(1).offset(index - 1).first
+end
+
+def new_content_action_id
+  return unless @current_action && current_action_changes_content?
+
+  @current_action.id
+end
+
+def current_action_changes_content?
+  new_card? || @current_action.new_content? || db_content_is_changing?
+end
+
+module HtmlFormat; parent.send :register_set_format, Card::Format::HtmlFormat, self; extend Card::Set::AbstractFormat
+  def action_from_context
+    if (action_id = voo.action_id || params[:action_id])
+      Action.fetch action_id
+    else
+      card.last_action
+    end
+  end
+
+  def action_content action, view_type
+    return "" unless action.present?
+
+    wrap do
+      [action_content_toggle(action, view_type),
+       content_diff(action, view_type)]
+    end
+  end
+
+  def content_diff action, view_type
+    diff = action.new_content? && content_changes(action, view_type)
+    return "<i>empty</i>" unless diff.present?
+
+    diff
+  end
+
+  def action_content_toggle action, view_type
+    return unless show_action_content_toggle?(action, view_type)
+
+    toggle_action_content_link action, view_type
+  end
+
+  def show_action_content_toggle? action, view_type
+    view_type == :expanded || action.summary_diff_omits_content?
+  end
+
+  def toggle_action_content_link action, view_type
+    other_view_type = view_type == :expanded ? :summary : :expanded
+    css_class = "revision-#{action.card_act_id} float-right"
+    link_to_view "action_#{other_view_type}",
+                 icon_tag(action_arrow_dir(view_type), class: "md-24"),
+                 class: css_class,
+                 path: { action_id: action.id, look_in_trash: true }
+  end
+
+  def action_arrow_dir view_type
+    view_type == :expanded ? :triangle_left : :triangle_right
+  end
+
+  def revert_actions_link link_text, path_args, html_args={}
+    return unless card.ok? :update
+
+    path_args.reverse_merge! action: :update, look_in_trash: true, assign: true,
+                             card: { skip: :validate_renaming }
+    html_args.reverse_merge! remote: true, method: :post, rel: "nofollow", path: path_args
+    add_class html_args, "slotter"
+    link_to link_text, html_args
+  end
+
+  def action_legend
+    types = %i[create update delete]
+    legend = types.map do |action_type|
+      "#{action_icon(action_type)} #{action_type}d"
+    end
+    legend << _render_draft_legend if voo.show?(:draft_legend)
+    "<small>Actions: #{legend.join ' | '}</small>"
+  end
+
+  def content_legend
+    legend = [Card::Content::Diff.render_added_chunk("Additions"),
+              Card::Content::Diff.render_deleted_chunk("Subtractions")]
+    "<small>Content changes: #{legend.join ' | '}</small>"
+  end
+
+  def content_changes action, diff_type, hide_diff=false
+    if hide_diff
+      action.raw_view
+    else
+      action.content_diff diff_type
+    end
+  end
+end
+end;end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/history/set/all/history/actions.rb ~~

data/tmpsets/set/mod005-history/all/history/acts.rb

@@ -0,0 +1,21 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All; module History;
+# Set: All cards (History, Acts)
+#
+module Acts;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/history/set/all/history/acts.rb"; end
+def act_card?
+  self == Card::ActManager.act_card
+end
+
+# all acts with actions on self and on cards included in self (ie, acts shown in history)
+def history_acts
+  @history_acts ||= Act.all_with_actions_on(history_card_ids, true).order id: :desc
+end
+
+def draft_acts
+  drafts.created_by(Card::Auth.current_id).map(&:act)
+end
+end;end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/history/set/all/history/acts.rb ~~

data/tmpsets/set/mod005-history/all/history/events.rb

@@ -0,0 +1,108 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All; module History;
+# Set: All cards (History, Events)
+#
+# must be called on all actions and before :set_name, :process_subcards and
+module Events;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/history/set/all/history/events.rb"; end
+# :validate_delete_children
+event :assign_action, :initialize, when: :actionable? do
+  act = director.need_act
+  @current_action = Card::Action.create(
+    card_act_id: act.id,
+    action_type: @action,
+    draft: (Env.params["draft"] == "true")
+  )
+  if @supercard && @supercard != self
+    @current_action.super_action = @supercard.current_action
+  end
+end
+
+# can we store an action? (can be overridden, eg in files)
+def actionable?
+  history?
+end
+
+event :detect_conflict, :validate, on: :update, when: :edit_conflict? do
+  errors.add :conflict, tr(:error_not_latest_revision)
+end
+
+def edit_conflict?
+  last_action_id_before_edit &&
+    last_action_id_before_edit.to_i != last_action_id &&
+    (la = last_action) &&
+    la.act.actor_id != Auth.current_id
+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: :finalize_action? do
+  if changed_fields.present?
+    @current_action.update! card_id: id
+
+    # Note: #last_change_on uses the id to sort by date
+    # so the changes for the create changes have to be created before the first change
+    store_card_changes_for_create_action if first_change?
+    store_card_changes unless first_create?
+    # FIXME: a `@current_action.card` call here breaks specs in solid_cache_spec.rb
+  elsif @current_action.card_changes.reload.empty?
+    @current_action.delete
+    @current_action = nil
+  end
+end
+
+# changes for the create action are stored after the first update
+def store_card_changes_for_create_action
+  store_each_history_field create_action.id do |field|
+    attribute_before_act field
+  end
+end
+
+def store_card_changes
+  store_each_history_field @current_action.id, changed_fields do |field|
+    self[field]
+  end
+end
+
+def store_each_history_field action_id, fields=nil
+  fields ||= Card::Change::TRACKED_FIELDS
+  if false # Card::Change.supports_import?
+    # attach.feature fails with this
+    values = fields.map.with_index { |field, index| [index, yield(field), action_id] }
+    Card::Change.import [:field, :value, :card_action_id], values #, validate: false
+  else
+    fields.each do |field|
+      Card::Change.create field: field,
+                          value: yield(field),
+                          card_action_id: action_id
+    end
+  end
+end
+
+def finalize_action?
+  actionable? && current_action
+end
+
+event :rollback_actions, :prepare_to_validate, on: :update, when: :rollback_request? do
+  update_args = process_revert_actions
+  Env.params["revert_actions"] = nil
+  update! update_args
+  clear_drafts
+  abort :success
+end
+
+event :finalize_act, after: :finalize_action, when: :act_card? do
+  Card::ActManager.act.update! card_id: id
+end
+
+event :remove_empty_act, :integrate_with_delay_final, when: :remove_empty_act? do
+  # Card::ActManager.act.delete
+  # Card::ActManager.act = nil
+end
+
+def remove_empty_act?
+  act_card? && ActManager.act&.ar_actions&.reload&.empty?
+end
+end;end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/history/set/all/history/events.rb ~~

data/tmpsets/set/mod005-history/all/history/last.rb

@@ -0,0 +1,107 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All; module History;
+# Set: All cards (History, Last)
+#
+module Last;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/history/set/all/history/last.rb"; end
+def acted_at
+  last_act.acted_at
+end
+
+def revised_at
+  (last_action && (act = last_action.act) && act.acted_at) || Time.zone.now
+end
+
+def last_change_on field, opts={}
+  action_id = extract_action_id(opts[:before] || opts[:not_after])
+
+  # If there is only one action then there are no entries in the changes table,
+  # so we can't do a sql search but the changes are accessible via the action.
+  if no_last_change? action_id, opts[:before]
+    nil
+  elsif create_action_last_change? action_id
+    create_action.change field
+  else
+    last_change_from_action_id action_id, field, opts
+  end
+end
+
+def no_last_change? action_id, before
+  before && action_id == create_action.id
+end
+
+def create_action_last_change? action_id
+  action_id == create_action.id || (!action_id && create_action.sole?)
+end
+
+def last_change_from_action_id action_id, field, opts
+  Change.joins(:action).where(
+    last_change_sql_conditions(opts),
+    card_id: id,
+    action_id: action_id,
+    field: Card::Change.field_index(field)
+  ).order(:id).last
+end
+
+def last_change_sql_conditions opts
+  cond = "card_actions.card_id = :card_id AND field = :field"
+  cond += " AND (draft is not true)" unless opts[:including_drafts]
+  operator = "<" if opts[:before]
+  operator = "<=" if opts[:not_after]
+  cond += " AND card_action_id #{operator} :action_id" if operator
+  cond
+end
+
+def last_action_id
+  last_action&.id
+end
+
+def last_action
+  actions.where("id IS NOT NULL").last
+end
+
+def last_content_action
+  last_change_on(:db_content)&.action
+end
+
+def last_content_action_id
+  last_change_on(:db_content)&.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
+      act_of_last_action = action.act
+      return act_of_last_action unless last_act_on_self
+      return last_act_on_self unless act_of_last_action
+
+      return last_act_on_self if act_of_last_action == last_act_on_self
+
+      if last_act_on_self.acted_at > act_of_last_action.acted_at
+        last_act_on_self
+      else
+        act_of_last_action
+      end
+    end
+end
+
+def previous_action action_id
+  return unless action_id
+
+  action_index = actions.find_index { |a| a.id == action_id }
+  all_actions[action_index - 1] if action_index.to_i.nonzero?
+end
+
+private
+
+def extract_action_id action_arg
+  action_arg.is_a?(Card::Action) ? action_arg.id : action_arg
+end
+end;end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/history/set/all/history/last.rb ~~