card 1.91 → 1.92

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

@@ -0,0 +1,23 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All; module Phases; extend Card::Set
+# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/phases.rb ~~
+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
+
+def clean_up
+  Card::DirectorRegister.clear
+end
+
+
+# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/phases.rb ~~
+end;end;end;end;

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

@@ -0,0 +1,187 @@
+# -*- 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 ~~
+# frozen_string_literal: true
+
+# Cards can refer to other cards in their content, eg via links and nests.
+# 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
+  references_in.map(&:referer_id).map(&Card.method(:fetch)).compact
+end
+
+# cards that include self
+def includers
+  refs = references_in.where(ref_type: "I")
+  refs.map(&:referer_id).map(&Card.method(:fetch)).compact
+end
+
+# cards that self refers to
+def referees
+  references_out.map { |ref| Card.fetch ref.referee_key, new: {} }
+end
+
+# cards that self includes
+def includees
+  refs = references_out.where(ref_type: "I")
+  refs.map { |ref| Card.fetch ref.referee_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
+
+# 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.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)
+    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.delete_all referer_id: id
+end
+
+# interpretation phase helps to prevent duplicate references
+# results in hash like:
+# { referee1_key: [referee1_id, referee1_type1, 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
+  return if referee_key == key # don't create self reference
+
+  referee_id = Card.fetch_id(referee_name)
+  ref_hash[referee_key] ||= [referee_id]
+  ref_hash[referee_key] << ref_type
+
+  interpret_partial_references ref_hash, referee_name unless referee_id
+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
+  [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 raw_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)
+  end
+end
+
+protected
+
+# test for updating referer content & preload referer list
+event :prepare_referer_update, :validate, on: :update, changed: :name do
+  self.update_referers = ![nil, false, "false"].member?(update_referers)
+  family_referers
+end
+
+# when name changes, update references to card
+event :refresh_references_in, :finalize, on: :save, changed: :name 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
+
+# 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)
+end
+
+
+# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/references.rb ~~
+end;end;end;end;

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

@@ -0,0 +1,311 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All; module Rules; extend Card::Set
+# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/rules.rb ~~
+# frozen_string_literal: true
+
+RULE_SQL = %(
+  SELECT
+    rules.id      AS rule_id,
+    settings.id   AS setting_id,
+    sets.id       AS set_id,
+    sets.left_id  AS anchor_id,
+    sets.right_id AS set_tag_id
+  FROM cards rules
+  JOIN cards sets     ON rules.left_id  = sets.id
+  JOIN cards settings ON rules.right_id = settings.id
+  WHERE     sets.type_id = #{Card::SetID}
+    AND settings.type_id = #{Card::SettingID}
+    AND (settings.codename != 'follow' OR rules.db_content != '')
+    AND    rules.trash is false
+    AND     sets.trash is false
+    AND settings.trash is false;
+).freeze
+
+# FIXME: "follow" hardcoded above
+
+READ_RULE_SQL = %(
+  SELECT
+    refs.referee_id AS party_id,
+    read_rules.id   AS read_rule_id
+  FROM cards read_rules
+  JOIN card_references refs ON refs.referer_id    = read_rules.id
+  JOIN cards sets           ON read_rules.left_id = sets.id
+  WHERE read_rules.right_id = #{Card::ReadID}
+    AND       sets.type_id  = #{Card::SetID}
+    AND read_rules.trash is false
+    AND       sets.trash is false;
+).freeze
+
+PREFERENCE_SQL = %(
+  SELECT
+    preferences.id AS rule_id,
+    settings.id    AS setting_id,
+    sets.id        AS set_id,
+    sets.left_id   AS anchor_id,
+    sets.right_id  AS set_tag_id,
+    users.id       AS user_id
+  FROM cards preferences
+  JOIN cards user_sets ON preferences.left_id  = user_sets.id
+  JOIN cards settings  ON preferences.right_id = settings.id
+  JOIN cards users     ON user_sets.right_id   = users.id
+  JOIN cards sets      ON user_sets.left_id    = sets.id
+  WHERE sets.type_id     = #{Card::SetID}
+    AND settings.type_id = #{Card::SettingID}
+    AND (%s or users.codename = 'all')
+    AND sets.trash        is false
+    AND settings.trash    is false
+    AND users.trash       is false
+    AND user_sets.trash   is false
+    AND preferences.trash is false;
+).freeze
+
+def is_rule?
+  is_standard_rule? || is_preference?
+end
+
+def is_standard_rule?
+  (r = right(skip_modules: true)) &&
+    r.type_id == Card::SettingID &&
+    (l = left(skip_modules: true)) &&
+    l.type_id == Card::SetID
+end
+
+def is_preference?
+  cardname.parts.length > 2 &&
+    (r = right(skip_modules: true)) &&
+    r.type_id == Card::SettingID &&
+    (set = self[0..-3, skip_modules: true]) &&
+    set.type_id == Card::SetID &&
+    (user = self[-2, skip_modules: true]) &&
+    (user.type_id == Card::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_id = self.class.rule_cache["#{rule_set_key}+#{setting_code}"]
+    rule_id ||= fallback && self.class.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] && 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
+
+  # FIXME: change to use codenames!!
+
+  sets = []
+  if known? && type_id == Card::CardtypeID # FIXME: belongs in type/cardtype
+    sets << ["#{name}+*type", Card::Set::Type.label(name)]
+  end
+  sets << ["#{name}+*self", Card::Set::Self.label(name)] if with_self
+  if known? && cardname.simple?
+    sets << ["#{name}+*right", Card::Set::Right.label(name)]
+  end
+  sets
+end
+
+module ClassMethods
+  # User-specific rule use the pattern
+  # user+set+setting
+  def preference_sql user_id=nil
+    user_restriction =
+      if user_id
+        "users.id = #{user_id}"
+      else
+        "users.type_id = #{Card::UserID}"
+      end
+    PREFERENCE_SQL % user_restriction
+  end
+
+  def global_setting name
+    Auth.as_bot do
+      (card = Card[name]) && !card.db_content.strip.empty? && card.db_content
+    end
+  end
+
+  def path_setting name # shouldn't this be in location helper?
+    name ||= "/"
+    return name if name =~ /^(http|mailto)/
+    "#{Card.config.relative_url_root}#{name}"
+  end
+
+  def toggle val
+    val.to_s.strip == "1"
+  end
+
+  def rule_cache_key row
+    return false unless (setting_code = Codename[row["setting_id"].to_i])
+
+    anchor_id = row["anchor_id"]
+    set_class_id = anchor_id.nil? ? row["set_id"] : row["set_tag_id"]
+    return false unless (set_class_code = Codename[set_class_id.to_i])
+
+    [anchor_id, set_class_code, setting_code].compact.map(&:to_s) * "+"
+  end
+
+  def interpret_simple_rules
+    ActiveRecord::Base.connection.select_all(RULE_SQL).each do |row|
+      next unless (key = rule_cache_key row)
+      @rule_hash[key] = row["rule_id"].to_i
+    end
+  end
+
+  def interpret_preferences
+    ActiveRecord::Base.connection.select_all(preference_sql).each do |row|
+      next unless (key = rule_cache_key row) && (user_id = row["user_id"])
+      add_preference_hash_values key, row["rule_id"].to_i, user_id.to_i
+    end
+  end
+
+  def add_preference_hash_values key, rule_id, user_id
+    @rule_hash[preference_key(key, user_id)] = rule_id
+    @user_ids_hash[key] ||= []
+    @user_ids_hash[key] << user_id
+    @rule_keys_hash[user_id] ||= []
+    @rule_keys_hash[user_id] << key
+  end
+
+  def cached_rule_keys_for user_id
+    rule_keys_cache[user_id] || []
+  end
+
+  def all_user_ids_with_rule_for set_card, setting_code
+    key =
+      if (l = set_card.left) && (r = set_card.right)
+        set_class_code = Codename[r.id]
+        "#{l.id}+#{set_class_code}+#{setting_code}"
+      else
+        set_class_code = Codename[set_card.id]
+        "#{set_class_code}+#{setting_code}"
+      end
+    user_ids = user_ids_cache[key] || []
+    if user_ids.include? AllID  # rule for all -> return all user ids
+      Card.where(type_id: UserID).pluck(:id)
+    else
+      user_ids
+    end
+  end
+
+  def preference_names user_name, setting_code
+    Card.search(
+      { right: { codename: setting_code },
+        left: {
+          left: { type_id: SetID }, right: user_name
+        },
+        return: :name
+      }, "preference cards for user: #{user_name}"
+    )
+  end
+
+  def preference_cards user_name, setting_code
+    preference_names(user_name, setting_code).map { |name| Card.fetch name }
+  end
+
+  def rule_cache
+    Card.cache.read("RULES") || begin
+      @rule_hash = {}
+      @user_ids_hash = {}
+      @rule_keys_hash = {}
+
+      interpret_simple_rules
+      interpret_preferences
+
+      write_user_ids_cache @user_ids_hash
+      write_rule_keys_cache @rule_keys_hash
+      write_rule_cache @rule_hash
+    end
+  end
+
+  def preference_key key, user_id
+    "#{key}+#{user_id}"
+  end
+
+  # all users that have a user-specific rule for a given rule key
+  def user_ids_cache
+    Card.cache.read("USER_IDS") || begin
+      clear_rule_cache
+      rule_cache
+      @user_ids_hash
+    end
+  end
+
+  # all keys of user-specific rules for a given user
+  def rule_keys_cache
+    Card.cache.read("RULE_KEYS") || begin
+      clear_rule_cache
+      rule_cache
+      @rule_keys_hash
+    end
+  end
+
+  def clear_rule_cache
+    write_rule_cache nil
+    write_user_ids_cache nil
+    write_rule_keys_cache nil
+  end
+
+  def clear_preference_cache
+    # FIXME: too entwined!
+    clear_rule_cache
+  end
+
+  def write_rule_cache hash
+    Card.cache.write "RULES", hash
+  end
+
+  def write_user_ids_cache hash
+    Card.cache.write "USER_IDS", hash
+  end
+
+  def write_rule_keys_cache hash
+    Card.cache.write "RULE_KEYS", hash
+  end
+
+  def read_rule_cache
+    Card.cache.read("READRULES") || begin
+      hash = {}
+      Card.connection.select_all(
+        Card::Set::All::Rules::READ_RULE_SQL
+      ).each do |row|
+        party_id = row["party_id"].to_i
+        hash[party_id] ||= []
+        hash[party_id] << row["read_rule_id"].to_i
+      end
+      Card.cache.write "READRULES", hash
+    end
+  end
+
+  def clear_read_rule_cache
+    Card.cache.write "READRULES", nil
+  end
+end
+
+
+# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/rules.rb ~~
+end;end;end;end;