wagn 1.12.7

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

@@ -0,0 +1,45 @@
+JUNK_INIT_ARGS = %w{ missing skip_virtual id }
+
+module ClassMethods
+  def new args={}, options={}
+    args = (args || {}).stringify_keys
+    JUNK_INIT_ARGS.each { |a| args.delete(a) }
+    %w{ type type_code }.each { |k| args.delete(k) if args[k].blank? }
+    args.delete('content') if args['attach'] # should not be handled here!
+    super args
+  end
+end
+
+def initialize args={}
+  args['name']    = args['name'   ].to_s
+  args['type_id'] = args['type_id'].to_i
+
+  args.delete('type_id') if args['type_id'] == 0 # can come in as 0, '', or nil
+  @type_args = {
+    :type      => args.delete('type'     ),
+    :type_code => args.delete('type_code'),
+    :type_id   => args[       'type_id'  ]
+  }
+
+  @supercard = args.delete 'supercard' # must come before name =
+  skip_modules = args.delete 'skip_modules'
+
+  super args # ActiveRecord #initialize
+
+  if tid = get_type_id( @type_args )
+    self.type_id = tid
+  end
+
+  include_set_modules unless skip_modules
+  self
+end
+
+def include_set_modules
+  unless @set_mods_loaded
+    set_modules.each do |m|
+      singleton_class.send :include, m
+    end
+    @set_mods_loaded=true
+  end
+  self
+end

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

@@ -0,0 +1,266 @@
+
+def name= newname
+  @cardname = newname.to_name
+  if @supercard
+    @relative_name = @cardname
+    relparts = @relative_name.parts
+    @superleft = @supercard if relparts.size==2 && relparts.first.blank?
+    @cardname = @relative_name.to_absolute_name @supercard.name
+  end
+  
+  newkey = @cardname.key
+  if key != newkey
+    self.key = newkey
+    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
+  end
+  super @cardname.s
+end
+
+def cardname
+  @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 relative_name
+  @relative_name || @cardname
+end
+
+def left *args
+  if !simple?
+    @superleft or begin
+      unless name_changed? and 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
+end
+
+def right *args
+  Card.fetch( cardname.right, *args ) if !simple?
+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 or Card.new args.merge(:name=>cardname.left)
+end
+
+def children
+  Card.search( { (simple? ? :part : :left) => name } ).to_a
+end
+
+def dependents
+  return [] if new_card?
+
+  if @dependents.nil?
+    @dependents =
+      Account.as_bot do
+        deps = children
+        deps.inject(deps) do |array, card|
+          array + card.dependents
+        end
+      end
+    #Rails.logger.warn "dependents[#{inspect}] #{@dependents.inspect}"
+  end
+  @dependents
+end
+
+def repair_key
+  Account.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 and self.save! )
+    saved ||= ( self.cardname = current_key and self.save! )
+
+    if saved
+      self.dependents.each { |c| c.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 Account.always_ok?
+end
+
+event :validate_unique_codename, :after=>:permit_codename do
+  if !codename.empty? and errors.empty? and 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 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? and simple? and id and Account.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(:first, :conditions=>[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? 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
+  end
+end
+
+
+event :validate_key, :after=>:validate_name, :on=>:save do
+  if key.empty?
+    errors.add :key, "cannot be blank"
+  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]
+      old_name_in_way = (sidecard && sidecard.id==self.id) # eg, renaming A to A+B
+      suspend_name(sidename) if old_name_in_way
+      send "#{side}_id=", begin
+        if !sidecard || old_name_in_way
+          Card.create! :name=>sidename
+        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) and existing_card != self
+    existing_card.name = existing_card.name+'*trash'
+    existing_card.rename_without_callbacks
+    existing_card.save!
+  end
+  @name_or_content_changed=true
+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=>self.id).update_all(:name=>tmp_name, :key=>tmp_name)
+end
+
+
+event :cascade_name_changes, :after=>:store, :on=>:update, :changed=>:name do
+
+  Rails.logger.debug "-------------------#{name_was}- CASCADE #{self.name} -------------------------------------"
+
+  self.update_referencers = false if self.update_referencers == 'false' #handle strings from cgi
+  Card::Reference.update_on_rename self, name, self.update_referencers
+
+  deps = self.dependents
+  #warn "-------------------#{name_was}---- CASCADE #{self.name} -> deps: #{deps.map(&:name)*", "} -----------------------"
+
+  @dependents = nil #reset
+
+  deps.each do |dep|
+    # here we specifically want NOT to invoke recursive cascades on these cards, have to go this low level to avoid callbacks.
+    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
+    Card.expire newname
+  end
+
+  if update_referencers
+    Account.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
+        # 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 dependents, 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 or card.structure
+          card = card.refresh
+          card.content = card.replace_references name_was, name
+          card.save!
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# -*- 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
+      class_key = if Card::Name === mark
+        key_card = Card.fetch mark.to_name.tag_name, :skip_modules=>true
+        key_card && key_card.codename
+      else
+        mark.to_s
+      end
+      set_patterns.find { |sub| sub.key == class_key }
+    end
+  end
+
+end
+
+
+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 = @method_keys = @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
+
+    #this is really messy.
+    if saving
+      self.add_to_read_rule_update_queue( set.item_cards :limit=>0 ) if right.id == Card::ReadID
+    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(&:set_const).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
+
+def method_keys
+  @method_keys ||= patterns.map(&:get_method_key).compact
+end

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

@@ -0,0 +1,218 @@
+# -*- encoding : utf-8 -*-
+
+Card.error_codes.merge! :permission_denied=>[:denial, 403], :captcha=>[:error,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
+alias_method_chain :ok?, :fetch # note: method is chained so that we can return the instance variable @action_ok
+
+
+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 || 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
+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 = Account.as_bot do
+    if opcard.content == '_left' && 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
+    end
+  end
+  return rcard, opcard.rule_class_name
+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
+  [why].flatten.each do |message|
+    errors.add :permission_denied, message
+  end
+  @action_ok = false
+end
+
+def permitted? action
+
+  if !Wagn.config.read_only
+    return true if action != :comment and Account.always_ok?
+
+    permitted_ids = who_can action
+
+    if action == :comment && Account.always_ok?
+      # admin can comment if anyone can
+      !permitted_ids.empty?
+    else
+      Account.among? permitted_ids
+    end
+  end
+end
+
+def permit action, verb=nil
+  if Wagn.config.read_only # not called by ok_to_read
+    deny_because "Currently in read-only mode"
+  end
+  
+  verb ||= action.to_s
+  unless permitted? action
+    deny_because you_cant("#{verb} this card")
+  end
+end
+
+def ok_to_create
+  permit :create
+end
+
+def ok_to_read
+  if !Account.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"
+    end
+  end
+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)" )
+  end
+  ok_to_read if @action_ok
+end
+
+def ok_to_delete
+  permit :delete
+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
+  end
+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?
+      Account.as_bot do
+        Card.search(:left=>self.name).each do |plus_card|
+          plus_card = plus_card.refresh.update_read_rule
+        end
+      end
+    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}"
+
+  self.read_rule_class = rclass
+  Card.where(:id=>self.id).update_all(:read_rule_id=>rcard.id, :read_rule_class=>rclass)
+  expire
+
+  # currently doing a brute force search for every card that may be impacted.  may want to optimize(?)
+  Account.as_bot do
+    Card.search(:left=>self.name).each do |plus_card|
+      if plus_card.rule(:read) == '_left'
+        plus_card.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
+  act = if @action != :delete && comment #will be obviated by new comment handling
+    :comment
+  else
+    @action
+  end
+  ok? act
+end
+
+
+
+event :recaptcha, :before=>:approve do
+  if !@supercard                        and
+      Wagn::Env[:recaptcha_on]          and
+      Card.toggle( rule :captcha )      and
+      num = Wagn::Env[:recaptcha_count] and
+      num < 1
+      
+    Wagn::Env[:recaptcha_count] = num + 1
+    Wagn::Env[:controller].verify_recaptcha :model=>self, :attribute=>:captcha
+  end
+end
+
+
+