card 1.99.6 → 1.100.0

data/tmpsets/set/mod003-core/all/update_read_rules.rb

@@ -0,0 +1,21 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All
+# Set: All cards (UpdateReadRules)
+#
+module UpdateReadRules;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/update_read_rules.rb"; 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 :update_rule_cache, :finalize, when: :is_rule? do
+  Card::Rule.clear_rule_cache
+end
+
+event :expire_related, :finalize do
+  reset_patterns
+  structuree_names.each { |name| ActManager.expirees << name } if is_structure?
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/update_read_rules.rb ~~

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

@@ -0,0 +1,93 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All
+# Set: All cards (Utils)
+#
+module Utils;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/utils.rb"; end
+module ClassMethods
+  def merge_list attribs, opts={}
+    unmerged = []
+    attribs.each do |row|
+      if merge row["name"], row, opts
+        Rails.logger.info "merged #{row['name']}"
+      else
+        unmerged.push row
+      end
+    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: {}
+    return unless mergeable? card, opts[:pristine]
+
+    resolve_file_attributes! attribs
+    card.safe_update! attribs
+  end
+
+  private
+
+  def resolve_file_attributes! attribs
+    %i[image file].each do |attach|
+      next unless attribs[attach] && attribs[attach].is_a?(String)
+
+      attribs[attach] = ::File.open(attribs[attach])
+    end
+  end
+
+  def mergeable? card, pristine_only
+    return true unless pristine_only
+
+    !card.pristine?
+  end
+end
+
+# separate name and other attributes
+def safe_update! attribs
+  separate_name_update! attribs.delete("name") unless new?
+  update! attribs if attribs.present?
+end
+
+def separate_name_update! new_name
+  return if new_name.to_s == name.to_s
+
+  update! name: new_name
+end
+
+# rubocop:disable Style/GlobalVars
+def measure desc
+  $times ||= {}
+  res = nil
+  t = Benchmark.measure do
+    res = yield
+  end
+  $times[desc] = $times.key?(desc) ? t + $times[desc] : t
+  puts "#{desc}: #{t}".red
+  res
+end
+# rubocop:enable Style/GlobalVars
+
+module Format; parent.send :register_set_format, Card::Format, self; extend Card::Set::AbstractFormat
+  delegate :measure, to: :card
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/utils.rb ~~

data/tmpsets/set/mod004-virtual/abstract/virtual_cache.rb

@@ -0,0 +1,52 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class Abstract
+# Set: Abstract (VirtualCache)
+#
+# -*- encoding : utf-8 -*-
+module VirtualCache;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/virtual/set/abstract/virtual_cache.rb"; end
+
+def virtual?
+  new?
+end
+
+def history?
+  false
+end
+
+def followable?
+  false
+end
+
+def db_content
+  Card::Virtual.fetch_content(self)
+end
+
+# called to refresh the virtual content
+# the default way is to use the card's template content
+def generate_virtual_content
+  template&.db_content
+end
+
+event :save_virtual_content, :prepare_to_store, on: :save, changed: :content do
+  Card::Virtual.create_or_update(self, attributes["db_content"])
+  abort :success
+end
+
+event :delete_virtual_content, :prepare_to_store, on: :delete do
+  Card::Virtual.find_by_card(self)&.delete
+  abort :success
+end
+
+def delete
+  # delete although it's new
+  update trash: true
+end
+
+def delete!
+  # delete although it's new
+  update! trash: true
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/virtual/set/abstract/virtual_cache.rb ~~

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

@@ -0,0 +1,118 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All
+# Set: All cards (History)
+#
+module History;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/history/set/all/history.rb"; end
+event :update_ancestor_timestamps, :integrate do
+  ids = history_ancestor_ids
+  return unless ids.present?
+  Card.where(id: ids).update_all(updater_id: Auth.current_id, updated_at: Time.now)
+  ids.map { |anc_id| Card.expire anc_id.cardname }
+end
+
+# track history (acts, actions, changes) on this card
+def history?
+  true
+end
+
+# all cards whose acts are considered part of this card's history
+def history_card_ids
+  nestee_ids << id
+end
+
+# all cards who are considered updated if this card's was updated
+def history_parent_ids
+  nester_ids
+end
+
+def history_ancestor_ids recursion_level=0
+  return [] if recursion_level > 5
+
+  ids = history_parent_ids +
+    history_parent_ids.map { |id| Card[id].history_ancestor_ids(recursion_level + 1) }
+  ids.flatten
+end
+
+# ~~FIXME~~: optimize (no need to instantiate all actions and changes!)
+# Nothing is instantiated here. ActiveRecord is much smarter than you think.
+# Methods like #empty? and #size make sql queries if their receivers are not already
+# loaded -pk
+def first_change?
+  # = update or delete
+  @current_action.action_type != :create && action_count == 2 &&
+    create_action.card_changes.empty?
+end
+
+def first_create?
+  @current_action.action_type == :create && action_count == 1
+end
+
+def action_count
+  Card::Action.where(card_id: @current_action.card_id).count
+end
+
+# card has account that is responsible for prior acts
+def has_edits?
+  Card::Act.where(actor_id: id).where("card_id IS NOT NULL").present?
+end
+
+def changed_fields
+  Card::Change::TRACKED_FIELDS & (changed_attribute_names_to_save | saved_changes.keys)
+end
+
+def nestee_ids
+  requiring_id { @nestee_ids ||= nesting_ids(:referee_id, :referer_id) }
+end
+
+def nester_ids
+  requiring_id { @nester_ids ||= nesting_ids(:referer_id, :referee_id) }
+end
+
+def diff_args
+  { diff_format: :text }
+end
+
+# Delete all changes and old actions and make the last action the create action
+# (that way the changes for that action will be created with the first update)
+def make_last_action_the_initial_action
+  delete_all_changes
+  old_actions.delete_all
+  last_action.update! action_type: :create
+end
+
+def clear_history
+  delete_all_changes
+  delete_old_actions
+end
+
+def delete_old_actions
+  old_actions.delete_all
+end
+
+def delete_all_changes
+  Card::Change.where(card_action_id: all_action_ids).delete_all
+end
+
+def save_content_draft content
+  super
+  acts.create do |act|
+    act.ar_actions.build(draft: true, card_id: id, action_type: :update)
+       .card_changes.build(field: :db_content, value: content)
+  end
+end
+
+private
+
+def nesting_ids return_field, where_field
+  Card::Reference.select(return_field).distinct.where(
+    ref_type: "I", where_field => id
+  ).pluck(return_field).compact
+end
+
+def requiring_id
+  id ? yield : (return [])
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/history/set/all/history.rb ~~

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 :div, class: "slotter btn-sm" 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 ~~