card 1.91 → 1.92

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

@@ -0,0 +1,282 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All; module Name; extend Card::Set
+# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/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"
+    uniq_name.next! while Card.exists?(uniq_name)
+    if rename == :old
+      # name conflict resolved; original name can be used
+      Card[name].update_attributes! name: uniq_name,
+                                    update_referers: 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
+  self.key = newkey if key != newkey
+  update_subcard_names cardname
+  write_attribute :name, cardname.s
+end
+
+def key= newkey
+  was_in_cache = Card.cache.soft.delete key
+  write_attribute :key, newkey
+  # keep the soft cache up-to-date
+  Card.write_to_soft_cache self if was_in_cache
+  # reset the old name - should be handled in tracked_attributes!!
+  reset_patterns_if_rule
+  reset_patterns
+  newkey
+end
+
+def update_subcard_names cardname
+  return unless @subcards
+  subcards.each do |subcard|
+    # if subcard has a relative name like +C
+    # and self is a subcard as well that changed from +B to A+B then
+    # +C should change to A+B+C. #replace_part doesn't work in this case
+    # because the old name +B is not a part of +C
+    name_to_replace =
+      if subcard.cardname.junction? &&
+         subcard.cardname.parts.first.empty? &&
+         cardname.parts.first.present?
+        # replace the empty part
+        "".to_name
+      else
+        name
+      end
+    subcard.name = subcard.cardname.replace_part name_to_replace, cardname.s
+  end
+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
+  context_name ||= @supercard.cardname if @supercard
+  cardname.relative_name context_name
+end
+
+def absolute_name context_name=nil
+  context_name ||= @supercard.cardname if @supercard
+  cardname.absolute_name context_name
+end
+
+def left *args
+  case
+  when simple?    then nil
+  when @superleft then @superleft
+  when name_changed? && name.to_name.trunk_name.key == name_was.to_name.key
+    nil # prevent recursion when, eg, renaming A+B to A+B+C
+  else
+    Card.fetch cardname.left, *args
+  end
+end
+
+def right *args
+  Card.fetch(cardname.right, *args) unless 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] || {}) unless 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
+
+# ids of children and children's children
+def descendant_ids parent_id=nil
+  return [] if new_card?
+  parent_id ||= id
+  Auth.as_bot do
+    child_ids = Card.search part: parent_id, return: :id
+    child_descendant_ids = child_ids.map { |cid| descendant_ids cid }
+    (child_ids + child_descendant_ids).flatten.uniq
+  end
+end
+
+# children and children's children
+# NOTE - set modules are not loaded
+# -- should only be used for name manipulations
+def descendants
+  @descendants ||= descendant_ids.map { |id| Card.quick_fetch id }
+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) && save!
+    saved ||= (self.cardname = current_key) && 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 :set_autoname, :prepare_to_validate, 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 :set_name, :store, changed: :name do
+  Card.expire name
+  Card.expire name_was
+end
+
+event :set_left_and_right, :store,
+      changed: :name, on: :save do
+  if cardname.junction?
+    [:left, :right].each do |side|
+      sidename = cardname.send "#{side}_name"
+      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
+      side_id_or_card =
+        if !sidecard || old_name_in_way
+          add_subcard(sidename.s)
+        else
+          sidecard.id
+        end
+      send "#{side}_id=", side_id_or_card
+    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, :finalize, on: :update, changed: :name do
+  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
+    de.update_referers = update_referers
+    de.refresh_references_in
+    Card.expire newname
+  end
+end
+
+
+# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/name.rb ~~
+end;end;end;end;

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

@@ -0,0 +1,65 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All; module NameValidations; extend Card::Set
+# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/name_validations.rb ~~
+event :permit_codename, :validate,
+      on: :update, changed: :codename do
+  errors.add :codename, "only admins can set codename" unless Auth.always_ok?
+  validate_uniqueness_of_codename
+end
+
+event :validate_uniqueness_of_codename do
+  return unless codename.present? && errors.empty? &&
+                Card.find_by_codename(codename).present?
+  errors.add :codename, "codename #{codename} already in use"
+end
+
+event :validate_name, :validate,
+      on: :save, changed: :name do
+  validate_legality_of_name
+  return if errors.any?
+  validate_uniqueness_of_name
+end
+
+event :validate_uniqueness_of_name do
+  # validate uniqueness of name
+  condition_sql = "cards.key = ? and trash=?"
+  condition_params = [cardname.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
+
+event :validate_legality_of_name do
+  if name.length > 255
+    errors.add :name, "is too long (255 character maximum)"
+  elsif cardname.blank?
+    errors.add :name, "can't be blank"
+  elsif cardname.parts.include? ""
+    errors.add :name, "is incomplete"
+  else
+    unless cardname.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
+    return unless cardname.junction? && simple? && id &&
+                  Auth.as_bot { Card.count_by_wql right_id: id } > 0
+    errors.add :name, "#{name} in use as a tag"
+  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
+
+
+# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/name_validations.rb ~~
+end;end;end;end;

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

@@ -0,0 +1,67 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All; module Pattern; extend Card::Set
+# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/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
+  @patterns = nil
+  @template = @virtual = nil
+  @set_mods_loaded = @set_modules = @set_names = @rule_set_keys = nil
+  @junction_only = nil # only applies to set cards
+  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
+      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
+  @set_names = patterns.map(&:to_s) if @set_names.nil?
+  @set_names
+end
+
+def in_set? set_module
+  patterns.map(&:module_key).include? set_module.shortname
+end
+
+def rule_set_keys
+  @rule_set_keys ||= patterns.map(&:rule_set_key).compact
+end
+
+
+# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/pattern.rb ~~
+end;end;end;end;

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

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