wagn 1.14.9 → 1.15.pre

data/mod/01_core/set/all/references.rb

@@ -1,118 +0,0 @@
-
-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 raw_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(raw_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!
-        referee_name.piece_names.each do |name|
-          if name.key != key # don't create self reference
-            
-            # reference types:
-            # L = link
-            # I = inclusion
-            # P = partial (i.e. the name is part of a compound name that is referenced by a link or inclusion)
-            # The partial type is needed to keep track of references of virtual cards. 
-            # For example a link [[A+*self]] won't make it to the reference table because A+*self is virtual and
-            # doesn't have an id but when A's name is changed we have to find and update that link.
-            ref_type = if name == referee_name
-                Card::Chunk::Link===chunk ? 'L' : 'I'
-              else
-                'P'
-              end
-            Card::Reference.create!(
-              :referer_id  => id,
-              :referee_id  => Card.where(:key=>name.key).pluck(:id).first,
-              :referee_key => name.key,
-              :ref_type    => ref_type,
-              :present     => 1
-            )
-          end
-        end
-      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/mod/01_core/set/all/rules.rb

@@ -1,124 +0,0 @@
-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.db_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::TypeSet.label( name) ] if known? && type_id==Card::CardtypeID
-  sets << ["#{name}+*self",  Card::SelfSet.label( name) ] 
-  sets << ["#{name}+*right", Card::RightSet.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
-    Auth.as_bot do
-      card=Card[name] and !card.db_content.strip.empty? and card.db_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
-=begin  
-  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  
-end
-
-

data/mod/01_core/set/all/states.rb

@@ -1,16 +0,0 @@
-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 actions.joins(:act).where('card_acts.actor_id != ?', Card::WagnBotID).exists?
-end

data/mod/01_core/set/all/templating.rb

@@ -1,120 +0,0 @@
-
-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.structure_rule_card
-        @virtual = true if junction?
-        content_card
-      else
-        default_card
-      end
-    elsif tmpl = structure_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 structure_rule_card
-  card = rule_card :structure, :skip_modules=>true
-  card && card.db_content.strip == '_self' ? nil : card
-end
-
-def structuree_names
-  if wql = structuree_spec
-    Auth.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
-    Auth.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?
-    if set_pattern = Card.fetch( cardname.trunk_name.tag_name, :skip_modules=>true )
-      pattern_code = set_pattern.codename and
-      set_class    = Card::SetPattern.find( pattern_code ) and
-      set_class.assigns_type
-    end
-  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_query
-  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

data/mod/01_core/set/all/tracked_attributes.rb

@@ -1,114 +0,0 @@
-#fixme -this is called by both initialize and update_attributes.  really should be optimized for new!
-def assign_attributes args={}, options={}
-  if args
-    args = args.stringify_keys
-    if newtype = args.delete('type')
-      args['type_id'] = Card.fetch_id newtype
-    end
-    @subcards = extract_subcard_args! args
-    reset_patterns
-  end
-  super args, options
-end
-
-def extract_subcard_args! args={}
-  extracted_subcards = args.delete('subcards') || {}
-  args.keys.each do |key|
-    if key =~ /^\+/
-      val = args.delete key
-      val = { 'content' => val } if String === val
-      extracted_subcards[key] = val
-    end
-  end
-  extracted_subcards
-end
-
-
-protected
-
-event :set_content, :before=>:store, :on=>:save do
-  self.db_content = content || '' #necessary?
-  self.db_content = Card::Content.clean! self.db_content if clean_html?
-  @selected_action_id = @selected_content = nil
-  clear_drafts
-  reset_patterns_if_rule saving=true
-end
-
-
-#fixme - the following don't really belong here, but they have to come after the reference stuff.  we need to organize a bit!
-
-event :update_ruled_cards, :after=>:store do
-  if is_rule?
-#      warn "updating ruled cards for #{name}"
-    self.class.clear_rule_cache
-    left.reset_set_patterns
-
-    if right_id==Card::ReadID and (name_changed? or trash_changed?)
-      self.class.clear_read_rule_cache
-      Card.cache.reset # maybe be more surgical, just Auth.user related
-      expire #probably shouldn't be necessary,
-      # but was sometimes getting cached version when card should be in the trash.
-      # could be related to other bugs?
-      in_set = {}
-      if !(self.trash)
-        if class_id = (set=left and set_class=set.tag and set_class.id)
-          rule_class_ids = set_patterns.map &:pattern_id
-          #warn "rule_class_id #{class_id}, #{rule_class_ids.inspect}"
-
-          #first update all cards in set that aren't governed by narrower rule
-           Auth.as_bot do
-             cur_index = rule_class_ids.index Card[read_rule_class].id
-             if rule_class_index = rule_class_ids.index( class_id )
-                # Why isn't this just 'trunk', do we need the fetch?
-                Card.fetch(cardname.trunk_name).item_cards(:limit=>0).each do |item_card|
-                  in_set[item_card.key] = true
-                  next if cur_index < rule_class_index
-                  if cur_index >= rule_class_index
-                    item_card.update_read_rule
-                  end
-                end
-             # elsif rule_class_index = rule_class_ids.index( 0 )
- #               in_set[trunk.key] = true
- #               #warn "self rule update: #{trunk.inspect}, #{rule_class_index}, #{cur_index}"
- #   trunk.update_read_rule if cur_index > rule_class_index
-             else warn "No current rule index #{class_id}, #{rule_class_ids.inspect}"
-             end
-          end
-
-        end
-      end
-
-      #then find all cards with me as read_rule_id that were not just updated and regenerate their read_rules
-      if !new_record?
-        Card.where( :read_rule_id=>self.id, :trash=>false ).reject do |w|
-          in_set[ w.key ]
-        end.each &:update_read_rule
-      end
-    end
-
-  end
-end
-
-event :process_read_rule_update_queue, :after=>:store do
-  Array.wrap(@read_rule_update_queue).each { |card| card.update_read_rule }
-  @read_rule_update_queue = []
-end
-
-#  set_callback :store, :after, :process_read_rule_update_queue, :prepend=>true
-
-event :expire_related, :after=>:store do
-  self.expire
-
-  if self.is_structure?
-    self.structuree_names.each do |name|
-      Card.expire name
-    end
-  end
-  # FIXME really shouldn't be instantiating all the following bastards.  Just need the key.
-  # fix in id_cache branch
-  self.dependents.each       { |c| c.expire }
-  # self.referencers.each      { |c| c.expire }
-  self.name_referencers.each { |c| c.expire }
-  # FIXME: this will need review when we do the new defaults/templating system
-end
-