wagn 1.12.7

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

@@ -0,0 +1,145 @@
+# -*- encoding : utf-8 -*-
+
+event :set_tracked_attributes, :before=>:store, :on=>:save do
+  updates.each_pair do |attrib, value|
+    if send("set_#{attrib}", value )
+      updates.clear attrib
+    end
+    @changed ||={}; @changed[attrib.to_sym]=true
+  end
+  #Rails.logger.debug "Card(#{name})#set_tracked_attributes end"
+end
+
+
+def assign_attributes args={}, options={}
+  if args and newtype = args.delete(:type) || args.delete('type')
+    args['type_id'] = Card.fetch_id( newtype )
+  end
+  reset_patterns
+
+  super args, options
+end
+
+
+protected
+
+
+
+
+def set_content new_content
+  if self.id #have to have this to create revision
+    new_content ||= ''
+    new_content = Card::Content.clean! new_content if clean_html?
+    clear_drafts if current_revision_id
+    new_rev = Card::Revision.create :card_id=>self.id, :content=>new_content, :creator_id =>Account.current_id
+    self.current_revision_id = new_rev.id
+    reset_patterns_if_rule saving=true
+    @name_or_content_changed = true
+  else
+    false
+  end
+end
+
+
+
+event :set_initial_content, :after=>:store, :on=>:create do
+  #Rails.logger.info "Card(#{inspect})#set_initial_content start #{content_without_tracking}"
+  # set_content bails out if we call it on a new record because it needs the
+  # card id to create the revision.  call it again now that we have the id.
+
+  #Rails.logger.warn "si cont #{content} #{updates.for?(:content).inspect}, #{updates[:content]}"
+  unless @from_trash
+    set_content updates[:content] # if updates.for?(:content)
+  
+    updates.clear :content
+
+    Card.where(:id=>id).update_all(:current_revision_id => current_revision_id)
+  end
+  #Rails.logger.info "set_initial_content #{content}, #{@current_revision_id}, s.#{self.current_revision_id} #{inspect}"
+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 && (@name_or_content_changed || ([:create, :delete].member? @action) )
+      # These instance vars are messy.  should use tracked attributes' @changed variable
+      # and get rid of @name_changed, @name_or_content_changed, and @child.
+      # Above should look like [:name, :content, :trash].member?( @changed.keys ).
+      # To implement that, we need to make sure @changed actually tracks trash
+      # (though maybe not as a tracked_attribute for performance reasons?)
+      # AND need to make sure @changed gets wiped after save (probably last in the sequence)
+
+      self.class.clear_read_rule_cache
+
+#        Account.cache.reset
+      Card.cache.reset # maybe be more surgical, just Account.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 &:key_id
+          #warn "rule_class_id #{class_id}, #{rule_class_ids.inspect}"
+
+          #first update all cards in set that aren't governed by narrower rule
+           Account.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
+                  item_card.update_read_rule
+                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/mods/core/sets/all/trash.rb

@@ -0,0 +1,45 @@
+def delete
+  update_attributes :trash => true
+end
+
+def delete!
+  update_attributes! :trash => true
+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
+#reset_patterns_if_rule saving=true
+
+event :validate_delete, :before=>:approve, :on=>:delete do
+  if !codename.blank?
+    errors.add :delete, "#{name} is is a system card. (#{codename})"
+  end
+  if account && Card::Revision.find_by_creator_id( self.id )
+    errors.add :delete, "Edits have been made with #{name}'s user account.\n  Deleting this card would mess up our revision records."
+  end
+end
+
+event :validate_delete_children, :after=>:approve, :on=>:delete do
+  @subcards = {}
+  children.each do |child|
+    @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/mods/core/sets/all/type.rb

@@ -0,0 +1,70 @@
+
+module ClassMethods
+  def default_type_id
+    @@default_type_id ||= Card[:all].fetch( :trait=>:default ).type_id
+  end
+end
+
+def type_card
+  Card[ type_id.to_i ]
+end
+
+def type_code
+  Card::Codename[ type_id.to_i ]
+end
+
+def type_name
+  return if type_id.nil?
+  type_card = Card.fetch type_id.to_i, :skip_modules=>true, :skip_virtual=>true
+  type_card and type_card.name
+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
+
+

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

@@ -0,0 +1,91 @@
+# -*- encoding : utf-8 -*-
+module ClassMethods
+  
+  def empty_trash
+    Card.where(:trash=>true).delete_all
+    User.delete_cardless
+    Card::Revision.delete_cardless
+    Card::Reference.repair_missing_referees
+    Card.delete_trashed_files
+  end
+  
+  def delete_trashed_files #deletes any file not associated with a real card.
+    dir = Wagn.paths['files'].existent.first
+    card_ids = Card.connection.select_all( %{ select id from cards where trash is false } ).map( &:values ).flatten
+    file_ids = Dir.entries( dir )[2..-1].map( &:to_i )
+    file_ids.each do |file_id|
+      if !card_ids.member?(file_id)
+        raise Wagn::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 delete_tmp_files id=nil
+    dir = Wagn.paths['files'].existent.first + '/tmp'
+    dir += "/#{id}" if id
+    FileUtils.rm_rf dir, :secure=>true
+  rescue
+    Rails.logger.info "failed to remove tmp files"
+  end
+  
+  
+  def merge_list attribs, opts
+    unmerged = []
+    attribs.each do |row|
+      result = begin
+        merge row['name'], row, opts
+      rescue
+        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={}
+    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
+

data/mods/standard/chunks/include.rb

@@ -0,0 +1,85 @@
+# -*- encoding : utf-8 -*-
+
+module Card::Chunk
+  class Include < Reference
+    cattr_reader :options
+    @@options = ::Set.new [ :inc_name, :inc_syntax, :view, :items, :type, :size, :title, :hide, :show, :structure ]
+    attr_reader :options
+
+    Card::Chunk.register_class self, {
+      :prefix_re => '\\{\\{',
+      :full_re   =>  /^\{\{([^\}]*)\}\}/,
+      :idx_char  => '{'
+    }
+
+    def interpret match, content
+      in_brackets = strip_tags match[1]
+#      warn "in_brackets = #{in_brackets}"
+      name, @opt_lists = in_brackets.split '|', 2
+      name = name.to_s.strip
+      result = case name
+        when /^\#\#/ ; '' # invisible comment
+        when /^\#/   ; "<!-- #{CGI.escapeHTML in_brackets} -->"
+#        when /^\s*$/ ; '' # no name
+        else
+          @options = if @opt_lists
+            @opt_lists.split('|').reverse.inject(nil) do |prev_level, level_options|
+              process_options level_options, prev_level
+            end
+          else {} end
+          @options.merge! :inc_name => name, :inc_syntax => in_brackets
+          @name = name
+        end
+
+      @process_chunk = result if !@name
+    end
+
+    def strip_tags string
+      #note: not using ActionView's strip_tags here because this needs to be super fast.
+      string.gsub /\<[^\>]*\>/, ''
+    end
+
+    def process_options list_string, items
+      hash = {}
+      style_hash = {}
+      hash[:items] = items unless items.nil?
+      Hash.new_from_semicolon_attr_list( list_string ).each do |key, value|
+        key = key.to_sym
+        if key==:item
+          hash[:items] ||= {}
+          hash[:items][:view] = value
+        elsif @@options.include? key
+          hash[key] = value
+        else
+          style_hash[key] = value
+        end
+      end
+
+      if !style_hash.empty?
+        hash[:style] = style_hash.map { |key, value| CGI.escapeHTML "#{key}:#{value};" } * ''
+      end
+      hash
+    end
+
+    def inspect
+      "<##{self.class}:n[#{@name}] p[#{@process_chunk}] txt:#{@text}>"
+    end
+
+    def process_chunk
+      return @process_chunk if @process_chunk
+
+      referee_name
+      if view = @options[:view]
+        view = view.to_sym
+      end
+
+      @processed = yield @options # this is not necessarily text, sometimes objects for json
+    end
+
+    def replace_reference old_name, new_name
+      replace_name_reference old_name, new_name
+      @text = "{{#{ [ @name.to_s, @opt_lists ].compact * '|' }}}"
+    end
+
+  end
+end

data/mods/standard/chunks/link.rb

@@ -0,0 +1,84 @@
+# -*- encoding : utf-8 -*-
+module Card::Chunk
+  class Link < Reference
+    word = /\s*([^\]\|]+)\s*/
+    # Groups: $1, [$2]: [[$1]] or [[$1|$2]] or $3, $4: [$3][$4]
+    Card::Chunk.register_class self, {
+      :prefix_re => '\\[',
+      :full_re   => /^\[\[([^\]]+)\]\]/,
+      :idx_char  => '['
+    }
+
+    def interpret match, content
+      target, @link_text = if raw_syntax = match[1]
+        if i = divider_index( raw_syntax )  # [[ A | B ]]
+          [ raw_syntax[0..(i-1)], raw_syntax[(i+1)..-1] ]
+        else                                # [[ A ]]
+          [ raw_syntax, nil ]
+        end
+      end
+      
+      @link_text = objectify @link_text
+      if target =~ /\/|mailto:/
+        @explicit_link = objectify target
+      else
+        @name = target
+      end  
+    end
+
+    def divider_index string
+      #there's probably a better way to do the following.  point is to find the first pipe that's not inside an inclusion
+      
+      if string.index '|'
+        string_copy = "#{string}" # had to do this to create new string?!
+        string.scan /\{\{[^\}]*\}\}/ do |incl|
+          string_copy.gsub! incl, ('x'*incl.length)
+        end
+        string_copy.index '|'
+      end
+    end
+
+    def objectify raw
+      if raw
+        raw.strip!
+        if raw =~ /(^|[^\\])\{\{/
+          Card::Content.new raw, format
+        else
+          raw
+        end
+      end
+    end
+
+
+    def render_link
+      @link_text = render_obj @link_text
+      
+      if @explicit_link
+        @explicit_link = render_obj @explicit_link
+        format.build_link @explicit_link, @link_text
+      elsif @name
+        format.card_link referee_name, @link_text, referee_card.send_if(:known?)
+      end
+    end
+
+    def process_chunk
+      @process_chunk ||= render_link
+    end
+
+    def inspect
+      "<##{self.class}:e[#{@explicit_link}]n[#{@name}]l[#{@link_text}] p[#{@process_chunk}] txt:#{@text}>"
+    end
+
+    def replace_reference old_name, new_name
+      replace_name_reference old_name, new_name
+
+      if Card::Content===@link_text
+        @link_text.find_chunks(Card::Chunk::Reference).each { |chunk| chunk.replace_reference old_name, new_name }
+      else
+        @link_text = new_name if old_name.to_name == @link_text
+      end
+      
+      @text = @link_text.nil? ? "[[#{referee_name.to_s}]]" : "[[#{referee_name.to_s}|#{@link_text}]]"
+    end
+  end
+end