wagn 1.13.0 → 1.14.0.pre1

data/lib/wagn/version.rb

@@ -14,8 +14,13 @@ module Wagn
       end
 
       def schema_stamp_path type
-        stamp_dir = ENV['SCHEMA_STAMP_PATH'] || File.join( Wagn.gem_root, 'config' )
-        File.join stamp_dir, "version#{ '_cards' if type.to_s =~ /card/ }.txt"  
+        stamp_dir = ENV['SCHEMA_STAMP_PATH'] || if type.to_s =~ /deck/
+          File.join( Wagn.root, 'config' )
+        else
+          File.join( Wagn.gem_root, 'config' )
+        end 
+        
+        File.join stamp_dir, "version#{ '_cards' if type.to_s =~ /card|deck/ }.txt"  
       end
             
     end

data/mod/{core → 01_core}/chunk/reference.rb

@@ -5,15 +5,27 @@ module Card::Chunk
 
     def referee_name
       return if name.nil?
-        
-      @referee_name ||= ( render_obj name ).to_name
+      
+      @referee_name ||= begin
+        rendered_name = render_obj( name )
+        ref_card = case rendered_name
+        when /^\~(\d+)$/ # get by id
+          Card.fetch $1.to_i 
+        when /^\:(\w+)$/ # get by codename
+          Card.fetch $1.to_sym
+        end
+        if ref_card
+          ref_card.cardname
+        else
+          rendered_name.to_name
+        end
+      end
       @referee_name = @referee_name.to_absolute(card.cardname).to_name
     end
 
     def referee_card
       @referee_card ||= referee_name && Card.fetch( referee_name )
     end
-
     def referee_id
       referee_card and referee_card.id
     end

data/mod/{core → 01_core}/format/html_format.rb

@@ -255,11 +255,14 @@ class Card
     def content_field form, options={}
       @form = form
       @nested = options[:nested]
+      card.last_action_id_before_edit = card.last_action_id
       revision_tracking = if card && !card.new_card? && !options[:skip_rev_id]
-        form.hidden_field :current_revision_id, :class=>'current_revision_id'
+        form.hidden_field :last_action_id_before_edit, :class=>'current_revision_id'
+        #hidden_field_tag 'card[last_action_id_before_edit]', card.last_action_id, :class=>'current_revision_id'
       end
       %{
-        #{ revision_tracking }
+        #{ revision_tracking 
+         }
         #{ _render_editor options }
       }
     end

data/mod/{core → 01_core}/set/all/collection.rb

@@ -1,6 +1,5 @@
 
 module ClassMethods
-  
   def search spec
     results = ::Card::Query.new(spec).run
     if block_given? and Array===results
@@ -28,6 +27,36 @@ def item_type
   nil
 end
 
+def include_item? cardname
+  ::Set.new(item_names).member? cardname
+end
+
+def extended_item_cards context = nil
+  context = (context ? context.cardname : self.cardname)
+  args={ :limit=>'' }
+  items = self.item_cards(args.merge(:context=>context))
+  extended_list = []
+  already_extended = ::Set.new # avoid loops
+  
+  while items.size > 0
+    item = items.shift
+    if already_extended.include? item 
+      next
+    elsif item.item_cards == [item]  # no further level of items
+      extended_list << item
+      already_extended << item
+    else
+      items.unshift(*item.item_cards) # keep items in order
+      already_extended << item
+    end
+  end
+  extended_list
+end
+
+def extended_item_contents context = nil
+  extended_item_cards(context).map(&:item_names).flatten
+end
+
 def extended_list context = nil
   context = (context ? context.cardname : self.cardname)
   args={ :limit=>'' }
@@ -41,10 +70,9 @@ def extended_list context = nil
   # this could go on and on.  more elegant to recurse until you don't have a collection
 end
 
-def contextual_content context_card, format_args={}
-  format_args[:not_current] = true
+def contextual_content context_card, format_args={}, view_args={}
   context_card.format(format_args).process_content(
-    self.format(:not_current=>true)._render_raw
+    self.format(format_args)._render_raw(view_args), view_args
   )
 end
 
@@ -84,4 +112,4 @@ format do
       end
     end
   end
-end
+end

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

@@ -0,0 +1,144 @@
+::Card.error_codes[:conflict] = [:conflict, 409]
+
+def content
+  if @selected_action_id
+    @selected_content ||= begin
+      change = last_change_on( :db_content, :not_after=> @selected_action_id ) and change.value
+    end
+  else
+    db_content or (new_card? && template.db_content)
+  end
+end
+
+def content=(value)
+  @selected_content = nil
+  self.db_content = value
+end
+
+def raw_content
+  structure ? template.db_content : db_content
+end
+
+def chunk_list #override to customize by set
+  :default
+end
+
+def last_change_on(field, opts={})
+  where_sql =  'card_actions.card_id = :card_id AND field = :field AND (draft = 0 OR draft IS NULL)'
+  where_sql += if opts[:before]
+    'AND card_action_id < :action_id'      
+  elsif opts[:not_after]
+    'AND card_action_id <= :action_id'
+  else
+    ''
+  end
+  
+  action_arg = opts[:before] || opts[:not_after]
+  action_id =  (action_arg.kind_of?(Card::Action) && action_arg.id) or action_arg
+  field_index = Card::TRACKED_FIELDS.index(field.to_s)
+  Change.joins(:action).where( where_sql, 
+    {:card_id=>id, :field=>field_index, :action_id=>action_id}
+  ).order(:id).last
+end
+
+def selected_action_id
+  @selected_action_id || (@current_action and @current_action.id) || last_action_id 
+end
+
+def selected_action_id= action_id
+  @selected_content = nil
+  @selected_action_id = action_id
+end
+
+def selected_action
+  selected_action_id and Action.fetch(selected_action_id)
+end
+
+def selected_content_action_id
+  @selected_action_id ||  
+  (@current_action and @current_action.new_content? and @current_action.id) || 
+  last_content_action_id 
+end
+
+def last_action_id
+  last_action and last_action.id
+end
+def last_action
+  actions.where('id IS NOT NULL').last
+end
+def last_content_action
+  l_c = last_change_on(:db_content) and l_c.action
+end
+def last_content_action_id
+  l_c = last_change_on(:db_content) and l_c.card_action_id
+end
+
+
+def previous_action action_id
+  if action_id
+    action_index = actions.find_index do |a|
+      a.id == action_id
+    end
+    actions[action_index - 1] if action_index.to_i != 0
+  end
+end
+
+def revised_at
+  (last_action and act=last_action.act and act.acted_at) or Time.now
+end
+
+def creator
+  Card[ creator_id ]
+end
+
+def updater
+  Card[ updater_id ]
+end
+
+def clean_html?
+  true
+end
+
+
+def draft_acts
+  drafts.created_by(Card::Auth.current_id).map(&:act)
+end
+
+def save_content_draft( content )
+  clear_drafts
+  acts.create do |act|
+    act.actions.build(:draft => true, :card_id=>id).changes.build(:field=>:db_content, :value=>content)
+  end
+end
+
+def clear_drafts
+  drafts.created_by(Card::Auth.current_id).each do |draft|
+    draft.delete
+  end
+end
+
+
+event :save_draft, :before=>:store, :on=>:update, :when=>proc{ |c| Env.params['draft'] == 'true' } do
+  save_content_draft content
+  abort :success
+end
+
+
+event :set_default_content, :on=>:create, :before=>:approve do  
+  if !db_content_changed? and template and template.db_content.present?
+    self.db_content = template.db_content
+  end
+end
+
+event :protect_structured_content, :before=>:approve, :on=>:update, :changed=>:db_content do  
+  if structure
+    errors.add :content, "can't change; structured by #{template.name}"
+  end
+end
+
+
+event :detect_conflict, :before=>:approve, :on=>:update do
+  if last_action_id_before_edit and last_action_id_before_edit.to_i != last_action_id and last_action.act.actor_id != Auth.current_id
+    errors.add :conflict, "changes not based on latest revision"
+  end
+end

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

@@ -0,0 +1,11 @@
+format do
+  def render_erb locals={}, template=nil, a_binding=nil, &block
+    template ||= block.call
+    a_binding ||= binding
+    locals.each do |k,v|
+      #a_binding.local_variable_set(k, v) # needs ruby 2.1
+      instance_variable_set("@#{k}",v)
+    end
+    ERB.new(template,nil,'-').result(binding)
+  end
+end

data/mod/{core → 01_core}/set/all/fetch.rb

@@ -21,7 +21,14 @@ module ClassMethods
   
   
   def fetch mark, opts={}
-
+    if String === mark
+      case mark
+      when /^\~(\d+)$/ # get by id
+        mark = $1.to_i 
+      when /^\:(\w+)$/ # get by codename
+        mark = $1.to_sym
+      end
+    end
     mark = Card::Codename[mark] if Symbol === mark # id from codename
 
     if mark.present?

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

@@ -0,0 +1,7 @@
+format do
+  def render_haml locals={}, template=nil, a_binding=nil, &block
+    template ||= block.call
+    a_binding ||= binding
+    ::Haml::Engine.new(template).render(a_binding, locals)
+  end
+end

data/mod/{core → 01_core}/set/all/initialize.rb

@@ -20,6 +20,8 @@ def initialize args={}
     :type_code => args.delete('type_code'),
     :type_id   => args[       'type_id'  ]
   }
+  
+  args['db_content'] = args.delete('content') if args['content']
 
   #FIXME -- too much of the above is duplicated by assign_attributes (tracked_attributes.rb)
 
@@ -27,11 +29,11 @@ def initialize args={}
   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

data/mod/{core → 01_core}/set/all/name.rb

@@ -195,7 +195,7 @@ event :set_name, :before=>:store, :changed=>:name do
       suspend_name(sidename) if old_name_in_way
       send "#{side}_id=", begin
         if !sidecard || old_name_in_way
-          Card.create! :name=>sidename
+          Card.create! :name=>sidename, :supercard => self
         else
           sidecard
         end.id
@@ -213,7 +213,6 @@ event :rename, :after=>:set_name, :on=>:update do
     existing_card.rename_without_callbacks
     existing_card.save!
   end
-  @name_or_content_changed=true
 end
 
 def suspend_name(name)
@@ -259,7 +258,7 @@ event :cascade_name_changes, :after=>:store, :on=>:update, :changed=>:name do
         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.db_content = card.replace_references name_was, name
           card.save!
         end
       end

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

@@ -0,0 +1,215 @@
+
+class FollowerStash  
+  def initialize card=nil
+    @followed_affected_cards = Hash.new { |h,v| h[v]=[] } 
+    @visited = ::Set.new
+    add_affected_card(card) if card
+  end
+    
+  def add_affected_card card
+    Auth.as_bot do
+      if !@visited.include? card.name
+        @visited.add card.name
+        # add card followers
+        Card.search( :right_plus=>[{:codename=> "following"}, 
+                             {:link_to=>card.name}     ]
+                   ).each do |follower|
+                     notify follower, :of => card.name
+                   end
+        # add cardtype followers
+        Card.search( :right_plus=>[{:codename=> "following"}, 
+                             {:link_to=>card.type_name} ]
+                   ).each do |follower|
+                    notify follower, :of => card.type_name
+                  end
+        Card.search(:include=>card.name).each do |includer| 
+          add_affected_card includer unless @visited.include? includer.name
+        end
+        if card.left and !@visited.include?(card.left.name) and
+           includee_set = Card.search(:included_by=>card.left.name).map(&:name) and
+           !@visited.intersection(includee_set).empty?
+              add_affected_card card.left
+        end
+      end
+    end
+  end
+  
+  def followers
+    @followed_affected_cards.keys
+  end
+  
+  def each_follower_followed_pair  # "follower" is a card object, "followed" a card name
+    @followed_affected_cards.each do |user, card_names|
+      yield(user,card_names.first)
+    end
+  end
+  
+  private
+  
+  def notify follower, because
+    @followed_affected_cards[follower] << because[:of]
+  end
+  
+end
+
+def act_card
+  @supercard || self
+end
+
+event :stash_followers, :after=>:approve, :on=>:delete do
+  act_card.follower_stash ||=  FollowerStash.new
+  act_card.follower_stash.add_affected_card self
+end
+
+event :notify_followers, :after=>:extend, :when=>proc{ |c|
+    !c.supercard and c.current_act and Card::Auth.current_id != WagnBotID 
+  }  do
+    
+  begin
+    @current_act.reload
+    @follower_stash ||= FollowerStash.new
+    @current_act.actions.each do |a|
+      @follower_stash.add_affected_card a.card
+    end
+    @follower_stash.each_follower_followed_pair do |follower, followed|
+      if follower.account and follower != @current_act.actor
+        follower.account.send_change_notice @current_act, followed
+      end
+    end
+  rescue =>e  #this error handling should apply to all extend callback exceptions
+    Airbrake.notify e if Airbrake.configuration.api_key
+    Rails.logger.info "\nController exception: #{e.message}"
+    Rails.logger.debug "BT: #{e.backtrace*"\n"}"
+  end
+end
+  
+format do  
+  view :list_of_changes, :denial=>:blank do |args|
+    action = get_action(args)
+    
+    relevant_fields = case action.action_type
+      when :create then [:cardtype, :content]
+      when :update then [:name, :cardtype, :content]
+      when :delete then [:content]
+      end
+    
+    relevant_fields.map do |type| 
+      edit_info_for(type, action)
+    end.compact.join
+  end
+  
+  
+  view :subedits do |args|
+    subedits = get_act(args).relevant_actions_for(card).map do |action| 
+        if action.card_id != card.id 
+          action.card.format(:format=>@format).render_subedit_notice(:action=>action)
+        end
+      end.compact.join
+      
+    if subedits.present?
+      wrap_subedits subedits
+    else
+      ''
+    end
+  end
+    
+  view :subedit_notice, :denial=>:blank do |args|
+    action = get_action(args)
+    name_before_action = (action.new_values[:name] && action.old_values[:name]) || card.name
+    
+    wrap_subedit_item %{#{name_before_action} #{action.action_type}d
+#{ render_list_of_changes(args) }}
+  end
+  
+  view :followed do |args|
+    args[:followed] || 'followed card'
+  end
+
+  view :follower do |args|
+    args[:follower] || 'follower'
+  end
+  
+  view :unfollow_url do |args|
+    if args[:followed] and args[:follower] and follower = Card.fetch( args[:follower] )
+     following_card = follower.fetch( :trait=>:following, :new=>{} )
+     wagn_url( "update/#{following_card.cardname.url_key}?drop_item=#{args[:followed].to_name.url_key}" )
+    end
+  end
+  
+  def edit_info_for field, action
+    return nil unless action.new_values[field]
+    
+    item_title = case action.action_type
+    when :update then 'new '
+    when :delete then 'deleted '
+    else ''
+    end
+    item_title +=  "#{field}: "
+
+    item_value = if action.action_type == :delete
+      action.old_values[field]
+    else
+      action.new_values[field]
+    end
+    
+     wrap_list_item "#{item_title}#{item_value}"
+  end
+  
+  def get_act args
+    @notification_act ||= args[:act] || (args[:act_id] and Act.find(args[:act_id])) || card.acts.last
+  end
+  
+  def get_action args
+    args[:action] || (args[:action_id] and Action.fetch(args[:action_id])) || card.last_action
+  end
+  
+  
+  def wrap_subedits subedits
+    "\nThis update included the following changes:#{wrap_list subedits}"
+  end
+     
+  def wrap_list list
+    "\n#{list}\n"
+  end
+  
+  def wrap_list_item item
+    "   #{item}\n"
+  end
+  
+  def wrap_subedit_item text
+    "\n#{text}\n"
+  end
+end
+
+
+format :email_text do 
+  view :last_action do |args|
+    act = get_act(args)
+    action_on_card =  act.action_on(act.card_id) || act.actions.first
+    "#{action_on_card.action_type}d"
+  end
+end
+
+format :email_html do  
+  view :last_action do |args|
+    act = get_act(args)
+    action_on_card =  act.action_on(act.card_id) || act.actions.first
+    "#{action_on_card.action_type}d"
+  end
+  
+  def wrap_list list
+    "<ul>#{list}</ul>\n"
+  end
+
+  def wrap_list_item item
+    "<li>#{item}</li>\n"
+  end
+  
+  def wrap_subedit_item text
+    "<li>#{text}</li>\n"
+  end
+end
+
+
+
+