card 1.101.5 → 1.103.0

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

@@ -1,152 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class All
-# Set: All cards (NameEvents)
-#
-# STAGE: validate
-module NameEvents;
-extend Card::Set
-def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/name_events.rb"; end
-
-event :validate_name, :validate, on: :save, changed: :name, when: :no_autoname? do
-  validate_legality_of_name
-  return if errors.any?
-  Card.write_to_soft_cache self
-  validate_uniqueness_of_name
-end
-
-event :validate_uniqueness_of_name, skip: :allowed do
-  # validate uniqueness of name
-
-  return unless (existing_id = Card::Lexicon.id key) && existing_id != id
-  # The above is a fast check but cannot detect if card is in trash
-
-  # TODO: perform the following as a remote-only fetch (not yet supported)
-  return unless (existing_card = Card.where(id: existing_id, trash: false).take)
-
-  errors.add :name, tr(:error_name_exists, name: existing_card.name)
-end
-
-event :validate_legality_of_name do
-  if name.length > 255
-    errors.add :name, tr(:error_too_long, length: name.length)
-  elsif name.blank?
-    errors.add :name, tr(:error_blank_name)
-  elsif name_incomplete?
-    errors.add :name, tr(:is_incomplete)
-  elsif !name.valid?
-    errors.add :name, tr(:error_banned_characters, banned: Card::Name.banned_array * " ")
-  elsif changing_existing_tag_to_junction?
-    errors.add :name, tr(:error_name_tag, name: name)
-  end
-end
-
-event :validate_key, after: :validate_name, on: :save, when: :no_autoname? do
-  if key.empty?
-    errors.add :key, tr(:error_blank_key) if errors.empty?
-  elsif key != name.key
-    errors.add :key, tr(:error_wrong_key, key: key, name: name)
-  end
-end
-
-# STAGE: store
-
-event :set_autoname, :prepare_to_store, on: :create, when: :autoname? do
-  self.name = autoname rule(:autoname)
-  rule_card(:autoname).update_column :db_content, name
-  pull_from_trash!
-  Card.write_to_soft_cache self
-end
-
-event :expire_old_name, :store, changed: :name, on: :update do
-  Director.expirees << name_before_act
-end
-
-event :update_lexicon_on_create, :finalize, changed: :name, on: :create do
-  Card::Lexicon.add self
-end
-
-event :update_lexicon_on_rename, :finalize, changed: :name, on: :update do
-  Card::Lexicon.update self
-end
-
-def lex
-  simple? ? name : [left_id, right_id]
-end
-
-def old_lex
-  if (old_left_id = left_id_before_act)
-    [old_left_id, right_id_before_act]
-  else
-    name_before_act
-  end
-end
-
-event :prepare_left_and_right, :store, changed: :name, on: :save do
-  return if name.simple?
-  prepare_side :left
-  prepare_side :right
-end
-
-def prepare_side side
-  side_id = send "#{side}_id"
-  sidename = name.send "#{side}_name"
-  prepare_obstructed_side(side, side_id, sidename) ||
-    prepare_new_side(side, side_id, sidename)
-end
-
-def prepare_new_side side, side_id, sidename
-  return unless side_id == -1 || !Card[side_id]&.real?
-
-  sidecard = Director.card(sidename) || add_subcard(sidename)
-  send "#{side}_id=", sidecard
-end
-
-def prepare_obstructed_side side, side_id, sidename
-  return unless side_id && side_id == id
-  clear_name sidename
-  send "#{side}_id=", add_subcard(sidename)
-  true
-end
-
-def name_incomplete?
-  name.parts.include?("") && !superleft&.autoname?
-end
-
-def no_autoname?
-  !autoname?
-end
-
-def autoname?
-  name.blank? &&
-    (@autoname_rule.nil? ? (@autoname_rule = rule(:autoname).present?) : @autoname_rule)
-end
-
-private
-
-def changing_existing_tag_to_junction?
-  return false unless changing_name_to_junction?
-  name_in_use_as_tag?
-end
-
-def name_in_use_as_tag?
-  !Card.where(right_id: id, trash: false).take.nil?
-end
-
-def changing_name_to_junction?
-  name.junction? && simple?
-end
-
-def old_name_in_way? sidecard
-  real? && sidecard&.simple? && id == sidecard&.id
-end
-
-def clear_name name
-  # move the current card out of the way, in case the new name will require
-  # re-creating a card with the current name, ie.  A -> A+B
-  Card.where(id: id).update_all(name: nil, key: nil, left_id: nil, right_id: nil)
-  Card.expire name
-  Card::Lexicon.cache.reset # probably overkill, but this for an edge case...
-  # Card::Lexicon.delete id, key
-end
-end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/name_events.rb ~~

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

@@ -1,63 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class All
-# Set: All cards (Pattern)
-#
-module Pattern;
-extend Card::Set
-def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/pattern.rb"; end
-def patterns?
-  defined? @patterns
-end
-
-def all_patterns
-  @all_patterns ||= set_patterns.map { |sub| sub.new self }.compact
-end
-
-# new cards do not
-def patterns
-  @patterns ||= (new_card? ? all_patterns[1..-1] : all_patterns)
-end
-
-def reset_patterns
-  # Rails.logger.info "resetting patterns: #{name}"
-  @patterns = @all_patterns = nil
-  @template = @virtual = nil
-  @set_mods_loaded = @set_modules = @set_names = @rule_set_keys = nil
-  @junction_only = nil # only applies to set cards
-  true
-end
-
-def safe_set_keys
-  patterns.map(&:safe_key).reverse * " "
-end
-
-def set_modules
-  @set_modules ||= all_patterns[0..-2].reverse.map(&:module_list).flatten.compact
-end
-
-def set_format_modules klass
-  @set_format_modules ||= {}
-  @set_format_modules[klass] =
-    all_patterns[0..-2].reverse.map do |pattern|
-      pattern.format_module_list klass
-    end.flatten.compact
-end
-
-def set_names
-  @set_names = patterns.map(&:to_s) if @set_names.nil?
-  @set_names
-end
-
-def in_set? set_module
-  patterns.map(&:module_key).include? set_module.shortname
-end
-
-def rule_set_keys
-  @rule_set_keys ||= patterns.map(&:rule_set_key).compact
-end
-
-def include_module? set
-  singleton_class&.include? set
-end
-end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/pattern.rb ~~

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

@@ -1,200 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class All
-# Set: All cards (References)
-#
-# frozen_string_literal: true
-
-# Cards can refer to other cards in their content, eg via links and nests.
-module References;
-extend Card::Set
-def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/references.rb"; end
-# The card that refers is the "referer", the card that is referred to is
-# the "referee". The reference itself has its own class (Card::Reference),
-# which handles id-based reference tracking.
-
-PARTIAL_REF_CODE = "P".freeze
-
-# cards that refer to self
-def referers
-  referer_cards_from_references references_in
-end
-
-# cards that include self
-def nesters
-  referer_cards_from_references references_in.where(ref_type: "I")
-end
-
-def referer_cards_from_references references
-  references.map(&:referer_id).uniq.map(&Card.method(:fetch)).compact
-end
-
-# cards that self refers to
-def referees
-  referees_from_references references_out
-end
-
-# cards that self includes
-def nestees
-  referees_from_references references_out.where(ref_type: "I")
-end
-
-def referees_from_references references
-  references.map(&:referee_key).uniq.map { |key| Card.fetch key, new: {} }
-end
-
-# cards that refer to self by name
-# (finds cards not yet linked by id)
-def name_referers
-  Card.joins(:references_out).where card_references: { referee_key: key }
-end
-
-# replace references in card content
-def replace_reference_syntax old_name, new_name
-  obj_content = Card::Content.new content, self
-  obj_content.find_chunks(Card::Content::Chunk::Reference).select do |chunk|
-    next unless (old_ref_name = chunk.referee_name)
-    next unless (new_ref_name = old_ref_name.swap old_name, new_name)
-    chunk.referee_name = chunk.replace_reference old_name, new_name
-    refs = Card::Reference.where referee_key: old_ref_name.key
-    refs.update_all referee_key: new_ref_name.key
-  end
-
-  obj_content.to_s
-end
-
-# delete old references from this card's content, create new ones
-def update_references_out
-  delete_references_out
-  create_references_out
-end
-
-# interpret references from this card's content and
-# insert entries in reference table
-def create_references_out
-  ref_hash = {}
-  each_reference_out do |referee_name, ref_type|
-    interpret_reference ref_hash, referee_name, ref_type
-  end
-  return if ref_hash.empty?
-  Card::Reference.mass_insert reference_values_array(ref_hash)
-end
-
-# delete references from this card
-def delete_references_out
-  raise "id required to delete references" if id.nil?
-  Card::Reference.where(referer_id: id).delete_all
-end
-
-# interpretation phase helps to prevent duplicate references
-# results in hash like:
-# { referee1_key: [referee1_id, referee1_type2],
-#   referee2_key...
-# }
-def interpret_reference ref_hash, raw_referee_name, ref_type
-  with_normalized_referee raw_referee_name do |referee_name, referee_key, referee_id|
-    ref_hash[referee_key] ||= [referee_id]
-    ref_hash[referee_key] << ref_type
-    interpret_partial_references ref_hash, referee_name unless referee_id
-  end
-end
-
-# Partial references are needed to track references to virtual cards.
-# For example a link to virual card [[A+*self]] won't have a referee_id,
-# but when A's name is changed we have to find and update that link.
-def interpret_partial_references ref_hash, referee_name
-  return if referee_name.simple?
-  [referee_name.left, referee_name.right].each do |sidename|
-    interpret_reference ref_hash, sidename, PARTIAL_REF_CODE
-  end
-end
-
-# translate interpreted reference hash into values array,
-# removing duplicate and unnecessary ref_types
-def reference_values_array ref_hash
-  values = []
-  ref_hash.each do |referee_key, hash_val|
-    referee_id = hash_val.shift || "null"
-    ref_types = hash_val.uniq
-    ref_types.delete PARTIAL_REF_CODE if ref_types.size > 1
-    # partial references are not necessary if there are explicit references
-    ref_types.each do |ref_type|
-      values << [id, referee_id, "'#{referee_key}'", "'#{ref_type}'"]
-    end
-  end
-  values
-end
-
-# invokes the given block for each reference in content with
-# the reference name and reference type
-def each_reference_out
-  content_object.find_chunks(Card::Content::Chunk::Reference).each do |chunk|
-    yield chunk.referee_name, chunk.reference_code
-  end
-end
-
-def has_nests?
-  content_object.has_chunk? Card::Content::Chunk::Nest
-end
-
-def content_object
-  Card::Content.new content, self
-end
-
-protected
-
-# test for updating referer content
-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_reference_syntax 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,
-      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, on: :save do
-  Card::Reference.unmap_referees id if action == :update && !update_referers
-  Card::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
-  Card::Reference.unmap_referees id
-end
-
-def not_update_referers
-  !update_referers
-end
-
-private
-
-def with_normalized_referee referee_name
-  return unless referee_name # eg commented nest has no referee_name
-  referee_name = referee_name.to_name
-  referee_key = referee_name.key
-  return if referee_key == key # don't create self reference
-  yield referee_name, referee_key, Card::Lexicon.id(referee_name)
-end
-end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/references.rb ~~

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

@@ -1,42 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class All
-# Set: All cards (Rename)
-#
-module Rename;
-extend Card::Set
-def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/rename.rb"; end
-event :rename_in_trash, after: :expire_old_name, on: :update do
-  existing_card = Card.find_by_key_and_trash name.key, true
-  return if !existing_card || existing_card == self
-  existing_card.name = existing_card.name + "*trash"
-  existing_card.rename_in_trash_without_callbacks
-  existing_card.save!
-end
-
-event :validate_renaming, :validate, on: :update, changed: :name, skip: :allowed do
-  return if name_before_act&.to_name == name # just changing to new variant
-  errors.add :content, tr(:cannot_change_content) if content_is_changing?
-  errors.add :type, tr(:cannot_change_type) if type_is_changing?
-  detect_illegal_compound_names
-end
-
-event :cascade_name_changes, :finalize, on: :update, changed: :name do
-  each_descendant do |d|
-    d.action = :update
-    update_referers ? d.update_referers : d.update_referer_references_out
-    d.refresh_references_in
-    d.refresh_references_out
-    d.expire
-  end
-end
-
-def changed_from_simple_to_compound?
-  name.compound? && name_before_act.to_name.simple?
-end
-
-def detect_illegal_compound_names
-  return unless changed_from_simple_to_compound? && child_ids(:right).present?
-  errors.add :name, "illegal name change; existing names end in +#{name_before_act}"
-end
-end;end;end;end;
-# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/rename.rb ~~