card 1.18.6 → 1.19.0

data/tmpsets/set/mod001-01_core/all/phases.rb

@@ -1,215 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; module All; module Phases; extend Card::Set
-# ~~~~~~~~~~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/01_core/set/all/phases.rb ~~~~~~~~~~~
-
-# The Card#abort method is for cleanly exiting an action without continuing
-# to process any further events.
-#
-# Three statuses are supported:
-#
-#   failure: adds an error, returns false on save
-#   success: no error, returns true on save
-#   triumph: similar to success, but if called on a subcard
-#            it causes the entire action to abort (not just the subcard)
-
-def abort status, msg = 'action canceled'
-  if status == :failure && errors.empty?
-    errors.add :abort, msg
-  elsif Hash === status && status[:success]
-    success << status[:success]
-    status = :success
-  end
-  raise Card::Abort.new(status, msg)
-end
-
-def abortable
-  yield
-rescue Card::Abort => e
-  if e.status == :triumph
-    @supercard ? raise(e) : true
-  elsif e.status == :success
-    if @supercard
-      @supercard.subcards.delete(key)
-    end
-    true
-  end
-end
-
-def valid_subcard?
-  abortable { valid? }
-end
-
-# this is an override of standard rails behavior that rescues abort
-# makes it so that :success abortions do not rollback
-def with_transaction_returning_status
-  status = nil
-  self.class.transaction do
-    add_to_transaction
-    status = abortable { yield }
-    raise ActiveRecord::Rollback unless status
-  end
-  status
-end
-
-# perhaps above should be in separate module?
-# ~~~~~~
-
-PHASES = {}
-[:prepare, :approve, :store, :stored, :extend, :subsequent]
-  .each_with_index do |phase, i|
-    PHASES[phase] = i
-  end
-
-def run_phase phase, &block
-  @phase = phase
-  @subphase = :before
-  if block_given?
-    block.call
-  else
-    run_callbacks phase
-  end
-  @subphase = :after
-end
-
-def simulate_phase opts, &block
-  @phase
-end
-
-def phase
-  @phase || (@supercard && @supercard.phase)
-end
-
-def subphase
-  @subphase || (@supercard && @supercard.subphase)
-end
-
-def prepare
-  @action = identify_action
-  # the following should really happen when type, name etc are changed
-  reset_patterns
-  include_set_modules
-  run_phase :prepare
-rescue => e
-  rescue_event e
-end
-
-def approve
-  @action ||= identify_action
-  run_phase :approve
-  expire_pieces if errors.any?
-  errors.empty?
-rescue => e
-  rescue_event e
-end
-
-def identify_action
-  case
-  when trash     then :delete
-  when new_card? then :create
-  else :update
-  end
-end
-
-def store
-  run_phase :store do
-    run_callbacks :store do
-      yield # unless @draft
-      @virtual = false
-    end
-  end
-  run_phase :stored
-rescue => e
-  rescue_event e
-ensure
-  @from_trash =  @last_content_action_id = nil
-end
-
-def extend
-  run_phase :extend
-  run_phase :subsequent
-rescue => e
-  rescue_event e
-ensure
-  @action = nil
-end
-
-def rescue_event e
-  @action = nil
-  expire_pieces
-  subcards.each(&:expire_pieces)
-  raise e
-  # rescue Card::Cancel
-  # false
-end
-
-def phase_ok? opts
-  phase && (
-    (opts[:during] && in?(opts[:during])) ||
-    (opts[:before] && before?(opts[:before])) ||
-    (opts[:after]  && after?(opts[:after])) ||
-    true # no phase restriction in opts
-  )
-end
-
-def before? allowed_phase
-  PHASES[allowed_phase] > PHASES[phase] ||
-    (PHASES[allowed_phase] == PHASES[phase] && subphase == :before)
-end
-
-def after? allowed_phase
-  PHASES[allowed_phase] < PHASES[phase] ||
-    (PHASES[allowed_phase] == PHASES[phase] && subphase == :after)
-end
-
-def in? allowed_phase
-  (allowed_phase.is_a?(Array) && allowed_phase.include?(phase)) ||
-    allowed_phase == phase
-end
-
-event :notable_exception_raised do
-  Rails.logger.debug "BT:  #{Card::Error.current.backtrace * "\n  "}"
-end
-
-def event_applies? opts
-  on_condition_applies?(opts[:on]) &&
-    changed_condition_applies?(opts[:changed]) &&
-    when_condition_applies?(opts[:when])
-end
-
-def on_condition_applies? action
-  if action
-    Array.wrap(action).member? @action
-  else
-    true
-  end
-end
-
-def changed_condition_applies? db_column
-  if db_column
-    db_column =
-      case db_column.to_sym
-      when :content then 'db_content'
-      when :type    then 'type_id'
-      else db_column.to_s
-      end
-    @action != :delete && changes[db_column]
-  else
-    true
-  end
-end
-
-def when_condition_applies? block
-  if block
-    block.call self
-  else
-    true
-  end
-end
-
-def success
-  Env.success(cardname)
-end
-
-
-# ~~~~~~~~~~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/01_core/set/all/phases.rb ~~~~~~~~~~~
-end;end;end;end;

data/tmpsets/set/mod001-01_core/all/references.rb

@@ -1,106 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; module All; module References; extend Card::Set
-# ~~~~~~~~~~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/01_core/set/all/references.rb ~~~~~~~~~~~
-
-PARTIAL_REF_CODE = 'P'
-
-def name_referencers link_name=nil
-  link_name = link_name.nil? ? key : link_name.to_name.key
-  Card.joins(:references_to).where card_references: { referee_key: link_name }
-end
-
-def extended_referencers
-  # FIXME: .. we really just need a number here.
-  (descendants + [self]).map(&:referencers).flatten.uniq
-end
-
-# replace references in card content
-def replace_references old_name, new_name
-  obj_content = Card::Content.new raw_content, self
-  obj_content.find_chunks(Card::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
-    old_references = Card::Reference.where(referee_key: old_ref_name.key)
-    old_references.update_all referee_key: new_ref_name.key
-  end
-
-  obj_content.to_s
-end
-
-# update entries in reference table
-def update_references rendered_content=nil
-  raise 'update references should not be called on new cards' if id.nil?
-
-  Card::Reference.delete_all_from self unless self.new_card?
-
-  rendered_content ||= Card::Content.new raw_content, self
-  rendered_content.find_chunks(Card::Chunk::Reference).each do |chunk|
-    create_reference_to chunk
-  end
-end
-
-def create_reference_to chunk
-  referee_name = chunk.referee_name
-  return false unless referee_name # eg no commented nest
-
-  referee_name.piece_names.each do |name|
-    next if name.key == key # don't create self reference
-
-    # reference types:
-    # L = link
-    # I = inclusion
-    # P = partial (i.e. the name is part of a compound name that is
-    #  referenced by a link or inclusion)
-
-    # The partial type is needed to keep track of references of virtual cards.
-    # For example a link [[A+*self]] won't make it to the reference table
-    # because A+*self is virtual and doesn't have an id but when A's name is
-    # changed we have to find and update that link.
-    ref_type = name != referee_name ? PARTIAL_REF_CODE : chunk.reference_code
-    Card::Reference.create!(
-      referer_id:  id,
-      referee_id:  Card.fetch_id(name),
-      referee_key: name.key,
-      ref_type:    ref_type,
-      present:     1
-    )
-  end
-end
-
-def referencers
-  references_from.map(&:referer_id).map(&Card.method(:fetch)).compact
-end
-
-def includers
-  references_from.where(ref_type: 'I')
-    .map(&:referer_id).map(&Card.method(:fetch)).compact
-end
-
-def referees
-  references_to.map { |ref| Card.fetch ref.referee_key, new: {} }
-end
-
-def includees
-  references_to.where(ref_type: 'I')
-    .map { |ref| Card.fetch ref.referee_key, new: {} }
-end
-
-protected
-
-event :refresh_references, after: :store, on: :save, changed: :content do
-  update_references
-end
-
-event :refresh_references_on_create, before: :refresh_references, on: :create do
-  Card::Reference.update_existing_key self
-  # FIXME: bogus blank default content is set on structured cards...
-end
-
-event :refresh_references_on_delete, after: :store, on: :delete do
-  Card::Reference.update_on_delete self
-end
-
-
-# ~~~~~~~~~~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/01_core/set/all/references.rb ~~~~~~~~~~~
-end;end;end;end;

data/tmpsets/set/mod001-01_core/all/rules.rb

@@ -1,317 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; module All; module Rules; extend Card::Set
-# ~~~~~~~~~~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/01_core/set/all/rules.rb ~~~~~~~~~~~
-RuleSQL = %{
-  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 sets.trash     is false
-  and   settings.type_id = #{Card::SettingID} and settings.trash is false
-  and                                             rules.trash    is false
-  and   (settings.codename != 'follow' or rules.db_content != '');
-}
-
-ReadRuleSQL = %{
-  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 read_rules.trash is false and sets.type_id = #{Card::SetID};
-}
-
-def is_rule?
-  is_standard_rule? || is_user_rule?
-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_user_rule?
-  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
-    user_id = options[:user_id] || (options[:user] and options[:user].id) || Auth.current_id
-    if user_id
-      fallback = "#{setting_code}+#{AllID}"
-      setting_code = "#{setting_code}+#{user_id}"
-    end
-  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 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::TypeSet.label(name)]
-  end
-  if with_self
-    sets << ["#{name}+*self", Card::SelfSet.label(name)]
-  end
-  if known? && cardname.simple?
-    sets << ["#{name}+*right", Card::RightSet.label(name)]
-  end
-  sets
-end
-
-module ClassMethods
-
-  # User-specific rule use the pattern
-  # user+set+setting
-  def user_rule_sql user_id=nil
-    user_restriction = if user_id
-        "users.id = #{user_id}"
-      else
-        "users.type_id = #{Card::UserID}"
-      end
-
-    %{
-      select
-        user_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,
-        users.id      as user_id
-      from cards user_rules
-      join cards user_sets on user_rules.left_id  = user_sets.id
-      join cards settings  on user_rules.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 (#{user_restriction} 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 user_rules.trash is false;
-    }
-  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 cache_key row
-    setting_code = Codename[ row['setting_id'].to_i ] or return false
-
-    anchor_id = row['anchor_id']
-    set_class_id = anchor_id.nil? ? row['set_id'] : row['set_tag_id']
-    set_class_code = Codename[ set_class_id.to_i ] or return false
-
-    key_base = [ anchor_id, set_class_code, setting_code].compact.map( &:to_s ) * '+'
-  end
-
-  def all_rule_keys_with_id
-    ActiveRecord::Base.connection.select_all(RuleSQL).each do |row|
-      if key = cache_key(row)
-        yield(key, row['rule_id'].to_i)
-      end
-    end
-  end
-
-  def all_user_rule_keys_with_id_and_user_id
-    ActiveRecord::Base.connection.select_all(user_rule_sql).each do |row|
-      if key = cache_key(row) and user_id = row['user_id']
-        yield(key, row['rule_id'].to_i, user_id.to_i)
-      end
-    end
-  end
-
-  def all_rule_keys_with_id_for user_id
-    ActiveRecord::Base.connection.select_all(user_rule_sql(user_id)).each do |row|
-      if key = cache_key(row)
-        yield(key, row['rule_id'].to_i)
-      end
-    end
-  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 user_rule_cards user_name, setting_code
-    Card.search(
-      { right: { codename: setting_code },
-        left: { left: { type_id: SetID }, right: user_name }
-        }, "rule cards for user: #{user_name}"
-    )
-  end
-
-  def rule_cache
-    Card.cache.read('RULES') || begin
-      rule_hash = {}
-      all_rule_keys_with_id do |key,rule_id|
-        rule_hash[key] = rule_id
-      end
-
-      user_ids_hash = {}
-      rule_keys_hash = {}
-      all_user_rule_keys_with_id_and_user_id do |key, rule_id, user_id|
-        rule_hash[ user_rule_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
-      write_user_ids_cache user_ids_hash
-      write_rule_keys_cache rule_keys_hash
-      write_rule_cache rule_hash
-    end
-  end
-
-  def user_rule_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
-      rule_cache
-      Card.cache.read('USER_IDS')
-    end
-  end
-
-  # all keys of user-specific rules for a given user
-  def rule_keys_cache
-    Card.cache.read('RULE_KEYS') || begin
-      rule_cache
-      Card.cache.read('RULE_KEYS')
-    end
-  end
-
-  def clear_rule_cache
-    write_rule_cache nil
-    write_user_ids_cache nil
-    write_rule_keys_cache nil
-  end
-
-  def clear_user_rule_cache
-    clear_rule_cache
-  end
-
-  def refresh_rule_cache_for_user user_id
-    rule_hash = rule_cache
-    user_ids_hash = user_ids_cache
-    rule_keys_hash = rule_keys_cache
-
-    cached_rule_keys_for(user_id).each do |key|
-      rule_hash[ user_rule_key(key, user_id) ] = nil
-      user_ids_hash[ key ].delete(user_id)
-    end
-    rule_keys_hash[ user_id ] = nil
-
-    all_rule_keys_with_id_for(user_id) do |key, rule_id|
-      rule_hash[ user_rule_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
-    write_user_ids_cache user_ids_hash
-    write_rule_keys_cache rule_keys_hash
-    write_rule_cache rule_hash
-  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 = {}
-      ActiveRecord::Base.connection.select_all(
-        Card::Set::All::Rules::ReadRuleSQL
-      ).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/01_core/set/all/rules.rb ~~~~~~~~~~~
-end;end;end;end;