card 1.99.6 → 1.100.0

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

@@ -0,0 +1,21 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All
+# Set: All cards (Phases)
+#
+module Phases;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/phases.rb"; end
+def prepare_for_phases
+  reset_patterns
+  include_set_modules
+end
+
+def only_storage_phase?
+  only_storage_phase || !director.main?
+end
+
+delegate :validation_phase, to: :director
+delegate :storage_phase, to: :director
+delegate :integration_phase, to: :director
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/phases.rb ~~

data/tmpsets/set/{mod002-core → mod003-core}/all/references.rb

@@ -1,9 +1,13 @@
 # -*- encoding : utf-8 -*-
-class Card; module Set; class All; module References; extend Card::Set
-# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/references.rb ~~
+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.
@@ -12,24 +16,30 @@ PARTIAL_REF_CODE = "P".freeze
 
 # cards that refer to self
 def referers
-  references_in.map(&:referer_id).map(&Card.method(:fetch)).compact
+  referer_cards_from_references references_in
 end
 
 # cards that include self
-def includers
-  refs = references_in.where(ref_type: "I")
-  refs.map(&:referer_id).map(&Card.method(:fetch)).compact
+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
-  references_out.map { |ref| Card.fetch ref.referee_key, new: {} }
+  referees_from_references references_out
 end
 
 # cards that self includes
-def includees
-  refs = references_out.where(ref_type: "I")
-  refs.map { |ref| Card.fetch ref.referee_key, new: {} }
+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
@@ -38,18 +48,12 @@ def name_referers
   Card.joins(:references_out).where card_references: { referee_key: key }
 end
 
-# cards that refer to self or any descendant
-def family_referers
-  @family_referers ||= ([self] + descendants).map(&:referers).flatten.uniq
-  # FIXME: could be much more efficient!
-end
-
 # replace references in card content
 def replace_reference_syntax old_name, new_name
-  obj_content = Card::Content.new raw_content, self
+  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.replace_part old_name, new_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
@@ -78,20 +82,21 @@ end
 # delete references from this card
 def delete_references_out
   raise "id required to delete references" if id.nil?
-  Card::Reference.delete_all referer_id: id
+  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_type1, referee1_type2],
+# { referee1_key: [referee1_id, referee1_type2],
 #   referee2_key...
 # }
 def interpret_reference ref_hash, referee_name, ref_type
   return unless referee_name # eg commented nest has no referee_name
-  referee_key = (referee_name = referee_name.to_name).key
+  referee_name = referee_name.to_name
+  referee_key = referee_name.key
   return if referee_key == key # don't create self reference
 
-  referee_id = Card.fetch_id(referee_name)
+  referee_id = Card::Lexicon.id referee_name
   ref_hash[referee_key] ||= [referee_id]
   ref_hash[referee_key] << ref_type
 
@@ -102,6 +107,7 @@ end
 # 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
@@ -123,25 +129,50 @@ def reference_values_array ref_hash
   values
 end
 
-# invokes the given block for each reference in raw_content with
+# invokes the given block for each reference in content with
 # the reference name and reference type
 def each_reference_out
-  content_obj = Card::Content.new raw_content, self
-  content_obj.find_chunks(Card::Content::Chunk::Reference).each do |chunk|
-    yield(chunk.referee_name, chunk.reference_code)
+  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 & preload referer list
+# test for updating referer content
 event :prepare_referer_update, :validate, on: :update, changed: :name do
   self.update_referers = ![nil, false, "false"].member?(update_referers)
-  family_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, changed: :name do
+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
@@ -157,31 +188,8 @@ event :clear_references, :finalize, on: :delete do
   Card::Reference.unmap_referees id
 end
 
-# on rename, update names in cards that refer to self by name (as directed)
-event :update_referer_content, :finalize,
-      on: :update, changed: :name,
-      when: proc { |card| card.update_referers } do
-  # FIXME: break into correct stages
-  Auth.as_bot do
-    family_referers.each do |card|
-      next if card == self || card.structure
-      card = card.refresh
-      card.db_content = card.replace_reference_syntax name_was, name
-      card.save!
-    end
-  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, changed: :name,
-      when: proc { |c| !c.update_referers } do
-  family_referers.map(&:update_references_out)
+def not_update_referers
+  !update_referers
 end
-
-
-# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/references.rb ~~
 end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/references.rb ~~

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

@@ -0,0 +1,42 @@
+# -*- 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 ~~

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

@@ -0,0 +1,75 @@
+# -*- 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 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
+
+# TODO: abstract so account doesn't have to have User type.
+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
+
+def rule setting_code, options={}
+  options[:skip_modules] = true
+  card = rule_card setting_code, options
+  card && card.db_content
+end
+
+def rule_card setting_code, options={}
+  Card.fetch rule_card_id(setting_code, options), options
+end
+
+def rule_card_id setting_code, options={}
+  fallback = options.delete :fallback
+
+  if Card::Setting.user_specific? setting_code
+    fallback, setting_code = preference_card_id_lookups setting_code, options
+  end
+
+  rule_set_keys.each do |rule_set_key|
+    rule_cache = Card::Rule.rule_cache
+    rule_id = rule_cache["#{rule_set_key}+#{setting_code}"]
+    rule_id ||= fallback && rule_cache["#{rule_set_key}+#{fallback}"]
+    return rule_id if rule_id
+  end
+  nil
+end
+
+def preference_card_id_lookups setting_code, options={}
+  user_id = options[:user_id] || options[:user]&.id || Auth.current_id
+  return unless user_id
+  ["#{setting_code}+#{AllID}", "#{setting_code}+#{user_id}"]
+end
+
+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
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/rules.rb ~~

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

@@ -0,0 +1,26 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All
+# Set: All cards (Stages)
+#
+module Stages;
+extend Card::Set
+def self.source_location; "/Users/ethan/dev/decko/gem/card/mod/core/set/all/stages.rb"; end
+attr_writer :director
+delegate :act_manager, to: :director
+
+def director
+  @director ||= Card::ActManager.fetch self
+end
+
+def identify_action
+  @action =
+    if trash && trash_changed?
+      :delete
+    elsif new_card?
+      :create
+    else
+      :update
+    end
+end
+end;end;end;end;
+# ~~ generated from /Users/ethan/dev/decko/gem/card/mod/core/set/all/stages.rb ~~

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

@@ -0,0 +1,93 @@
+# -*- 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 ~~