card 1.102.0 → 1.103.3

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

@@ -1,136 +0,0 @@
-# -*- 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/ezl5238/dev/decko/gem/mod/history/set/all/history/act_listing.rb"; end
-module HtmlFormat; module_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 ||= Card.config.acts_per_page || 10
-  end
-
-  def acts_page_from_params
-    @acts_page_from_params ||= params["page"].present? ? params["page"].to_i : 1
-  end
-
-  def act_paging acts, context
-    return unless controller.request # paginate requires a request
-
-    wrap_with :div, class: "slotter btn-sm" do
-      paginate current_page_acts(acts), act_paging_opts(context)
-    end
-  end
-
-  def act_paging_opts context
-    { remote: true, theme: "twitter-bootstrap-4" }.tap do |opts|
-      opts[:total_pages] = 10 if limited_paging? context
-    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/ezl5238/dev/decko/gem/mod/history/set/all/history/act_listing.rb ~~

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

@@ -1,137 +0,0 @@
-# -*- 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/ezl5238/dev/decko/gem/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, action_id is probably a mod (e.g. if you request
-  # files/:logo/standard.png)
-
-  action_if_on_self Action.fetch(action_id)
-end
-
-def action_if_on_self action
-  return unless action.is_a? Action
-
-  action if action.card_id == id
-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; module_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/ezl5238/dev/decko/gem/mod/history/set/all/history/actions.rb ~~

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

@@ -1,17 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class All; module History;
-# Set: All cards (History, Acts)
-#
-# all acts with actions on self and on cards included in self (ie, acts shown in history)
-module Acts;
-extend Card::Set
-def self.source_location; "/Users/ezl5238/dev/decko/gem/mod/history/set/all/history/acts.rb"; end
-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/ezl5238/dev/decko/gem/mod/history/set/all/history/acts.rb ~~

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

@@ -1,109 +0,0 @@
-# -*- 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/ezl5238/dev/decko/gem/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, Cardio.t(:history_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
-  Card::Action.cache.delete "#{create_action.id}-changes"
-  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 %i[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::Director.act.update! card_id: id
-end
-
-event :remove_empty_act, :integrate_with_delay_final, when: :remove_empty_act? do
-  # Card::Director.act.delete
-  # Card::Director.act = nil
-end
-
-def remove_empty_act?
-  act_card? && Director.act&.ar_actions&.reload&.empty?
-end
-end;end;end;end;end;
-# ~~ generated from /Users/ezl5238/dev/decko/gem/mod/history/set/all/history/events.rb ~~

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

@@ -1,107 +0,0 @@
-# -*- 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/ezl5238/dev/decko/gem/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/ezl5238/dev/decko/gem/mod/history/set/all/history/last.rb ~~

data/tmpsets/set/mod012-history/all/history/revision.rb

@@ -1,74 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class All; module History;
-# Set: All cards (History, Revision)
-#
-module Revision;
-extend Card::Set
-def self.source_location; "/Users/ezl5238/dev/decko/gem/mod/history/set/all/history/revision.rb"; end
-def revision action, before_action=false
-  # 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
-
-  if before_action
-    revision_before_action action
-  else
-    revision_attributes action
-  end
-end
-
-def revision_attributes 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 revision_before_action action
-  if (prev_action = action.previous_action)
-    revision prev_action
-  else
-    { trash: true }
-  end
-end
-
-def rollback_request?
-  history? && actions_to_revert.any?
-end
-
-def process_revert_actions revert_actions=nil
-  revert_actions ||= actions_to_revert
-  update_args = { subcards: {} }
-  reverting_to_previous = Env.params["revert_to"] == "previous"
-  revert_actions.each do |action|
-    merge_revert_action! action, update_args, reverting_to_previous
-  end
-  update_args
-end
-
-def actions_to_revert
-  if (act_id = Env.params["revert_act"])
-    Act.find(act_id).actions
-  else
-    explicit_actions_to_revert
-  end
-end
-
-def explicit_actions_to_revert
-  Array.wrap(Env.params["revert_actions"]).map do |a_id|
-    Action.fetch(a_id) || nil
-  end.compact
-end
-
-def merge_revert_action! action, update_args, reverting_to_previous
-  rev = action.card.revision(action, reverting_to_previous)
-  rev.delete :name unless rev[:name] # handles null name field in compound cards
-  if action.card_id == id
-    update_args.merge! rev
-  else
-    update_args[:subcards][action.card.name] = rev
-  end
-end
-end;end;end;end;end;
-# ~~ generated from /Users/ezl5238/dev/decko/gem/mod/history/set/all/history/revision.rb ~~

data/tmpsets/set/mod012-history/all/history/selected.rb

@@ -1,73 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class All; module History;
-# Set: All cards (History, Selected)
-#
-# if these aren't in a nested module, the methods just overwrite the base
-#  methods, but we need a distinct module so that super will be able to refer to
-module Selected;
-extend Card::Set
-def self.source_location; "/Users/ezl5238/dev/decko/gem/mod/history/set/all/history/selected.rb"; end
-# the base methods.
-def content
-  @selected_action_id ? selected_content : super
-end
-
-def content= value
-  @selected_content = nil
-  super
-end
-
-def select_action_by_params params
-  action = nth_action(params[:rev]) || action_from_id(params[:rev_id])
-  return unless action
-
-  select_action action.id
-end
-
-def select_action action_id
-  run_callbacks :select_action do
-    self.selected_action_id = action_id
-  end
-end
-
-def selected_action_id
-  @selected_action_id || @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 selected_content
-  @selected_content ||= content_at_time_of_selected_action || db_content
-end
-
-def content_at_time_of_selected_action
-  last_change_on(:db_content, not_after: selected_action_id,
-                              including_drafts: true)&.value
-end
-
-def with_selected_action_id action_id
-  current_action_id = @selected_action_id
-  select_action_id action_id
-  result = yield
-  select_action_id current_action_id
-  result
-end
-
-def select_action_id action_id
-  run_callbacks :select_action do
-    self.selected_action_id = action_id
-  end
-end
-
-def selected_content_action_id
-  @selected_action_id || new_content_action_id || last_content_action_id
-end
-end;end;end;end;end;
-# ~~ generated from /Users/ezl5238/dev/decko/gem/mod/history/set/all/history/selected.rb ~~