wagn 1.12.7

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

@@ -0,0 +1,159 @@
+def approve
+  #warn "approve called for #{name}!"
+  @action = case
+    when trash     ; :delete
+    when new_card? ; :create
+    else             :update
+    end
+
+  # the following should really happen when type, name etc are changed
+  reset_patterns
+  include_set_modules
+  
+  run_callbacks :approve
+  expire_pieces if errors.any?
+  errors.empty?
+rescue Exception=>e
+  rescue_event e
+end
+
+
+def store
+  run_callbacks :store do
+    yield
+    @virtual = false
+  end
+rescue Exception=>e
+  rescue_event e
+ensure
+  @from_trash = nil
+end
+
+
+def extend
+#    puts "extend called"
+  run_callbacks :extend
+rescue Exception=>e
+  rescue_event e
+ensure
+  @action = nil
+end
+
+
+def rescue_event e
+  @action = nil
+  expire_pieces
+  if @subcards
+    @subcards.each { |key, card| card.expire_pieces }
+  end
+  raise e
+end
+
+def event_applies? opts
+  if opts[:on]
+    return false unless Array.wrap( opts[:on] ).member? @action
+  end
+  if opts[:changed]
+    return false if @action == :delete or !changes[ opts[:changed].to_s ]
+  end
+  if opts[:when]
+    return false unless opts[:when].call self
+  end
+  true
+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!
+
+    opts[:supercard] = self    
+    subcard = if known_card = Card[sub_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
+    end
+
+    @subcards[sub_name] = subcard if subcard
+  end
+end
+
+event :approve_subcards, :after=>:process_subcards do
+  @subcards.each do |key, subcard|
+    if !subcard.valid?
+      subcard.errors.each do |field, err|
+        errors.add field, "#{subcard.relative_name}: #{err}"
+      end
+    end
+  end
+end
+
+event :store_subcards, :after=>:store do
+  @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
+

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

@@ -0,0 +1,102 @@
+# -*- encoding : utf-8 -*-
+
+def name_referencers link_name=nil
+  link_name = link_name.nil? ? key : link_name.to_name.key
+  Card.all :joins => :references_to, :conditions => { :card_references => { :referee_key => link_name } }
+end
+
+def extended_referencers
+  # FIXME .. we really just need a number here.
+  (dependents + [self]).map(&:referencers).flatten.uniq
+end
+
+def replace_references old_name, new_name
+  obj_content = Card::Content.new content, card=self
+  
+  obj_content.find_chunks( Card::Chunk::Reference ).select do |chunk|
+    if old_ref_name = chunk.referee_name and new_ref_name = old_ref_name.replace_part(old_name, new_name)
+      chunk.referee_name = chunk.replace_reference old_name, new_name
+      Card::Reference.where( :referee_key => old_ref_name.key ).update_all :referee_key => new_ref_name.key
+    end
+  end
+
+  obj_content.to_s
+end
+
+def update_references rendered_content = nil, refresh = false
+  raise "update references should not be called on new cards" if id.nil?
+
+  Card::Reference.delete_all_from self
+
+  # FIXME: why not like this: references_expired = nil # do we have to make sure this is saved?
+  #Card.update( id, :references_expired=>nil )
+  #  or just this and save it elsewhere?
+  #references_expired=nil
+  
+  connection.execute("update cards set references_expired=NULL where id=#{id}")
+#  references_expired = nil
+  expire if refresh
+
+  rendered_content ||= Card::Content.new(content, card=self)
+  
+  rendered_content.find_chunks(Card::Chunk::Reference).each do |chunk|
+    if referee_name = chunk.referee_name # name is referenced (not true of commented inclusions)
+      referee_id = chunk.referee_id   
+      if id != referee_id               # not self reference
+        
+        #update_references chunk.referee_name if Card::Content === chunk.referee_name
+        # for the above to work we will need to get past delete_all!
+        
+        Card::Reference.create!(
+          :referer_id  => id,
+          :referee_id  => referee_id,
+          :referee_key => referee_name.key,
+          :ref_type    => Card::Chunk::Link===chunk ? 'L' : 'I',
+          :present     => chunk.referee_card.nil?   ?  0  :  1
+        )
+      end
+    end
+  end
+end
+
+
+
+def referencers
+  return [] unless refs = references_from
+  refs.map(&:referer_id).map( &Card.method(:fetch) ).compact
+end
+
+def includers
+  return [] unless refs = references_from.where( :ref_type => 'I' )
+  refs.map(&:referer_id).map( &Card.method(:fetch) ).compact
+end
+
+def referees
+  return [] unless refs = references_to
+  refs.map { |ref| Card.fetch ref.referee_key, :new=>{} }.compact
+end
+
+def includees
+  return [] unless refs = references_to.where( :ref_type => 'I' )
+  refs.map { |ref| Card.fetch ref.referee_key, :new=>{} }.compact
+end
+
+
+
+protected
+
+
+event :refresh_references, :after=>:store, :on=>:save do
+  self.update_references
+  expire_structuree_references
+end
+
+event :refresh_references_on_create, :before=>:refresh_references, :on=>:create do
+  Card::Reference.update_existing_key self
+  # FIXME: bogus blank default content is set on structured cards...
+end
+
+event :refresh_references_on_delete, :after=>:store, :on=>:delete do
+  Card::Reference.update_on_delete self
+  expire_structuree_references
+end

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

@@ -0,0 +1,125 @@
+# -*- encoding : utf-8 -*-
+RuleSQL = %{
+  select rules.id as rule_id, settings.id as setting_id, sets.id as set_id, sets.left_id as anchor_id, sets.right_id as set_tag_id
+  from cards rules join cards sets on rules.left_id = sets.id join cards settings on rules.right_id = settings.id
+  where sets.type_id     = #{Card::SetID }    and sets.trash     is false
+  and   settings.type_id = #{Card::SettingID} and settings.trash is false
+  and                                             rules.trash    is false;
+}
+
+ReadRuleSQL = %{
+  select refs.referee_id as party_id, read_rules.id as read_rule_id
+  from cards read_rules join card_references refs on refs.referer_id = read_rules.id join cards sets on read_rules.left_id = sets.id
+  where read_rules.right_id = #{Card::ReadID} and read_rules.trash is false and sets.type_id = #{Card::SetID};
+}  
+
+def is_rule?
+  !simple?                          and
+  l = left(  :skip_modules=>true )  and
+  l.type_id == Card::SetID          and
+  r = right( :skip_modules=>true )  and
+  r.type_id == Card::SettingID 
+end
+
+def rule setting_code, options={}
+  options[:skip_modules] = true
+  card = rule_card setting_code, options
+  card && card.content
+end
+
+def rule_card setting_code, options={}
+  Card.fetch rule_card_id( setting_code, options ), options
+end
+
+def rule_card_id setting_code, options={}
+  fallback = options.delete( :fallback )
+  rule_set_keys.each do |rule_set_key|
+    rule_id = self.class.rule_cache["#{rule_set_key}+#{setting_code}"]
+    rule_id ||= fallback && self.class.rule_cache["#{rule_set_key}+#{fallback}"]
+    return rule_id if rule_id
+  end
+  nil
+end
+
+def related_sets
+  # refers to sets that users may configure from the current card - NOT to sets to which the current card belongs
+
+  sets = []
+  sets << ["#{name}+*type",  Card::SetPattern::TypePattern.label( name) ] if known? && type_id==Card::CardtypeID
+  sets << ["#{name}+*self",  Card::SetPattern::SelfPattern.label( name) ] 
+  sets << ["#{name}+*right", Card::SetPattern::RightPattern.label(name) ] if known? && cardname.simple?
+    
+#      Card.search(:type=>'Set',:left=>{:right=>name},:right=>'*type plus right',:return=>'name').each do |set_name|
+#        sets<< set_name
+#      end
+  sets
+end
+
+module ClassMethods
+  
+  def setting name
+    Account.as_bot do
+      card=Card[name] and !card.content.strip.empty? and card.content
+    end
+  end
+  
+  def path_setting name #shouldn't this be in location helper?
+    name ||= '/'
+    return name if name =~ /^(http|mailto)/
+    "#{Wagn.config.relative_url_root}#{name}"
+  end
+
+  def toggle val
+    val.to_s.strip == '1'
+  end
+
+  def rule_cache
+    Card.cache.read('RULES') || begin        
+      hash = {}
+      ActiveRecord::Base.connection.select_all( Card::Set::All::Rules::RuleSQL ).each do |row|
+        setting_code = Card::Codename[ row['setting_id'].to_i ] or next
+        anchor_id = row['anchor_id']
+        set_class_id = anchor_id.nil? ? row['set_id'] : row['set_tag_id']
+    
+        set_class_code = Card::Codename[ set_class_id.to_i ] or next
+        hash_key = [ anchor_id, set_class_code, setting_code ].compact.map( &:to_s ) * '+'
+        hash[ hash_key ] = row['rule_id'].to_i
+      end
+      Card.cache.write 'RULES', hash
+    end
+  end
+  
+  def clear_rule_cache
+    Card.cache.write 'RULES', nil
+  end
+  
+  def read_rule_cache
+    Card.cache.read('READRULES') || begin
+      hash = {}
+      ActiveRecord::Base.connection.select_all( Card::Set::All::Rules::ReadRuleSQL ).each do |row|
+        party_id, read_rule_id = row['party_id'].to_i, row['read_rule_id'].to_i
+        hash[party_id] ||= []
+        hash[party_id] << read_rule_id
+      end
+      Card.cache.write 'READRULES', hash
+    end
+  end
+  
+  def clear_read_rule_cache
+    Card.cache.write 'READRULES', nil
+  end
+  
+  def default_rule setting_code, fallback=nil
+    card = default_rule_card setting_code, fallback
+    return card && card.content
+  end
+
+  def default_rule_card setting_code, fallback=nil
+    rule_id = rule_cache["all+#{setting_code}"]
+    rule_id ||= fallback && rule_cache["all+#{fallback}"]
+    Card[rule_id] if rule_id
+  end
+  
+end
+
+

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

@@ -0,0 +1,16 @@
+def new_card?
+  new_record? || !!@from_trash
+end
+
+def known?
+  real? || virtual?
+end
+
+def real?
+  !new_card?
+end
+
+def pristine?
+  # has not been edited directly by human users.  bleep blorp.
+  new_card? or !revisions.map(&:creator_id).find { |id| id != Card::WagnBotID }
+end

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

@@ -0,0 +1,118 @@
+# -*- encoding : utf-8 -*-
+
+def is_template?
+  cardname.trait_name? :structure, :default
+end
+
+def is_structure?
+  cardname.trait_name? :structure
+end
+
+def template
+  # currently applicable templating card.
+  # note that a *default template is never returned for an existing card.
+  @template ||= begin
+    @virtual = false
+    if new_card?
+      default_card = rule_card :default, :skip_modules=>true
+
+      dup_card = dup
+      dup_card.type_id = default_card ? default_card.type_id : Card.default_type_id
+
+
+      if content_card = dup_card.content_rule_card
+        @virtual = true if junction?
+        content_card
+      else
+        default_card
+      end
+    elsif tmpl = content_rule_card
+      # this is a mechanism for repairing bad data.  like #repair_key, it should be obviated and removed.
+      if type_id != tmpl.type_id and tmpl.assigns_type?
+        repair_type tmpl.type_id
+      end
+      tmpl
+    end
+  end
+end
+
+def structure
+  if template && template.is_structure?
+    template
+  end
+end
+
+def virtual?
+  return false unless new_card?
+  if @virtual.nil?
+    cardname.simple? ? @virtual=false : template
+  end
+  @virtual
+end
+
+def content_rule_card
+  card = rule_card :structure, :skip_modules=>true
+  card && card.content.strip == '_self' ? nil : card
+end
+
+def structuree_names
+  if wql = structuree_spec
+    Account.as_bot do
+      Card::Query.new(wql.merge :return=>:name).run
+    end
+  else
+    []
+  end
+end
+
+# FIXME: content settings -- do we really need the reference expiration system?
+#
+# I kind of think so.  otherwise how do we handled patterned references in hard-templated cards?
+# I'll leave the FIXME here until the need (and/or other solution) is well documented.  -efm
+
+def expire_structuree_references
+  update_structurees :references_expired => 1
+end
+
+def update_structurees args
+  # note that this is not smart about overriding templating rules
+  # for example, if someone were to change the type of a +*right+*structure rule that was overridden
+  # by a +*type plus right+*structure rule, the override would not be respected.
+  if query = structuree_spec
+    Account.as_bot do
+      Card::Query.new( query.merge(:return => :id) ).run.each_slice(100) do |id_batch|
+        Card.where( :id => id_batch ).update_all args
+      end
+    end
+  end
+end
+
+def assigns_type?
+  # needed because not all *structure templates govern the type of set members
+  # for example, X+*type+*structure governs all cards of type X,
+  # but the content rule does not (in fact cannot) have the type X.
+  if is_structure?
+    set_class = Card.find_set_pattern cardname.trunk_name
+    set_class && set_class.assigns_type
+  end
+end
+
+private
+
+def repair_type template_type_id
+  self.type_id = template_type_id
+  update_column :type_id, type_id
+  reset_patterns
+end
+
+def structuree_spec
+  if is_structure? and c=trunk and c.type_id = Card::SetID  #could use is_rule?...
+    c.get_spec
+  end
+end
+
+event :update_structurees_type, :after=>:store, :changed=>:type_id do
+  if assigns_type? # certain *structure templates
+    update_structurees :type_id => type_id
+  end
+end