card 0.0.1 → 1.15.pre

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

@@ -0,0 +1,120 @@
+
+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

@@ -0,0 +1,114 @@
+#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
+    set = rule_set
+    set.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 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 )
+                set.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
+

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

@@ -0,0 +1,50 @@
+def delete
+  update_attributes :trash => true unless new_card?
+end
+
+def delete!
+  update_attributes! :trash => true unless new_card?
+end
+
+
+event :pull_from_trash, :before=>:store, :on=>:create do
+  if trashed_card = Card.find_by_key_and_trash(key, true)
+    # a. (Rails way) tried Card.where(:key=>'wagn_bot').select(:id), but it wouldn't work.  This #select
+    #    generally breaks on cards. I think our initialization process screws with something
+    # b. (Wagn way) we could get card directly from fetch if we add :include_trashed (eg).
+    #    likely low ROI, but would be nice to have interface to retrieve cards from trash...
+    self.id = trashed_card.id
+    @from_trash = true
+    @new_record = false
+  end
+  self.trash = false
+  true
+end
+
+event :validate_delete, :before=>:approve, :on=>:delete do
+  if !codename.blank?
+    errors.add :delete, "#{name} is is a system card. (#{codename})"
+  end
+  
+  undeletable_all_rules_tags = %w{ default style layout create read update delete }
+  if junction? and l=left and l.codename == 'all' and undeletable_all_rules_tags.member? right.codename
+    errors.add :delete, "#{name} is an indestructible rule"
+  end
+  
+  if account && Card::Act.find_by_actor_id( self.id )
+    errors.add :delete, "Edits have been made with #{name}'s user account.\nDeleting this card would mess up our history."
+  end
+end
+
+event :validate_delete_children, :after=>:approve, :on=>:delete do
+  children.each do |child|
+    child.supercard = self
+    subcards[child.name]=child
+    child.trash = true
+    unless child.valid?
+      child.errors.each do |field, message|
+        errors.add field, "can't delete #{child.name}: #{message}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+
+module ClassMethods
+  def default_type_id
+    @@default_type_id ||= Card[:all].fetch( :trait=>:default ).type_id
+  end
+end
+
+def type_card
+  return if type_id.nil?
+  Card.fetch type_id.to_i, :skip_modules=>true
+end
+
+def type_code
+  Card::Codename[ type_id.to_i ]
+end
+
+def type_name
+  type_card.try :name
+end
+
+def type_cardname
+  type_card.try :cardname
+end
+
+def type= type_name
+  self.type_id = Card.fetch_id type_name
+end
+
+def get_type_id args={}
+  return if args[:type_id] # type_id was set explicitly.  no need to set again.
+  
+  type_id = case
+    when args[:type_code]
+      if code=args[:type_code]
+        Card::Codename[code] || ( c=Card[code] and c.id)
+      end
+    when args[:type]
+      Card.fetch_id args[:type]
+    else :noop
+    end
+
+  case type_id
+  when :noop
+  when false, nil
+    errors.add :type, "#{args[:type] || args[:type_code]} is not a known type."
+  else
+    return type_id
+  end
+
+  if name && t=template
+    reset_patterns #still necessary even with new template handling?
+    t.type_id
+  end
+end
+
+
+event :validate_type_change, :before=>:approve, :on=>:update, :changed=>:type_id do
+  if c = dup and c.action == :create and !c.valid?
+    errors.add :type, "of #{ name } can't be changed; errors creating new #{ type_id }: #{ c.errors.full_messages * ', ' }"
+  end
+end
+
+event :validate_type, :before=>:approve, :changed=>:type_id do    
+  if !type_name
+    errors.add :type, "No such type"
+  end
+  
+  if rt = structure and rt.assigns_type? and type_id!=rt.type_id
+    errors.add :type, "can't be changed because #{name} is hard templated to #{rt.type_name}"
+  end
+end
+
+event :reset_type_specific_fields, :after=>:store do
+  Auth.as_bot do
+    Card.search :left=>{ :left=>type_name }, :right=>{:codename=>'type_plus_right'} do |set_card|
+      set_card.reset_set_patterns
+    end
+  end
+end
+
+#    Card.search :left_plus=>[ type_name, :right_plus=>{:codename=>'type_plus_right'}] do |right_anchor|
+#      Card["#{lef}"]
+#      set_card.reset_set_patterns
+#    end
+  

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

@@ -0,0 +1,85 @@
+
+module ClassMethods
+  
+  def empty_trash
+    Card.where(:trash=>true).delete_all
+    Card::Action.delete_cardless
+    Card::Reference.repair_missing_referees
+    Card::Reference.delete_missing_referers
+    Card.delete_trashed_files
+  end
+  
+  def delete_trashed_files #deletes any file not associated with a real card.
+    dir = Card.paths['files'].existent.first
+    trashed_card_sql = %{ select id from cards where trash is true }
+    trashed_card_ids = Card.connection.select_all( trashed_card_sql ).map( &:values ).flatten.map &:to_i
+    file_ids = Dir.entries( dir )[2..-1].map( &:to_i )
+    file_ids.each do |file_id|
+      if trashed_card_ids.member?(file_id)
+        raise Card::Error, "Narrowly averted deleting current file" if Card.exists?(file_id) #double check!
+        FileUtils.rm_rf "#{dir}/#{file_id}", :secure => true
+      end
+    end
+  end
+  
+  def merge_list attribs, opts
+    unmerged = []
+    attribs.each do |row|
+      result = begin
+        merge row['name'], row, opts
+#      rescue => e
+#        Rails.logger.info "merge_list problem: #{ e.message }"
+#        false
+      end
+      unmerged.push row unless result == true
+    end
+            
+    if unmerged.empty?
+      Rails.logger.info "successfully merged all!"
+    else
+      unmerged_json = JSON.pretty_generate unmerged
+      if output_file = opts[:output_file]
+        ::File.open output_file, 'w' do |f|
+          f.write unmerged_json
+        end
+      else
+        Rails.logger.info "failed to merge:\n\n#{ unmerged_json }"
+      end
+    end
+  end    
+    
+  
+  def merge name, attribs={}, opts={}
+    puts "merging #{ name }"
+    card = fetch name, :new=>{}
+    
+    if opts[:pristine] && !card.pristine?
+      false
+    else
+      card.attributes = attribs
+      card.save!
+    end
+  end
+  
+end
+
+def debug_type
+  "#{type_code||'no code'}:#{type_id}"
+end
+
+def to_s
+  "#<#{self.class.name}[#{debug_type}]#{self.attributes['name']}>"
+end
+
+def inspect
+  "#<#{self.class.name}" + "##{id}" +
+  "###{object_id}" + #"l#{left_id}r#{right_id}" +
+  "[#{debug_type}]" + "(#{self.name})" + #"#{object_id}" +
+  #(errors.any? ? '*Errors*' : 'noE') +
+  (errors.any? ? "<E*#{errors.full_messages*', '}*>" : '') +
+  #"{#{references_expired==1 ? 'Exp' : "noEx"}:" +
+  "{#{trash&&'trash:'||''}#{new_card? &&'new:'||''}#{frozen? ? 'Fz' : readonly? ? 'RdO' : ''}" +
+  "#{@virtual &&'virtual:'||''}#{@set_mods_loaded&&'I'||'!loaded' }:#{references_expired.inspect}}" +
+  '>'
+end
+