card 1.16.15 → 1.17.0

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

@@ -4,18 +4,20 @@ class Card; module Set; module All; module Name; extend Card::Set
 require 'uuid'
 
 module ClassMethods
-  def uniquify_name name, rename=false
-    return name unless Card[name]
+  def uniquify_name name, rename=:new
+    return name unless Card.exists?(name)
     uniq_name = "#{name} 1"
-    while Card[uniq_name]
+    while Card.exists?(uniq_name)
       uniq_name.next!
     end
-    return uniq_name unless rename
-
-    Card[name].update_attributes! name: uniq_name,
-                                  update_referencers: true
-    # name conflict resolved; original name can be used
-    name
+    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
 
@@ -122,24 +124,42 @@ 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
-  Card.search((simple? ? :part : :left) => name).to_a
+  child_names.map { |name| Card[name] }
 end
 
-def dependents
-  return [] if new_card?
+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
 
-  if @dependents.nil?
-    @dependents =
-      Auth.as_bot do
-        deps = children
-        deps.inject(deps) do |array, card|
-          array + card.dependents
-        end
-      end
-    # Rails.logger.warn "dependents[#{inspect}] #{@dependents.inspect}"
+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
-  @dependents
+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
@@ -157,7 +177,7 @@ def repair_key
     saved ||= (self.cardname = current_key) && self.save!
 
     if saved
-      dependents.each(&:repair_key)
+      descendants.each(&:repair_key)
     else
       Rails.logger.debug "FAILED TO REPAIR BROKEN KEY: #{key}"
       self.name = "BROKEN KEY: #{name}"
@@ -215,8 +235,9 @@ 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 on new, do next and save on create
-    Auth.as_bot { autoname_card.refresh.update_attributes! content: name }
+    # FIXME: should give placeholder in approve phase
+    # and finalize/commit change in store phase
+    autoname_card.refresh.update_column :db_content, name
   end
 end
 
@@ -278,28 +299,25 @@ event :cascade_name_changes, after: :store, on: :update, changed: :name do
   self.update_referencers = false if update_referencers == 'false'
   Card::Reference.update_on_rename self, name, self.update_referencers
 
-  deps = dependents
-  # warn "-------------------#{name_was}---- CASCADE #{self.name} -> deps: " \
-  #      " #{deps.map(&:name)*', '} -----------------------"
-
-  @dependents = nil # reset
+  des = descendants
+  @descendants = nil # reset
 
-  deps.each do |dep|
+  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: #{dep.name}"
-    Card.expire dep.name # old name
-    newname = dep.cardname.replace_part name_was, name
-    Card.where(id: dep.id).update_all name: newname.to_s, key: newname.key
-    Card::Reference.update_on_rename dep, newname, update_referencers
+    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(deps) if update_referencers
+  execute_referencers_update(des) if update_referencers
 end
 
-def execute_referencers_update dependents
+def execute_referencers_update descendants
   Auth.as_bot do
-    [name_referencers(name_was) + dependents.map(&:referencers)]
+    [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
@@ -310,7 +328,7 @@ def execute_referencers_update dependents
       # 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 dependents,
+      # 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
 

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

@@ -22,26 +22,28 @@ def reset_patterns_if_rule saving=false
     set.reset_patterns
     set.include_set_modules
 
-    #this is really messy.
-    if saving
-      self.add_to_read_rule_update_queue( set.item_cards limit: 0 ) if right.id == Card::ReadID
+    # 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 * " "
+  patterns.map(&:safe_key).reverse * " "
 end
 
 def set_modules
-  @set_modules ||= patterns_without_new[0..-2].reverse.map(&:module_list).flatten.compact
+  @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
+  @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
@@ -53,11 +55,10 @@ def 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
+  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

@@ -2,17 +2,17 @@
 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]
-
+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.
-
+#      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
@@ -24,39 +24,50 @@ def ok_with_fetch? action, opts={}
   card = opts[:trait].nil? ? self : fetch(opts)
   card && card.ok_without_fetch?(action)
 end
-alias_method_chain :ok?, :fetch # note: method is chained so that we can return the instance variable @action_ok
 
+# 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).first.item_cards.map &:id
+  # 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 permission_rule_card action
-  opcard = rule_card action
-
-  unless opcard # 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
-
-  rcard = Auth.as_bot do
-    if ['_left','[[_left]]'].member?(opcard.db_content) && self.junction?  # compound cards can inherit permissions from left parent
-      lcard = left_or_new( skip_virtual: true, skip_modules: true )
-      if action==:create && lcard.real? && !lcard.action==:create
-        action = :update
-      end
-      lcard.permission_rule_card(action).first
-    else
-      opcard
+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
-  return rcard, opcard.rule_class_name
+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
@@ -67,67 +78,61 @@ 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?
 
-  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
+  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"
+    deny_because 'Currently in read-only mode'
   end
 
+  return if permitted? action
   verb ||= action.to_s
-  unless permitted? action
-    deny_because you_cant("#{verb} #{name.present? ? name : 'this'}")
-  end
+  deny_because you_cant("#{verb} #{name.present? ? name : 'this'}")
 end
 
 def ok_to_create
   permit :create
-  if @action_ok and junction?
-    [:left, :right].each do |side|
-      next if side==:left && @superleft   # left is supercard; create permissions will get checked there.
-      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
+  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
-  if !Auth.always_ok?
-    @read_rule_id ||= permission_rule_card(:read).first.id.to_i
-    if !Auth.as_card.read_rules.member? @read_rule_id
-      deny_because you_cant "read this"
-    end
-  end
+  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 and type_id_changed? and !permitted? :create
-    deny_because you_cant( "change to this type (need create permission)" )
+  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
@@ -138,51 +143,51 @@ end
 
 def ok_to_comment
   permit :comment, 'comment on'
-  if @action_ok
-    deny_because "No comments allowed on templates" if is_template?
-    deny_because "No comments allowed on structured content" if structure
-  end
+  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 do
-  if trash == true
-    self.read_rule_id = self.read_rule_class = nil
-  else
-    # avoid doing this on simple content saves?
-    rcard, rclass = permission_rule_card(:read)
-    self.read_rule_id = rcard.id
-    self.read_rule_class = rclass
-    #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
-
-    if !new_card? && type_id_changed?
-      Auth.as_bot do
-        Card.search(left: self.name).each do |plus_card|
-          plus_card = plus_card.refresh.update_read_rule
-        end
-      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
-  self.read_rule_id = rcard.id #these two are just to make sure vals are correct on current object
-  #warn "updating read rule for #{inspect} to #{rcard.inspect}, #{rclass}"
-
+  # 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: self.id).update_all(read_rule_id: rcard.id, read_rule_class: rclass)
-  expire
+  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(?)
+  # currently doing a brute force search for every card that may be impacted.
+  # may want to optimize(?)
   Auth.as_bot do
-    Card.search(left: self.name).each do |plus_card|
-      if plus_card.rule(:read) == '_left'
-        plus_card.update_read_rule
+    fields.each do |field|
+      if field.rule(:read) == '_left'
+        field.update_read_rule
       end
     end
   end
@@ -191,17 +196,18 @@ 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
+  task =
+    if @action != :delete && comment # will be obviated by new comment handling
+      :comment
+    else
+      @action
+    end
   track_permission_errors do
     ok? task
   end
@@ -219,19 +225,22 @@ def track_permission_errors
   result
 end
 
-
 def recaptcha_on?
   have_recaptcha_keys? &&
-  Env[:controller]     &&
-  !Auth.signed_in?     &&
-  !Auth.needs_setup?   &&
-  !Auth.always_ok?     &&
-  Card.toggle( rule :captcha )
+    Env[:controller]   &&
+    !Auth.signed_in?   &&
+    !Auth.needs_setup? &&
+    !Auth.always_ok?   &&
+    Card.toggle(rule :captcha)
 end
 
 def have_recaptcha_keys?
-  @@have_recaptcha_keys = defined?(@@have_recaptcha_keys) ? @@have_recaptcha_keys :
-    !!( Card.config.recaptcha_public_key && Card.config.recaptcha_private_key )
+  @@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
@@ -242,21 +251,23 @@ event :recaptcha, before: :approve do
 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.
+  # 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  ; @action_ok = false
-    when action==:create   ; @superleft ? true : super( action, verb )
-      #restricts account creation to subcard handling on permitted card (unless explicitly permitted)
-    when is_own_account?   ; true
-    else                   ; super action, verb
+    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
@@ -274,17 +285,14 @@ module Follow
 
   def permit action, verb=nil
     if [:create, :delete, :update].include?(action) && Auth.signed_in? &&
-        (user = rule_user) && Auth.current_id == user.id
+       (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;