card 1.99.6 → 1.100.0

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

@@ -1,319 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; class All; module Permissions; extend Card::Set
-# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/permissions.rb ~~
-
-Card.error_codes.merge! permission_denied: [:denial, 403],
-                        captcha: [:errors, 449]
-
-module ClassMethods
-  def repair_all_permissions
-    Card.where(
-      "(read_rule_class is null or read_rule_id is null) and trash is false"
-    ).each do |broken_card|
-      broken_card.include_set_modules
-      broken_card.repair_permissions!
-    end
-  end
-end
-
-def repair_permissions!
-  rule_id, rule_class = permission_rule_id_and_class :read
-  update_columns read_rule_id: rule_id, read_rule_class: rule_class
-end
-
-# ok? and ok! are public facing methods to approve one action at a time
-#
-#   fetching: if the optional :trait parameter is supplied, it is passed
-#      to fetch and the test is perfomed on the fetched card, therefore:
-#
-#      trait: :account      would fetch this card plus a tag codenamed :account
-#      trait: :roles, new: {} would initialize a new card with default ({})
-# options.
-
-def ok? action
-  @action_ok = true
-  send "ok_to_#{action}"
-  @action_ok
-end
-
-def ok_with_fetch? action, opts={}
-  card = opts[:trait].nil? ? self : fetch(opts)
-  card && card.ok_without_fetch?(action)
-end
-
-# note: method is chained so that we can return the instance variable @action_ok
-alias_method_chain :ok?, :fetch
-
-def ok! action, opts={}
-  raise Card::Error::PermissionDenied, self unless ok? action, opts
-end
-
-def who_can action
-  # warn "who_can[#{name}] #{(prc=permission_rule_card(action)).inspect},
-  # #{prc.first.item_cards.map(&:id)}" if action == :update
-  permission_rule_card(action).item_cards.map(&:id)
-end
-
-def permission_rule_id_and_class action
-  direct_rule_id = rule_card_id action
-  require_permission_rule! direct_rule_id, action
-  direct_rule = Card.fetch direct_rule_id, skip_modules: true
-  [applicable_permission_rule_id(direct_rule, action),
-   direct_rule.rule_class_name]
-end
-
-def applicable_permission_rule_id direct_rule, action
-  if junction? && direct_rule.db_content =~ /^\[?\[?_left\]?\]?$/
-    lcard = left_or_new(skip_virtual: true, skip_modules: true)
-    if action == :create && lcard.real? && !lcard.action == :create
-      action = :update
-    end
-    lcard.permission_rule_id_and_class(action).first
-  else
-    direct_rule.id
-  end
-end
-
-def permission_rule_card action
-  Card.fetch permission_rule_id_and_class(action).first
-end
-
-def require_permission_rule! rule_id, action
-  return if rule_id
-  # RULE missing.  should not be possible.
-  # generalize this to handling of all required rules
-  errors.add :permission_denied, "No #{action} rule for #{name}"
-  raise Card::Error::PermissionDenied, self
-end
-
-def rule_class_name
-  trunk.type_id == Card::SetID ? cardname.trunk_name.tag : nil
-end
-
-def you_cant what
-  "You don't have permission to #{what}"
-end
-
-def deny_because why
-  @permission_errors << why if @permission_errors
-  @action_ok = false
-end
-
-def permitted? action
-  return if Card.config.read_only
-  return true if action != :comment && Auth.always_ok?
-
-  permitted_ids = who_can action
-  if action == :comment && Auth.always_ok?
-    # admin can comment if anyone can
-    !permitted_ids.empty?
-  else
-    Auth.as_card.among? permitted_ids
-  end
-end
-
-def permit action, verb=nil
-  # not called by ok_to_read
-  deny_because "Currently in read-only mode" if Card.config.read_only
-
-  return if permitted? action
-  verb ||= action.to_s
-  deny_because you_cant("#{verb} #{name.present? ? name : 'this'}")
-end
-
-def ok_to_create
-  permit :create
-  return if !@action_ok || !junction?
-
-  [:left, :right].each do |side|
-    # left is supercard; create permissions will get checked there.
-    next if side == :left && @superleft
-    part_card = send side, new: {}
-    # if no card, there must be other errors
-    next unless part_card && part_card.new_card?
-    unless part_card.ok? :create
-      deny_because you_cant("create #{part_card.name}")
-    end
-  end
-end
-
-def ok_to_read
-  return if Auth.always_ok?
-  @read_rule_id ||= permission_rule_id_and_class(:read).first
-  return if Auth.as_card.read_rules.member? @read_rule_id
-  deny_because you_cant "read this"
-end
-
-def ok_to_update
-  permit :update
-  if @action_ok && type_id_changed? && !permitted?(:create)
-    deny_because you_cant("change to this type (need create permission)")
-  end
-  ok_to_read if @action_ok
-end
-
-def ok_to_delete
-  permit :delete
-end
-
-def ok_to_comment
-  permit :comment, "comment on"
-  return unless @action_ok
-  deny_because "No comments allowed on templates" if is_template?
-  deny_because "No comments allowed on structured content" if structure
-end
-
-event :clear_read_rule, :store, on: :delete do
-  self.read_rule_id = self.read_rule_class = nil
-end
-
-event :set_read_rule, :store,
-      on: :save, changed: [:type_id, :name] do
-  read_rule_id, read_rule_class = permission_rule_id_and_class(:read)
-  self.read_rule_id = read_rule_id
-  self.read_rule_class = read_rule_class
-end
-
-event :set_field_read_rules,
-      after: :set_read_rule, on: :update, changed: :type_id do
-  # find all cards with me as trunk and update their read_rule
-  # (because of *type plus right)
-  # skip if name is updated because will already be resaved
-
-  Auth.as_bot do
-    fields.each do |field|
-      field.refresh.update_read_rule
-    end
-  end
-end
-
-# currently doing a brute force search for every card that may be impacted.
-# may want to optimize(?)
-def update_field_read_rules
-  Auth.as_bot do
-    fields.each do |field|
-      field.update_read_rule if field.rule(:read) == "_left"
-    end
-  end
-end
-
-def without_timestamps
-  Card.record_timestamps = false
-  yield
-ensure
-  Card.record_timestamps = true
-end
-
-event :update_read_rule do
-  without_timestamps do
-    reset_patterns # why is this needed?
-    rcard_id, rclass = permission_rule_id_and_class :read
-    # these two are just to make sure vals are correct on current object
-    self.read_rule_id = rcard_id
-    self.read_rule_class = rclass
-    Card.where(id: id).update_all read_rule_id: rcard_id,
-                                  read_rule_class: rclass
-    expire_hard
-
-    update_field_read_rules
-  end
-end
-
-def add_to_read_rule_update_queue updates
-  @read_rule_update_queue = Array.wrap(@read_rule_update_queue).concat updates
-end
-
-event :check_permissions, :validate do
-  task =
-    if @action != :delete && comment # will be obviated by new comment handling
-      :comment
-    else
-      @action
-    end
-  track_permission_errors do
-    ok? task
-  end
-end
-
-def track_permission_errors
-  @permission_errors = []
-  result = yield
-
-  @permission_errors.each do |message|
-    errors.add :permission_denied, message
-  end
-  @permission_errors = nil
-
-  result
-end
-
-def recaptcha_on?
-  have_recaptcha_keys? &&
-    Env[:controller]   &&
-    !Auth.signed_in?   &&
-    !Auth.needs_setup? &&
-    !Auth.always_ok?   &&
-    Card.toggle(rule(:captcha))
-end
-
-def have_recaptcha_keys?
-  @@have_recaptcha_keys =
-    if defined?(@@have_recaptcha_keys)
-      @@have_recaptcha_keys
-    else
-      !!(Card.config.recaptcha_public_key && Card.config.recaptcha_private_key)
-    end
-end
-
-event :recaptcha, :validate do
-  if !@supercard && !Env[:recaptcha_used] && recaptcha_on?
-    Env[:recaptcha_used] = true
-    Env[:controller].verify_recaptcha model: self, attribute: :captcha
-  end
-end
-
-module Accounts
-  # This is a short-term hack that is used in account-related cards to allow a
-  # permissions pattern where permissions are restricted to the owner of the
-  # account (and, by default, Admin)
-  # That pattern should be permitted by our card representation
-  # (without creating separate rules for each account holder) but is not yet.
-
-  def permit action, verb=nil
-    if action == :comment then @action_ok = false
-    elsif action == :create  then @superleft ? true : super(action, verb)
-      # restricts account creation to subcard handling on permitted card
-      # (unless explicitly permitted)
-    elsif own_account? then true
-    else
-      super action, verb
-    end
-  end
-end
-
-module Follow
-  def ok_to_update
-    permit :update
-  end
-
-  def ok_to_create
-    permit :create
-  end
-
-  def ok_to_delete
-    permit :delete
-  end
-
-  def permit action, verb=nil
-    if [:create, :delete, :update].include?(action) && Auth.signed_in? &&
-       (user = rule_user) && Auth.current_id == user.id
-      return true
-    else
-      super action, verb
-    end
-  end
-end
-
-
-# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/permissions.rb ~~
-end;end;end;end;

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

@@ -1,23 +0,0 @@
-# -*- 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/rules.rb

@@ -1,311 +0,0 @@
-# -*- 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;