card 1.101.5 → 1.103.0

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

@@ -1,90 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class All
-# Set: All cards (Rules)
-#
-module Rules;
-extend Card::Set
-def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/rules.rb"; end
-def rule setting_code
-  rule_card(setting_code, skip_modules: true)&.db_content
-end
-
-def rule_card setting_code, options={}
-  Card.fetch rule_card_id(setting_code), options
-end
-
-def rule_card_id setting_code
-  rule_id_lookup Card::Rule.rule_cache, setting_code
-end
-
-def preference setting_code, user=nil
-  preference_card(setting_code, user, skip_modules: true)&.db_content
-end
-
-def preference_card setting_code, user=nil, options={}
-  Card.fetch preference_card_id(setting_code, user), options
-end
-
-def preference_card_id setting_code, user=nil
-  return unless (user_id = preference_user_id user)
-  rule_id_lookup Card::Rule.preference_cache,
-                 "#{setting_code}+#{user_id}",
-                 "#{setting_code}+#{AllID}"
-end
-
-def is_rule?
-  is_standard_rule? || is_preference?
-end
-
-def is_standard_rule?
-  (r = right(skip_modules: true)) &&
-    r.type_id == SettingID &&
-    (l = left(skip_modules: true)) &&
-    l.type_id == SetID
-end
-
-def is_preference?
-  name.parts.length > 2 &&
-    (r = right(skip_modules: true)) &&
-    r.type_id == SettingID &&
-    (set = self[0..-3, skip_modules: true]) &&
-    set.type_id == SetID &&
-    (user = self[-2, skip_modules: true]) &&
-    (user.type_id == UserID || user.codename == :all)
-end
-
-# FIXME: move to a better place (if still needed) and use codenames
-def related_sets with_self=false
-  # refers to sets that users may configure from the current card -
-  # NOT to sets to which the current card belongs
-
-  sets = []
-  sets << ["#{name}+*self", Card::Set::Self.label(name)] if with_self
-  if known? && name.simple?
-    sets << ["#{name}+*right", Card::Set::Right.label(name)]
-  end
-  sets
-end
-
-private
-
-def preference_user_id user
-  case user
-  when Integer then user;
-  when Card    then user
-  when nil     then Auth.current_id
-  else
-    raise Card::ServerError, "invalid preference user"
-  end
-end
-
-def rule_id_lookup lookup_hash, cache_suffix, fallback_suffix=nil
-  rule_set_keys.each do |rule_set_key|
-    rule_id = lookup_hash["#{rule_set_key}+#{cache_suffix}"]
-    rule_id ||= fallback_suffix && lookup_hash["#{rule_set_key}+#{fallback_suffix}"]
-    return rule_id if rule_id
-  end
-  nil
-end
-end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/rules.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/ethan/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 exist? real?
-  alias 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 new_card? new?
-alias 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/ethan/dev/decko/gem/card/mod/core/set/all/states.rb ~~

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

@@ -1,129 +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/ethan/dev/decko/gem/card/mod/core/set/all/subcards.rb"; end
-def field tag, opts={}
-  Card.fetch name.field(tag), opts
-end
-
-def subcard card_name
-  subcards.card card_name
-end
-
-def subfield field_name
-  subcards.field field_name
-end
-
-def field? tag
-  field(tag) || subfield(tag)
-end
-
-def subcards
-  @subcards ||= Card::Subcards.new self
-end
-
-def subcards?
-  subcards.present?
-end
-
-def expire_subcards
-  subcards.clear
-end
-
-# phase_method :attach_subcard, before: :store do |name_or_card, args=nil|
-# TODO: handle differently in different stages
-def add_subcard name_or_card, args={}
-  subcards.add name_or_card, args
-end
-alias_method :attach_subcard, :add_subcard
-
-def add_subcard! name_or_card, args={}
-  subcard = subcards.add name_or_card, args
-  subcard.director.reset_stage
-  subcard
-end
-alias_method :attach_subcard!, :add_subcard!
-
-# phase_method :attach_subfield, before: :approve do |name_or_card, args=nil|
-def attach_subfield name_or_card, args={}
-  subcards.add_field name_or_card, args
-end
-alias_method :add_subfield, :attach_subfield
-
-def attach_subfield! name_or_card, args={}
-  subcard = subcards.add_field name_or_card, args
-  subcard.director.reset_stage
-  subcard
-end
-
-def detach_subcard name_or_card
-  subcards.remove name_or_card
-end
-alias_method :remove_subcard, :detach_subcard
-
-def detach_subfield name_or_card
-  subcards.remove_field name_or_card
-end
-alias_method :remove_subfield, :detach_subfield
-
-def clear_subcards
-  subcards.clear
-end
-
-# ensures subfield is present
-# does NOT override subfield content if already present
-def ensure_subfield field_name, args={}
-  if subfield_present? field_name
-    subfield field_name
-  else
-    add_subfield field_name, args
-  end
-end
-
-def subfield_present? field_name
-  subfield(field_name)&.content&.present?
-end
-
-def deep_clear_subcards
-  subcards.deep_clear
-end
-
-def handle_subcard_errors
-  subcards.each do |subcard|
-    subcard.errors.each do |error|
-      subcard_error subcard, error
-    end
-    subcard.errors.clear
-  end
-end
-
-def subcard_error subcard, error
-  msg = error.message
-  msg = "#{error.attribute} #{msg}" unless %i[content abort].member? error.attribute
-  errors.add subcard.name.from(name), msg
-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/ethan/dev/decko/gem/card/mod/core/set/all/subcards.rb ~~

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

@@ -1,136 +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/ethan/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
-
-    trashed_card_ids = all_trashed_card_ids
-    file_ids = all_file_ids
-    file_ids.each do |file_id|
-      next unless trashed_card_ids.member?(file_id)
-      raise Card::Error, tr(:exception_almost_deleted) if Card.exists?(file_id)
-      ::FileUtils.rm_rf "#{dir}/#{file_id}", secure: true
-    end
-  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 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, tr(: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 junction? && left&.codename == :all &&
-     undeletable_all_rules_tags.member?(right.codename.to_s)
-    errors.add :delete, tr(:error_indestructible, name: name)
-  end
-
-  errors.add :delete, tr(: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|
-    next unless child
-    # prevents errors in cases where a child is deleted prior to this point
-    # and thus is not returned by the fetch in #children
-
-    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/ethan/dev/decko/gem/card/mod/core/set/all/trash.rb ~~