card 1.18.6 → 1.19.0

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

@@ -1,348 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; module All; module Name; extend Card::Set
-# ~~~~~~~~~~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/01_core/set/all/name.rb ~~~~~~~~~~~
-require 'uuid'
-
-module ClassMethods
-  def uniquify_name name, rename=:new
-    return name unless Card.exists?(name)
-    uniq_name = "#{name} 1"
-    while Card.exists?(uniq_name)
-      uniq_name.next!
-    end
-    if rename == :old
-      # name conflict resolved; original name can be used
-      Card[name].update_attributes! name: uniq_name,
-                                    update_referencers: true
-      name
-    else
-      uniq_name
-    end
-  end
-end
-
-def name= newname
-  cardname = newname.to_name
-  if @supercard
-    @supercard.subcards.rename key, cardname.key
-    @contextual_name = cardname.to_s
-    relparts = cardname.parts
-    if relparts.size == 2 &&
-       (relparts.first.blank? || relparts.first.to_name.key == @supercard.key)
-      @superleft = @supercard
-    end
-    cardname = cardname.to_absolute_name @supercard.name
-  end
-
-  newkey = cardname.key
-  if key != newkey
-    self.key = newkey
-    # reset the old name - should be handled in tracked_attributes!!
-    reset_patterns_if_rule
-    reset_patterns
-  end
-  subcards.each do |subcard|
-    subcard.name = subcard.cardname.replace_part name, newname
-  end
-
-  write_attribute :name, cardname.s
-end
-
-def cardname
-  name.to_name
-end
-
-def autoname name
-  if Card.exists? name
-    autoname name.next
-  else
-    name
-  end
-end
-
-# FIXME: use delegations and include all cardname functions
-def simple?
-  cardname.simple?
-end
-
-def junction?
-  cardname.junction?
-end
-
-def contextual_name
-  @contextual_name || name
-end
-
-def relative_name context_name=nil
-  if !context_name && @supercard
-    context_name = @supercard.cardname
-  end
-  cardname.relative_name(context_name)
-end
-
-def absolute_name context_name=nil
-  if !context_name && @supercard
-    context_name = @supercard.cardname
-  end
-  cardname.absolute_name(context_name)
-end
-
-def left *args
-  return if simple?
-  @superleft || begin
-    unless name_changed? &&
-           name.to_name.trunk_name.key == name_was.to_name.key
-      # prevent recursion when, eg, renaming A+B to A+B+C
-      Card.fetch cardname.left, *args
-    end
-  end
-end
-
-def right *args
-  Card.fetch(cardname.right, *args) if !simple?
-end
-
-def [] *args
-  case args[0]
-  when Fixnum, Range
-    fetch_name = Array.wrap(cardname.parts[args[0]]).compact.join '+'
-    Card.fetch(fetch_name, args[1] || {}) if !simple?
-  else
-    super
-  end
-end
-
-def trunk *args
-  simple? ? self : left(*args)
-end
-
-def tag *args
-  simple? ? self : Card.fetch(cardname.right, *args)
-end
-
-def left_or_new args={}
-  left(args) || Card.new(args.merge(name: cardname.left))
-end
-
-def fields
-  field_names.map { |name| Card[name] }
-end
-
-def field_names parent_name=nil
-  child_names parent_name, :left
-end
-
-def children
-  child_names.map { |name| Card[name] }
-end
-
-def child_names parent_name=nil, side=nil
-  # eg, A+B is a child of A and B
-  parent_name ||= name
-  side ||= parent_name.to_name.simple? ? :part : :left
-  Card.search({ side => parent_name, return: :name },
-              "(#{side}) children of #{parent_name}")
-end
-
-def descendant_names parent_name=nil
-  return [] if new_card?
-  parent_name ||= name
-  Auth.as_bot do
-    deps = child_names parent_name
-    deps.inject(deps) do |array, childname|
-      array + descendant_names(childname)
-    end
-  end
-end
-
-def descendants
-  # children and children's children
-  # NOTE - set modules are not loaded
-  # -- should only be used for name manipulations
-  @descendants ||= descendant_names.map { |name| Card.quick_fetch name }
-end
-
-def repair_key
-  Auth.as_bot do
-    correct_key = cardname.key
-    current_key = key
-    return self if current_key == correct_key
-
-    if (key_blocker = Card.find_by_key_and_trash(correct_key, true))
-      key_blocker.cardname = key_blocker.cardname + "*trash#{rand(4)}"
-      key_blocker.save
-    end
-
-    saved =   (self.key      = correct_key) && self.save!
-    saved ||= (self.cardname = current_key) && self.save!
-
-    if saved
-      descendants.each(&:repair_key)
-    else
-      Rails.logger.debug "FAILED TO REPAIR BROKEN KEY: #{key}"
-      self.name = "BROKEN KEY: #{name}"
-    end
-    self
-  end
-rescue
-  Rails.logger.info "BROKE ATTEMPTING TO REPAIR BROKEN KEY: #{key}"
-  self
-end
-
-event :permit_codename, before: :approve, on: :update, changed: :codename do
-  errors.add :codename, 'only admins can set codename' unless Auth.always_ok?
-end
-
-event :validate_unique_codename, after: :permit_codename do
-  if codename.present? && errors.empty? &&
-     Card.find_by_codename(codename).present?
-    errors.add :codename, "codename #{codename} already in use"
-  end
-end
-
-event :validate_name, before: :approve, on: :save do
-  cdname = name.to_name
-  if name.length > 255
-    errors.add :name, 'is too long (255 character maximum)'
-  elsif cdname.blank?
-    errors.add :name, "can't be blank"
-  elsif name_changed?
-    # Rails.logger.debug "valid name #{card.name.inspect} New #{name.inspect}"
-
-    unless cdname.valid?
-      errors.add :name, 'may not contain any of the following characters: ' \
-                        "#{ Card::Name.banned_array * ' ' }"
-    end
-    # this is to protect against using a plus card as a tag
-    if cdname.junction? && simple? && id &&
-       Auth.as_bot { Card.count_by_wql right_id: id } > 0
-      errors.add :name, "#{name} in use as a tag"
-    end
-
-    # validate uniqueness of name
-    condition_sql = 'cards.key = ? and trash=?'
-    condition_params = [cdname.key, false]
-    unless new_record?
-      condition_sql << ' AND cards.id <> ?'
-      condition_params << id
-    end
-    if (c = Card.find_by(condition_sql, *condition_params))
-      errors.add :name, "must be unique; '#{c.name}' already exists."
-    end
-  end
-end
-
-event :set_autoname, before: :validate_name, on: :create do
-  if name.blank? && (autoname_card = rule_card(:autoname))
-    self.name = autoname autoname_card.content
-    # FIXME: should give placeholder in approve phase
-    # and finalize/commit change in store phase
-    autoname_card.refresh.update_column :db_content, name
-  end
-end
-
-event :validate_key, after: :validate_name, on: :save do
-  if key.empty?
-    errors.add :key, 'cannot be blank' if errors.empty?
-  elsif key != cardname.key
-    errors.add :key, "wrong key '#{key}' for name #{name}"
-  end
-end
-
-event :set_name, before: :store, changed: :name do
-  Card.expire name
-  Card.expire name_was
-  if cardname.junction?
-    [:left, :right].each do |side|
-      sidename = cardname.send "#{side}_name"
-      # warn "sidename #{name} / #{name_was} / #{cardname},
-      # #{side}: #{sidename}"
-      sidecard = Card[sidename]
-
-      # eg, renaming A to A+B
-      old_name_in_way = (sidecard && sidecard.id == id)
-      suspend_name(sidename) if old_name_in_way
-      send "#{side}_id=", begin
-        if !sidecard || old_name_in_way
-          Card.create! name: sidename, supercard: self
-        else
-          sidecard
-        end.id
-      end
-    end
-  else
-    self.left_id = self.right_id = nil
-  end
-end
-
-event :rename, after: :set_name, on: :update do
-  if (existing_card = Card.find_by_key_and_trash(cardname.key, true)) &&
-     existing_card != self
-    existing_card.name = existing_card.name + '*trash'
-    existing_card.rename_without_callbacks
-    existing_card.save!
-  end
-end
-
-def suspend_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.expire name
-  tmp_name = 'tmp:' + UUID.new.generate
-  Card.where(id: id).update_all(name: tmp_name, key: tmp_name)
-end
-
-event :cascade_name_changes, after: :store, on: :update, changed: :name do
-  # Rails.logger.info "------------------- #{name_was} CASCADE #{self.name} " \
-  #                   " -------------------------------------"
-  # handle strings from cgi
-  self.update_referencers = false if update_referencers == 'false'
-  Card::Reference.update_on_rename self, name, self.update_referencers
-
-  des = descendants
-  @descendants = nil # reset
-
-  des.each do |de|
-    # here we specifically want NOT to invoke recursive cascades on these
-    # cards, have to go this low level to avoid callbacks.
-    Rails.logger.info "cascading name: #{de.name}"
-    Card.expire de.name # old name
-    newname = de.cardname.replace_part name_was, name
-    Card.where(id: de.id).update_all name: newname.to_s, key: newname.key
-    Card::Reference.update_on_rename de, newname, update_referencers
-    Card.expire newname
-  end
-  execute_referencers_update(des) if update_referencers
-end
-
-def execute_referencers_update descendants
-  Auth.as_bot do
-    [name_referencers(name_was) + descendants.map(&:referencers)]
-      .flatten.uniq.each do |card|
-      # FIXME:  using 'name_referencers' instead of plain 'referencers' for self
-      # because there are cases where trunk and tag
-      # have already been saved via association by this point and therefore
-      # referencers misses things
-      # eg.  X includes Y, and Y is renamed to X+Z.  When X+Z is saved, X is
-      # first updated as a trunk before X+Z gets to this point.
-      # so at this time X is still including Y, which does not exist.
-      # therefore #referencers doesn't find it, but name_referencers(old_name)
-      # does.
-      # some even more complicated scenario probably breaks on the descendants,
-      # so this probably needs a more thoughtful refactor
-      # aligning the dependent saving with the name cascading
-
-      Rails.logger.debug "------------------ UPDATE REFERER #{card.name} " \
-                         '------------------------'
-      unless card == self || card.structure
-        card = card.refresh
-        card.db_content = card.replace_references name_was, name
-        card.save!
-      end
-    end
-  end
-end
-
-
-# ~~~~~~~~~~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/01_core/set/all/name.rb ~~~~~~~~~~~
-end;end;end;end;

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

@@ -1,64 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; module All; module Pattern; extend Card::Set
-# ~~~~~~~~~~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/01_core/set/all/pattern.rb ~~~~~~~~~~~
-
-def patterns
-  @patterns ||= set_patterns.map { |sub| sub.new(self) }.compact
-end
-
-def patterns_with_new
-  new_card? ? patterns_without_new[1..-1] : patterns_without_new
-end
-alias_method_chain :patterns, :new
-
-def reset_patterns
-  @set_mods_loaded = @patterns = @set_modules = @junction_only = @set_names = @template = @rule_set_keys = @virtual = nil
-  true
-end
-
-def reset_patterns_if_rule saving=false
-  if !new_card? && is_rule?
-    set = left
-    set.reset_patterns
-    set.include_set_modules
-
-    # FIXME: should be in right/read.rb
-    if saving && right.id == Card::ReadID
-      self.add_to_read_rule_update_queue(set.item_cards limit: 0)
-    end
-  end
-end
-
-def safe_set_keys
-  patterns.map(&:safe_key).reverse * " "
-end
-
-def set_modules
-  @set_modules ||=
-    patterns_without_new[0..-2].reverse.map(&:module_list).flatten.compact
-end
-
-def set_format_modules klass
-  @set_format_modules ||= {}
-  @set_format_modules[klass] =
-    patterns_without_new[0..-2].reverse.map do |pattern|
-      pattern.format_module_list klass
-    end.flatten.compact
-end
-
-def set_names
-  if @set_names.nil?
-    @set_names = patterns.map &:to_s
-    Card.set_members @set_names, key
-  end
-  @set_names
-end
-
-def rule_set_keys
-  set_names # this triggers set_members cache.  need better solution!
-  @rule_set_keys ||= patterns.map(&:rule_set_key).compact
-end
-
-
-# ~~~~~~~~~~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/01_core/set/all/pattern.rb ~~~~~~~~~~~
-end;end;end;end;

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

@@ -1,298 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; module All; module Permissions; extend Card::Set
-# ~~~~~~~~~~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/01_core/set/all/permissions.rb ~~~~~~~~~~~
-
-Card.error_codes.merge! permission_denied: [:denial, 403],
-                        captcha: [:errors, 449]
-
-# 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::PermissionDenied.new 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::PermissionDenied.new(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 and 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.among? permitted_ids
-  end
-end
-
-def permit action, verb=nil
-  if Card.config.read_only # not called by ok_to_read
-    deny_because 'Currently in read-only mode'
-  end
-
-  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 part_card && part_card.new_card? # if no card, there must be other errors
-      unless part_card.ok? :create
-        deny_because you_cant("create #{part_card.name}")
-      end
-    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, before: :store, on: :delete do
-  self.read_rule_id = self.read_rule_class = nil
-end
-
-event :set_read_rule, before: :store, on: :save do
-  # avoid doing this on simple content saves?
-  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
-
-def update_read_rule
-  Card.record_timestamps = false
-  reset_patterns # why is this needed?
-  rcard, rclass = permission_rule_card :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
-
-  # currently doing a brute force search for every card that may be impacted.
-  # may want to optimize(?)
-  Auth.as_bot do
-    fields.each do |field|
-      if field.rule(:read) == '_left'
-        field.update_read_rule
-      end
-    end
-  end
-
-ensure
-  Card.record_timestamps = true
-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, after: :approve 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, before: :approve 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
-    case
-    when action == :comment then @action_ok = false
-    when action == :create  then @superleft ? true : super(action, verb)
-      # restricts account creation to subcard handling on permitted card
-      # (unless explicitly permitted)
-    when 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/01_core/set/all/permissions.rb ~~~~~~~~~~~
-end;end;end;end;