card 1.102.0 → 1.103.0

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

@@ -1,78 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class All
-# Set: All cards (ReferenceEvents)
-#
-# test for updating referer content
-module ReferenceEvents;
-extend Card::Set
-def self.source_location; "/Users/ezl5238/dev/decko/gem/card/mod/core/set/all/reference_events.rb"; end
-event :prepare_referer_update, :validate, on: :update, changed: :name do
-  self.update_referers = ![nil, false, "false"].member?(update_referers)
-end
-
-# on rename, update names in cards that refer to self by name (as directed)
-event :update_referer_content, :finalize, on: :update, when: :update_referers do
-  referers.each do |card|
-    next if card.structure
-
-    card.skip_event! :validate_renaming, :check_permissions
-    card.content = card.replace_references name_before_act, name
-    attach_subcard card
-  end
-end
-
-# on rename, when NOT updating referer content, update references to ensure
-# that partial references are correctly tracked
-# eg.  A links to X+Y.  if X+Y is renamed and we're not updating the link in A,
-# then we need to be sure that A has a partial reference
-event :update_referer_references_out, :finalize,
-      changed: :name, on: :update, when: :not_update_referers do
-  referers.map(&:update_references_out)
-end
-
-# when name changes, update references to card
-event :refresh_references_in, :finalize, changed: :name, on: :save do
-  Reference.unmap_referees id if action == :update && !update_referers
-  Reference.map_referees key, id
-end
-
-# when content changes, update references to other cards
-event :refresh_references_out, :finalize, on: :save, changed: :content do
-  update_references_out
-end
-
-# clean up reference table when card is deleted
-event :clear_references, :finalize, on: :delete do
-  delete_references_out
-  Reference.unmap_referees id
-end
-
-# replace references in card content
-def replace_references old_name, new_name
-  cont = content_object
-  cont.find_chunks(:Reference).each do |chunk|
-    next unless replace_reference chunk, old_name, new_name
-  end
-  cont.to_s
-end
-
-protected
-
-def not_update_referers
-  !update_referers
-end
-
-private
-
-def replace_reference chunk, old_name, new_name
-  return unless (old = chunk.referee_name) && (new = old.swap old_name, new_name)
-
-  chunk.referee_name = chunk.replace_reference old_name, new_name
-  update_reference old.key, new.key
-end
-
-def update_reference old_key, new_key
-  Reference.where(referee_key: old_key).update_all referee_key: new_key
-end
-end;end;end;end;
-# ~~ generated from /Users/ezl5238/dev/decko/gem/card/mod/core/set/all/reference_events.rb ~~

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

@@ -1,93 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class All
-# Set: All cards (States)
-#
-# All cards have one (and only one) of these three states: real, virtual, and unknown.
-#
-# - *real* cards are stored in the database (but not in the trash) and have a unique id.
-# - *virtual* cards are not real, but they act real based on rules. For example,
-#   Home+*editors does a search for all the users who have edited the "Home" card.
-#   There are many other similar cards that search for things like references, children,
-#   etc. But we don't store all these cards in the database; we generate them dynamically
-module States;
-extend Card::Set
-def self.source_location; "/Users/ezl5238/dev/decko/gem/card/mod/core/set/all/states.rb"; end
-#   based on the names.
-# - *unknown* cards are everything else.
-#
-# These states are frequently grouped as follows:
-#
-# - *known* cards are either _real_ or _virtual_
-# - *new* (or *unreal*) cards are either _unknown_ or _virtual_
-
-module ClassMethods
-  def real? mark
-    quick_fetch(mark).present?
-  end
-  alias_method :exist?, :real?
-  alias_method :exists?, :real?
-
-  def known? mark
-    fetch(mark).present?
-  end
-end
-
-# @return [Symbol] :real, :virtual, or :unknown
-def state anti_fishing=true
-  case
-  when !known?                     then :unknown
-  when anti_fishing && !ok?(:read) then :unknown
-  when real?                       then :real
-  when virtual?                    then :virtual
-  else :wtf
-  end
-end
-
-# @return [True/False]
-def real?
-  !unreal?
-end
-
-# Virtual cards are structured, compound cards that are not stored in the database. You
-# can create virtual cards with structure rules.
-#
-# Some cards with hard-coded content will also override the #virtual? method. This
-# is established practice, but it is NOT advisable to override any of the other
-# state methods.
-#
-# @return [True/False]
-def virtual?
-  if @virtual.nil?
-    @virtual = real? || name.simple? ? false : structure.present?
-  end
-  @virtual
-end
-
-# @return [True/False]
-def unknown?
-  !known?
-end
-
-# @return [True/False]
-def known?
-  real? || virtual?
-end
-
-# @return [True/False]
-def new?
-  new_record? ||       # not yet in db (from ActiveRecord)
-    !@from_trash.nil?  # in process of restoration from trash
-end
-alias_method :new_card?, :new?
-alias_method :unreal?, :new?
-
-# has not been edited directly by human users.  bleep blorp.
-def pristine?
-  new_card? || !user_changes?
-end
-
-def user_changes?
-  actions.joins(:act).where("card_acts.actor_id != ?", WagnBotID).exists?
-end
-end;end;end;end;
-# ~~ generated from /Users/ezl5238/dev/decko/gem/card/mod/core/set/all/states.rb ~~

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

@@ -1,29 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class All
-# Set: All cards (Subcards)
-#
-module Subcards;
-extend Card::Set
-def self.source_location; "/Users/ezl5238/dev/decko/gem/card/mod/core/set/all/subcards.rb"; end
-event :reject_empty_subcards, :prepare_to_validate do
-  subcards.each_with_key do |subcard, key|
-    next unless subcard.new? && subcard.unfilled?
-
-    remove_subcard(key)
-    director.subdirectors.delete(subcard)
-  end
-end
-
-# check when deleting field that left has not also been deleted
-def trashed_left?
-  l = left
-  !l || l.trash
-end
-
-# check when renaming field that it is not actually the same field
-# (eg on a renamed trunk)
-def same_field?
-  (left_id == left_id_before_act) && (right_id == right_id_before_act)
-end
-end;end;end;end;
-# ~~ generated from /Users/ezl5238/dev/decko/gem/card/mod/core/set/all/subcards.rb ~~

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

@@ -1,142 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class All
-# Set: All cards (Trash)
-#
-module Trash;
-extend Card::Set
-def self.source_location; "/Users/ezl5238/dev/decko/gem/card/mod/core/set/all/trash.rb"; end
-Self::Admin.add_to_basket(
-  :tasks,
-  name: :empty_trash,
-  irreversible: true,
-  execute_policy: -> { Card.empty_trash },
-  stats: {
-    title: "trashed cards",
-    count: -> { Card.where(trash: true) },
-    link_text: "empty trash",
-    task: "empty_trash"
-  }
-)
-
-module ClassMethods
-  def empty_trash
-    Card.delete_trashed_files
-    Card.where(trash: true).in_batches.update_all(left_id: nil, right_id: nil)
-    Card.where(trash: true).in_batches.delete_all
-    Card::Action.delete_cardless
-    Card::Change.delete_actionless
-    Card::Act.delete_actionless
-    Card::Reference.unmap_if_referee_missing
-    Card::Reference.delete_if_referer_missing
-  end
-
-  # deletes any file not associated with a real card.
-  def delete_trashed_files
-    dir = Cardio.paths["files"].existent.first
-    # TODO: handle cloud files
-    return unless dir
-
-    (all_trashed_card_ids & all_file_ids).each do |file_id|
-      delete_files_with_id dir, file_id
-    end
-  end
-
-  def delete_files_with_id dir, file_id
-    raise Card::Error, t(:core_exception_almost_deleted) if Card.exists?(file_id)
-
-    ::FileUtils.rm_rf "#{dir}/#{file_id}", secure: true
-  end
-
-  def all_file_ids
-    dir = Card.paths["files"].existent.first
-    Dir.entries(dir)[2..-1].map(&:to_i)
-  end
-
-  def all_trashed_card_ids
-    trashed_card_sql = %( select id from cards where trash is true )
-    sql_results = Card.connection.select_all(trashed_card_sql)
-    sql_results.map(&:values).flatten.map(&:to_i)
-  end
-end
-
-def trash?
-  trash
-end
-
-def delete args={}
-  add_to_trash args do |delete_args|
-    update delete_args
-  end
-end
-
-def delete! args={}
-  add_to_trash args do |delete_args|
-    update! delete_args
-  end
-end
-
-def add_to_trash args
-  return if new_card?
-
-  yield args.merge trash: true
-end
-
-event :manage_trash, :prepare_to_store, on: :create do
-  pull_from_trash!
-  self.trash = false
-  true
-end
-
-def pull_from_trash!
-  return unless (id = Card::Lexicon.id key) # name is already known
-  return unless (trashed_card = Card.where(id: id).take)&.trash
-
-  # confirm name is actually in trash
-
-  db_attributes["id"] = trashed_card.db_attributes["id"]
-  # id_in_database returns existing card id
-
-  @from_trash = true
-  @new_record = false
-end
-
-def db_attributes
-  send(:mutations_from_database).send :attributes
-end
-
-event :validate_delete, :validate, on: :delete do
-  unless codename.blank?
-    errors.add :delete, t(:core_error_system_card, name: name, codename: codename)
-  end
-
-  undeletable_all_rules_tags =
-    %w[default style layout create read update delete]
-  # FIXME: HACK! should be configured in the rule
-
-  if compound? && left&.codename == :all &&
-     undeletable_all_rules_tags.member?(right.codename.to_s)
-    errors.add :delete, t(:core_error_indestructible, name: name)
-  end
-
-  errors.add :delete, t(:core_error_user_edits, name: name) if account && has_edits?
-end
-
-event :validate_delete_children, after: :validate_delete, on: :delete do
-  return if errors.any?
-
-  each_child do |child|
-    child.include_set_modules
-    delete_as_subcard child
-    # next if child.valid?
-    # child.errors.each do |field, message|
-    #   errors.add field, "can't delete #{child.name}: #{message}"
-    # end
-  end
-end
-
-def delete_as_subcard subcard
-  subcard.trash = true
-  add_subcard subcard
-end
-end;end;end;end;
-# ~~ generated from /Users/ezl5238/dev/decko/gem/card/mod/core/set/all/trash.rb ~~

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

@@ -1,70 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class All
-# Set: All cards (Type)
-#
-module Type;
-extend Card::Set
-def self.source_location; "/Users/ezl5238/dev/decko/gem/card/mod/core/set/all/type.rb"; end
-module ClassMethods
-  def default_type_id
-    @@default_type_id ||= Card[:all].fetch(:default, skip_modules: true).type_id
-  end
-end
-
-def type_card
-  return if type_id.nil?
-
-  Card.quick_fetch type_id.to_i
-end
-
-def type_code
-  Card::Codename[type_id.to_i]
-end
-
-def type_name
-  type_card.try :name
-end
-
-alias_method :type, :type_name
-
-def type_name_or_default
-  type_card.try(:name) || Card.quick_fetch(Card.default_type_id).name
-end
-
-def type_cardname
-  type_card.try :name
-end
-
-def type= type_name
-  self.type_id = type_name.card_id
-end
-
-def type_id= card_or_id
-  write_card_or_id :type_id, card_or_id
-end
-
-def type_id_from_template
-  return unless name && (t = template)
-
-  reset_patterns # still necessary even with new template handling?
-  self.type_id = t.type_id
-end
-
-event :validate_type_change, :validate, on: :update, changed: :type_id do
-  return unless (c = dup) && c.action == :create && !c.valid?
-
-  errors.add :type, t(:core_error_cant_change_errors,
-                      name: name,
-                      type_id: type_id,
-                      error_messages: c.errors.full_messages)
-end
-
-event :validate_type, :validate, changed: :type_id, on: :save do
-  errors.add :type, t(:core_error_no_such_type) unless type_name
-
-  if (rt = structure) && rt.assigns_type? && type_id != rt.type_id
-    errors.add :type, t(:core_error_hard_templated, name: name, type_name: rt.type_name)
-  end
-end
-end;end;end;end;
-# ~~ generated from /Users/ezl5238/dev/decko/gem/card/mod/core/set/all/type.rb ~~

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

@@ -1,104 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class All
-# Set: All cards (Utils)
-#
-module Utils;
-extend Card::Set
-def self.source_location; "/Users/ezl5238/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].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
-
-def mod_root modname
-  if (spec = Gem::Specification.find_by_name "card-mod-#{modname}")
-    spec.full_gem_path
-  else
-    "#{Cardio.gem_root}/mod/#{modname}"
-  end
-end
-
-delegate :t, to: Cardio
-
-module Format; module_parent.send :register_set_format, Card::Format, self; extend Card::Set::AbstractFormat
-  delegate :t, to: Cardio
-  delegate :measure, to: :card
-end
-end;end;end;end;
-# ~~ generated from /Users/ezl5238/dev/decko/gem/card/mod/core/set/all/utils.rb ~~