wagn 1.12.13 → 1.13.0.pre

data/mods/core/sets/all/initialize.rb

@@ -21,6 +21,8 @@ def initialize args={}
     :type_id   => args[       'type_id'  ]
   }
 
+  #FIXME -- too much of the above is duplicated by assign_attributes (tracked_attributes.rb)
+
   @supercard = args.delete 'supercard' # must come before name =
   skip_modules = args.delete 'skip_modules'
 

data/mods/core/sets/all/name.rb

@@ -1,3 +1,4 @@
+require 'uuid'
 
 def name= newname
   cardname = newname.to_name
@@ -14,12 +15,12 @@ def name= newname
     reset_patterns_if_rule # reset the old name - should be handled in tracked_attributes!!
     reset_patterns
   end
-  if @subcards
-    @subcards.each do |subkey, subcard|
-      next if Symbol===subkey
-      subcard.name = subkey.to_name.to_absolute cardname
-    end
+  
+  subcards.each do |subkey, subcard|
+    next unless Card===subcard
+    subcard.name = subkey.to_name.to_absolute cardname
   end
+  
   super cardname.s
 end
 
@@ -85,7 +86,7 @@ def dependents
 
   if @dependents.nil?
     @dependents =
-      Account.as_bot do
+      Auth.as_bot do
         deps = children
         deps.inject(deps) do |array, card|
           array + card.dependents
@@ -97,7 +98,7 @@ def dependents
 end
 
 def repair_key
-  Account.as_bot do
+  Auth.as_bot do
     correct_key = cardname.key
     current_key = key
     return self if current_key==correct_key
@@ -125,7 +126,7 @@ end
 
 
 event :permit_codename, :before=>:approve, :on=>:update, :changed=>:codename do
-  errors.add :codename, 'only admins can set codename' unless Account.always_ok?
+  errors.add :codename, 'only admins can set codename' unless Auth.always_ok?
 end
 
 event :validate_unique_codename, :after=>:permit_codename do
@@ -146,7 +147,7 @@ event :validate_name, :before=>:approve, :on=>:save do
       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? and simple? and id and Account.as_bot { Card.count_by_wql :right_id=>id } > 0
+    if cdname.junction? and simple? and id and Auth.as_bot { Card.count_by_wql :right_id=>id } > 0
       errors.add :name, "#{name} in use as a tag"
     end
 
@@ -167,14 +168,14 @@ end
 event :set_autoname, :before=>:validate_name, :on=>:create do
   if name.blank? and autoname_card = rule_card(:autoname)
     self.name = autoname autoname_card.content
-    Account.as_bot { autoname_card.refresh.update_attributes! :content=>name }   #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 on new, do next and save on create
   end
 end
 
 
 event :validate_key, :after=>:validate_name, :on=>:save do
   if key.empty?
-    errors.add :key, "cannot be blank"
+    errors.add :key, "cannot be blank" if errors.empty?
   elsif key != cardname.key
     errors.add :key, "wrong key '#{key}' for name #{name}"
   end
@@ -245,7 +246,7 @@ event :cascade_name_changes, :after=>:store, :on=>:update, :changed=>:name do
   end
 
   if update_referencers
-    Account.as_bot do
+    Auth.as_bot do
       [self.name_referencers(name_was)+(deps.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

data/mods/core/sets/all/pattern.rb

@@ -1,15 +1,6 @@
-# -*- encoding : utf-8 -*-
 MODULES={}
 
 module ClassMethods
-  
-  def method_key opts
-    set_patterns.each do |pclass|
-      if !pclass.opt_keys.map(&opts.method(:has_key?)).member? false;
-        return pclass.method_key_from_opts(opts)
-      end
-    end
-  end
 
   def find_set_pattern mark
     if mark

data/mods/core/sets/all/permissions.rb

@@ -1,4 +1,3 @@
-# -*- encoding : utf-8 -*-
 
 Card.error_codes.merge! :permission_denied=>[:denial, 403], :captcha=>[:error,449]
 
@@ -29,10 +28,6 @@ def ok! action, opts={}
   raise Card::PermissionDenied.new self unless ok? action, opts
 end
 
-def update_account_ok? #FIXME - temporary API, I think this is fixed, can we cache any of this for speed, this is accessed for each header
-  id == Account.current_id or ok?( :update, :trait=>:account )
-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
@@ -47,8 +42,8 @@ def permission_rule_card action
     raise Card::PermissionDenied.new(self)
   end
 
-  rcard = Account.as_bot do
-    if opcard.content == '_left' && self.junction?  # compound cards can inherit permissions from left parent
+  rcard = Auth.as_bot do
+    if ['_left','[[_left]]'].member?(opcard.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
@@ -71,24 +66,22 @@ end
 
 
 def deny_because why
-  [why].flatten.each do |message|
-    errors.add :permission_denied, message
-  end
+  @permission_errors << why if @permission_errors
   @action_ok = false
 end
 
 def permitted? action
 
   if !Wagn.config.read_only
-    return true if action != :comment and Account.always_ok?
+    return true if action != :comment and Auth.always_ok?
 
     permitted_ids = who_can action
 
-    if action == :comment && Account.always_ok?
+    if action == :comment && Auth.always_ok?
       # admin can comment if anyone can
       !permitted_ids.empty?
     else
-      Account.among? permitted_ids
+      Auth.among? permitted_ids
     end
   end
 end
@@ -100,16 +93,17 @@ def permit action, verb=nil
   
   verb ||= action.to_s
   unless permitted? action
-    deny_because you_cant("#{verb} this card")
+    deny_because you_cant("#{verb} #{name.present? ? name : 'this'}")
   end
 end
 
 def ok_to_create
   permit :create
-  if junction?
+  if @action_ok and junction?
     [:left, :right].each do |side|
-      part_card = send side, :new=>{}
-      if part_card && part_card.new_card? #if no card, there must be other errors
+      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
@@ -119,10 +113,10 @@ def ok_to_create
 end
 
 def ok_to_read
-  if !Account.always_ok?
+  if !Auth.always_ok?
     @read_rule_id ||= permission_rule_card(:read).first.id.to_i
-    if !Account.as_card.read_rules.member? @read_rule_id
-      deny_because you_cant "read this card"
+    if !Auth.as_card.read_rules.member? @read_rule_id
+      deny_because you_cant "read this"
     end
   end
 end
@@ -142,8 +136,8 @@ end
 def ok_to_comment
   permit :comment, 'comment on'
   if @action_ok
-    deny_because "No comments allowed on template cards" if is_template?
-    deny_because "No comments allowed on hard templated cards" if structure
+    deny_because "No comments allowed on templates" if is_template?
+    deny_because "No comments allowed on structured content" if structure
   end
 end
 
@@ -160,7 +154,7 @@ event :set_read_rule, :before=>:store do
     # skip if name is updated because will already be resaved
 
     if !new_card? && type_id_changed?
-      Account.as_bot do
+      Auth.as_bot do
         Card.search(:left=>self.name).each do |plus_card|
           plus_card = plus_card.refresh.update_read_rule
         end
@@ -182,7 +176,7 @@ def update_read_rule
   expire
 
   # currently doing a brute force search for every card that may be impacted.  may want to optimize(?)
-  Account.as_bot do
+  Auth.as_bot do
     Card.search(:left=>self.name).each do |plus_card|
       if plus_card.rule(:read) == '_left'
         plus_card.update_read_rule
@@ -200,26 +194,57 @@ end
 
 
 event :check_permissions, :after=>:approve do
-  act = if @action != :delete && comment #will be obviated by new comment handling
+  task = if @action != :delete && comment #will be obviated by new comment handling
     :comment
   else
     @action
   end
-  ok? act
+  
+  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
 
 event :recaptcha, :before=>:approve do
   if !@supercard                        and
-      Wagn::Env[:recaptcha_on]          and
+      Env.recaptcha_on?                 and
       Card.toggle( rule :captcha )      and
-      num = Wagn::Env[:recaptcha_count] and
+      num = Card::Env[:recaptcha_count] and
       num < 1
       
-    Wagn::Env[:recaptcha_count] = num + 1
-    Wagn::Env[:controller].verify_recaptcha :model=>self, :attribute=>:captcha
+    Env[:recaptcha_count] = num + 1
+    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  ; @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
+    end
+  end
+  
+end
+  
 

data/mods/core/sets/all/phases.rb

@@ -1,21 +1,36 @@
 
-def save
-  super
+def valid_subcard?
+  abortable { valid? }
+end
+
+def abortable
+  yield
 rescue Card::Abort => e
+  # need mechanism for subcards to abort entire process?
   e.status == :success
 end
 
-def abort status=:failure, msg='save canceled'
+
+# this is an override of standard rails behavior that rescues abortmakes 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
+
+def abort status=:failure, msg='action canceled'
+  if status == :failure && errors.empty?
+    errors.add :abort, msg
+  end
   raise Card::Abort.new( status, msg)
 end
 
 def approve
-  #warn "approve called for #{name}!"
-  @action = case
-    when trash     ; :delete
-    when new_card? ; :create
-    else             :update
-    end
+  @action = identify_action
 
   # the following should really happen when type, name etc are changed
   reset_patterns
@@ -28,6 +43,13 @@ rescue Exception=>e
   rescue_event e
 end
 
+def identify_action
+  case
+  when trash     ; :delete
+  when new_card? ; :create
+  else             :update
+  end
+end
 
 def store
   run_callbacks :store do
@@ -54,8 +76,9 @@ end
 def rescue_event e
   @action = nil
   expire_pieces
-  if @subcards
-    @subcards.each { |key, card| card.expire_pieces }
+  subcards.each do |key, card|
+    next unless Card===card
+    card.expire_pieces
   end
   raise e
 #rescue Card::Cancel
@@ -75,98 +98,54 @@ def event_applies? opts
   true
 end
 
+def subcards
+  @subcards ||= {}
+end
+
+
 event :process_subcards, :after=>:approve, :on=>:save do
-  @subcards = {}
-  (cards || {}).each do |sub_name, opts|
-    next if sub_name.to_name.key == key # don't resave self!
+  
+  subcards.keys.each do |sub_name|
+    opts = @subcards[sub_name]
+    ab_name = sub_name.to_name.to_absolute_name name
+    next if ab_name.key == key # don't resave self!
+
 
-    opts[:supercard] = self    
-    subcard = if known_card = Card[sub_name]
+    opts = opts.stringify_keys
+    opts['subcards'] = extract_subcard_args! opts
+
+    opts[:supercard] = self
+    
+    subcard = if known_card = Card[ab_name]
       known_card.refresh.assign_attributes opts
       known_card
-    elsif opts[:content].present? and opts[:content].strip.present?
-      Card.new opts.merge :name => sub_name
+    elsif opts['subcards'].present? or (opts['content'].present? and opts['content'].strip.present?)
+      Card.new opts.reverse_merge 'name' => sub_name
     end
 
-    @subcards[sub_name] = subcard if subcard
+    if subcard
+      @subcards[sub_name] = subcard
+    else
+      @subcards.delete sub_name
+    end
   end
 end
 
 event :approve_subcards, :after=>:process_subcards do
-  @subcards.each do |key, subcard|
-    if !subcard.valid?
+  subcards.each do |key, subcard|
+    if !subcard.valid_subcard?
       subcard.errors.each do |field, err|
-        errors.add field, "#{subcard.relative_name}: #{err}"
+        err = "#{field} #{err}" unless [:content, :abort].member? field
+        errors.add subcard.relative_name, err
       end
     end
   end
 end
 
 event :store_subcards, :after=>:store do
-  @subcards.each do |key, sub|
+  subcards.each do |key, sub|
     sub.save! :validate=>false
   end
 end
 
-#~~~~~~~~~~~~~~~~
-# EXPERIMENTAL
-# the following methods are for visualing card events
-#  not ready for prime time!
-
-def events action
-  @action = action
-  root = _validate_callbacks + _save_callbacks
-  events = [ events_tree(:validation), events_tree(:save)]
-  @action = nil
-  puts_events events
-end
-
-private
-
-def puts_events events, prefix='', depth=0
-  r = ''
-  depth += 1
-  events.each do |e|
-    space = ' ' * (depth * 2)
-
-    #FIXME - this is not right.  before and around callbacks are processed in declaration order regardless of kind.
-    # not all befores then all arounds
-    
-    if e[:before]
-      r += puts_events( e[:before], space+'v  ', depth)
-    end
-    if e[:around]
-      r += puts_events( e[:around], space+'vv ', depth )
-    end
-    
-    
-    output = "#{prefix}#{e[:name]}"
-    warn output
-    r+= "#{output}\n"
-    
-    if e[:after]
-      r += puts_events( e[:after ].reverse, space+'^  ', depth )
-    end
-  end
-  r
-end
-
-def events_tree filt
-  hash = {:name => filt }
-  if respond_to? "_#{filt}_callbacks"
-    send( "_#{filt}_callbacks" ).each do |callback|
-      next unless callback.applies? self
-      hash[callback.kind] ||= []    
-      hash[callback.kind] << events_tree( callback.filter )
-    end
-  end
-  hash
-end
-#FIXME - this doesn't belong here!!
-
-class ::ActiveSupport::Callbacks::Callback
-  def applies? object
-    object.send :eval, "value=nil;halted=false;!!(#{@compiled_options})"
-  end
-end