wagn 1.13.0 → 1.14.0.pre1

data/{spec/mod/standard → mod/04_settings/spec}/set/right/comment_spec.rb

@@ -9,18 +9,18 @@ describe Card::Set::Right::Comment do
     end
 
     it "should have appender immediately" do
-      Card['a'].ok?(:comment).should_not be_true
+      expect(Card['a'].ok?(:comment)).not_to be_truthy
       Card::Auth.as_bot do
         @rule.save!
       end
-      Card['a'].ok?(:comment).should be_true
+      expect(Card['a'].ok?(:comment)).to be_truthy
     end
 
     it "should have appender immediately" do
       Card::Auth.as_bot do 
-        Card['a'].ok?(:comment).should_not be_true 
+        expect(Card['a'].ok?(:comment)).not_to be_truthy 
         @rule.save!
-        Card['a'].ok?(:comment).should be_true
+        expect(Card['a'].ok?(:comment)).to be_truthy
       end
     end
   end
@@ -34,7 +34,7 @@ describe Card::Set::Right::Comment do
         @c.comment = " and more\n  \nsome lines\n\n"
         @c.save!
       end
-      Card["basicname"].content.should =~ /\<p\>some lines\<\/p\>/
+      expect(Card["basicname"].content).to match(/\<p\>some lines\<\/p\>/)
     end
   end
 

data/{spec/mod/standard → mod/04_settings/spec}/set/right/structure_spec.rb

@@ -3,13 +3,15 @@
 describe Card::Set::Right::Structure do
   it "closed_content is rendered as type + raw" do
     template = Card.new(:name=>'A+*right+*structure', :content=>'[[link]] {{inclusion}}')
-    template.format._render(:closed_content).should ==
+    expect(template.format._render(:closed_content)).to eq(
       '<a href="/Basic" class="cardtype">Basic</a> : [[link]] {{inclusion}}'
+    )
   end
 
   it "closed_content is rendered as type + raw" do
     template = Card.new(:name=>'A+*right+*structure', :type=>'Html', :content=>'[[link]] {{inclusion}}')
-    template.format._render(:closed_content).should ==
+    expect(template.format._render(:closed_content)).to eq(
       '<a href="/HTML" class="cardtype">HTML</a> : [[link]] {{inclusion}}'
+    )
   end
 end

data/{spec/mod/standard → mod/04_settings/spec}/set/right/style_spec.rb

@@ -1,6 +1,6 @@
 # -*- encoding : utf-8 -*-
 
-require File.expand_path('../../../lib/machine_spec.rb', __FILE__)
+require File.expand_path('../../../../../03_machines/spec/lib/machine_spec.rb', __FILE__)
 
 describe Card::Set::Right::Style do
 #  describe "#delet"

data/mod/{standard → 05_standard}/set/all/all_csv.rb

@@ -28,7 +28,7 @@ format :csv  do
     begin
       card1 = search_vars[:results].first  
     
-      parsed_content = Card::Content.new card1.content, self
+      parsed_content = Card::Content.new card1.raw_content, self
       unless String === parsed_content.__getobj__
         titles = parsed_content.map do |chunk|
           next if chunk.class != Card::Chunk::Include

data/mod/05_standard/set/all/all_js.rb

@@ -0,0 +1,7 @@
+    
+format :js do
+  view :include_tag do |args|
+    %{\n#{javascript_include_tag page_path(card.name) }\n }
+  end
+  
+end

data/mod/{standard → 05_standard}/set/all/attach.rb

@@ -1,23 +1,18 @@
-
-def attach_array(rev_id=nil)
-  c=if rev_id || self.new_card? || selected_revision_id==current_revision_id
-      self.content
-    else      
-      Card::Revision.find_by_id(selected_revision_id).content
-    end
+def attach_array
+  
+  c= self.content
   !c || c =~ /^\s*<img / ?  ['','',''] : c.split(/\n/)
 end
 
+#ask ethan
 def attach_array_set i, v
-  rev_id = ( cr = current_revision and cr.id )
-  c = attach_array rev_id
-  c = c[0..2] # make sure there is no mod set for uploaded files
-  
+  c = attach_array[0..2]  # make sure there is no mod set for uploaded files
   if c[i] != v
     c[i] = v
     self.content = c*"\n"
   end
 end
+
 def attach_file_name()    attach_array[0] end
 def attach_content_type() attach_array[1] end
 def attach_file_size()    attach_array[2] end
@@ -40,13 +35,17 @@ STYLES = %w{ icon small medium large original }
 
 
 def attachment_format(ext)
-  return nil unless ext.present? && attach
-  return nil unless original_ext = attach_extension
-  return original_ext if ['file', original_ext].member? ext
-  exts = MIME::Types[attach.content_type]
-  return nil unless exts
-  return ext if exts.find {|mt| mt.extensions.member? ext }
-  return exts[0].extensions[0]
+  if ext.present? and attach and original_ext=attach_extension 
+    if['file', original_ext].member? ext
+      original_ext
+    elsif exts = MIME::Types[attach.content_type] 
+      if exts.find {|mt| mt.extensions.member? ext }
+        ext
+      else
+        exts[0].extensions[0]
+      end
+    end
+  end   
 rescue => e
   Rails.logger.info "attachment_format issue: #{e.message}"
   nil
@@ -55,31 +54,30 @@ end
 # FIXME: test extension matches content type
 
 
-
-def attachment_link(rev_id) # create filesystem links to previous revision
+def attachment_symlink_to(previous_action_id) # create filesystem links to files from previous action
   if styles = case type_code
-        when 'File'; ['']
-        when 'Image'; STYLES
+        when :file; ['']
+        when :image; STYLES
       end
-    save_rev_id = selected_revision_id
+    save_action_id = selected_action_id
     links = {}
 
-    self.selected_revision_id = rev_id
+    self.selected_action_id = previous_action_id
     styles.each { |style|  links[style] = attach.path(style)          }
 
-    self.selected_revision_id = current_revision_id
-    styles.each { |style|  File.link links[style], attach.path(style) }
+    self.selected_action_id = last_action_id
+    styles.each { |style|  ::File.symlink links[style], attach.path(style) }
 
-    self.selected_revision_id = save_rev_id
+    self.selected_action_id = save_action_id
   end
 end
 
 def before_post_attach
 #  Rails.logger.info "bpa called for #{name}"
+
   at=self.attach
   at.instance_write :file_name, at.original_filename
-
-  Card::ImageID == (type_id || Card.fetch_id( @type_args[:type] ) )
+  Card::ImageID == (type_id || Card.fetch_id( @type_args[:type] || @type_args[:type_code]) )
   # returning true enables thumnail creation
 end
 
@@ -88,8 +86,8 @@ def self.included(base)
   base.class_eval do
     has_attached_file :attach, :preserve_files=>true,
       :default_url => "missing",
-      :url => ":file_path/:basename-:size:revision_id.:extension",
-      :path => ":local/:card_id/:size:revision_id.:extension",
+      :url => ":file_path/:basename-:size:action_id.:extension",
+      :path => ":local/:card_id/:size:action_id.:extension",
       :styles => { :icon   => '16x16#', :small  => '75x75',
                  :medium => '200x200>', :large  => '500x500>' }
 
@@ -97,7 +95,7 @@ def self.included(base)
 
     validates_each :attach do |rec, attr, value|
       if [Card::FileID, Card::ImageID].member? rec.type_id
-        max_size = (max = Card['*upload max']) ? max.content.to_i : 5
+        max_size = (max = Card['*upload max']) ? max.db_content.to_i : 5
         if value.size.to_i > max_size.megabytes
           rec.errors.add :file_size, "File cannot be larger than #{max_size} megabytes"
         end
@@ -137,6 +135,8 @@ module Paperclip::Interpolations
     at.instance.type_id==Card::FileID || style_name.blank? ? '' : "#{style_name}-"
   end
 
-  def revision_id(at, style_name) at.instance.selected_revision_id end
+  def action_id(at, style_name) 
+    at.instance.selected_content_action_id 
+  end
 end
 

data/mod/05_standard/set/all/follow.rb

@@ -0,0 +1,51 @@
+def toggle_subscription_for watcher
+  following = watcher.fetch :trait=>:following, :new=>{:type=>:pointer}
+  if following.items.include? card
+    following.drop_item card.name
+  else
+    following.add_item card.name
+  end
+  following.save
+end
+
+
+format :html do
+  watch_perms = lambda { |r| Auth.signed_in? && !r.card.new_card? }
+  
+  view :watch, :tags=>[:unknown_ok, :no_wrap_comments], :denial=>:blank, :perms=>:none do |args|
+    wrap args do
+      link_args = if card.watched?
+        [card,"following", :off, "stop sending emails about changes to #{card.name}", { :hover_content=> 'unfollow' } ]
+      elsif card.type_watched?
+        [card.type_card, "(following)", :off, "stop sending emails about changes to #{card.type_name} cards", { :hover_content=> 'unfollow' } ]
+      else
+        [card,"follow", :on, "send emails about changes to #{card.name}" ]
+      end
+      watch_link *link_args
+    end
+  end
+
+  def watch_link watched_card, text, toggle, title, extra={}
+    return '' unless watched_card
+    
+    following = Auth.current.fetch :trait=>:following, :new=>{:type=>:pointer}
+    path_hash = {:card=>following, :action=>:update, :toggle=>toggle, 
+                 :success=>{:id=>card.name, :view=>:watch} }
+    case toggle
+    when :off then path_hash[:drop_item] = watched_card.cardname.url_key
+    when :on  then path_hash[:add_item]  = watched_card.cardname.url_key
+    end
+
+    link_to "#{text}", path(path_hash), 
+      {:class=>"watch-toggle watch-toggle-#{toggle} slotter", :title=>title, :remote=>true, :method=>'post'}.merge(extra)
+  end
+  
+end
+
+
+
+def type_watched?; Auth.current.fetch(:trait=>:following, :new=>{}).include_item? type_card.cardname.url_key end
+def watched?;     Auth.current.fetch(:trait=>:following, :new=>{}).include_item? cardname.url_key end
+
+
+

data/mod/05_standard/set/all/history.rb

@@ -0,0 +1,294 @@
+REVISIONS_PER_PAGE = Wagn.config.revisions_per_page
+
+# must be called on all actions and before :set_name, :process_subcards and :validate_delete_children
+def create_act_and_action
+  @current_act = if @supercard 
+    @supercard.current_act || @supercard.acts.build(:ip_address=>Env.ip)
+  else
+    acts.build(:ip_address=>Env.ip)
+  end
+  
+  @current_action = actions.build(:action_type=>@action, :draft=>(Env.params['draft'] == 'true') )
+  @current_action.act = @current_act
+  
+  # @current_act = (@supercard ? @supercard.current_act : Card::Act.new(:ip_address=>Env.ip))
+  # if !@supercard
+  #   @current_act.card = self
+  # end
+  # @current_action = @current_act.actions.build(:action_type=>@action, :draft=>(Env.params['draft'] == 'true') )
+  # @current_action.card = self
+  
+  if (@supercard and @supercard !=self)
+    @current_action.super_action = @supercard.current_action
+  end
+end
+
+
+
+event(:create_act_and_action_for_save,   :before=>:process_subcards, :on=>:save)   { create_act_and_action }
+event(:create_act_and_action_for_delete, :before =>:validate_delete_children, :on=>:delete) { create_act_and_action }
+
+
+event :remove_empty_act, :after=>:extend do
+  # if not @supercard and not @current_act.actions.empty?
+  #   @current_act.save
+  # end
+  @current_act.reload
+  if not @supercard and @current_act.actions.empty?
+     @current_act.delete
+     @current_act = nil
+   end
+end
+
+
+
+event :rollback_actions, :before=>:approve, :on=>:update, :when=>proc{ |c| Env and Env.params['action_ids'] and Env.params['action_ids'].class == Array} do
+  revision = { :subcards => {}}
+  rollback_actions = Env.params['action_ids'].map do |a_id|
+    Action.fetch(a_id) || nil
+  end
+  rollback_actions.each do |action|  
+    if action.card_id == id
+      revision.merge!(revision(action)) 
+    else
+      revision[:subcards].merge!(revision(action))
+    end
+  end
+  
+  Env.params['action_ids'] = nil
+  update_attributes! revision
+  rollback_actions.each do |action|
+    action.card.attachment_symlink_to action.id
+  end
+  clear_drafts
+  abort :success
+end
+
+
+
+
+
+def intrusive_family_acts args={}   # all acts with actions on self and on cards that are descendants of self and included in self
+  @intrusive_family_acts ||= begin
+    Act.find_all_with_actions_on( (included_descendant_card_ids << id), args)
+  end
+end
+
+def intrusive_acts  args={:with_drafts=>true} # all acts with actions on self and on cards included in self
+  @intrusive_acts ||= begin
+    Act.find_all_with_actions_on( (included_card_ids << id), args)
+  end
+end
+
+def current_rev_nr
+  @current_rev_nr ||= begin
+    @intrusive_acts.first.actions.last.draft ? @intrusive_acts.size - 1 : @intrusive_acts.size
+  end
+end
+
+def included_card_ids
+  Card::Reference.select(:referee_id).where( :ref_type => 'I', :referer_id=>id ).pluck('referee_id').compact.uniq
+end 
+  
+def descendant_card_ids parent_ids=[id]
+  more_ids = Card.where('left_id IN (?)', parent_ids).pluck('id')
+  
+  if !more_ids.empty? 
+    more_ids += descendant_card_ids more_ids
+  end
+  more_ids
+end
+
+def included_descendant_card_ids
+  included_card_ids & descendant_card_ids
+end
+
+format :html do
+  view :history do |args|
+    frame args.merge(:body_class=>"history-slot", :content=>true, :subheader=>_render_revision_subheader ) do
+      _render_revisions
+    end
+  end
+
+  view :revisions do |args| 
+    page = params['page'] || 1
+    count = card.intrusive_acts.size+1-(page.to_i-1)*REVISIONS_PER_PAGE
+    card.intrusive_acts.page(page).per(REVISIONS_PER_PAGE).map do |act|      
+      count -= 1
+      render_act_summary args.merge(:act=>act,:rev_nr=>count)
+    end.join
+  end
+  
+  view :revision_subheader do |args|
+    intr = card.intrusive_acts.page(params['page']).per(REVISIONS_PER_PAGE)
+    render_haml :intr=>intr do 
+      %{
+.history-header  
+  %span.slotter
+    = paginate intr, :remote=>true
+  %span.history-legend{:style=>"text-align:right;"}
+    %i.fa.fa-circle.diff-green
+    %span
+      = Card::Diff.render_added_chunk("Added")
+      |
+    %i.fa.fa-circle.diff-red
+    %span
+      = Card::Diff.render_deleted_chunk("Deleted")
+      }
+    end
+  end
+  
+  view :act_summary do |args|
+    render_act :summary, args
+  end
+  
+  view :act_expanded do |args|
+    render_act :expanded, args
+  end
+  
+  def render_act act_view, args
+    act = (params['act_id'] and Card::Act.find(params['act_id'])) || args[:act]
+    rev_nr = params['rev_nr'] || args[:rev_nr] 
+    current_rev_nr = params['current_rev_nr'] || args[:current_rev_nr] || card.current_rev_nr
+    hide_diff = (params["hide_diff"]=="true") || args[:hide_diff]
+    wrap( args.merge(:slot_class=>"revision-#{act.id} history-slot") ) do
+      render_haml :card=>card, :act=>act, :act_view=>act_view, 
+                  :current_rev_nr=>current_rev_nr, :rev_nr=>rev_nr, 
+                  :hide_diff=> hide_diff do 
+        %{
+.act{:style=>"clear:both;"}
+  .head
+    .nr
+      = "##{rev_nr}"
+    .title
+      .actor
+        = link_to act.actor.name, wagn_url( act.actor )
+      .time.timeago
+        = time_ago_in_words(act.acted_at)
+        ago
+        - if act.actions.last.draft
+          |
+          %em.info
+            Autosave
+        - if current_rev_nr == rev_nr
+          |
+          %em.info
+            Current
+        - elsif act_view == :expanded
+          = rollback_link act.relevant_actions_for(card, act.actions.last.draft)
+          = show_or_hide_changes_link hide_diff, :act_id=>act.id, :act_view=>act_view, :rev_nr=>rev_nr, :current_rev_nr=>current_rev_nr 
+  .toggle
+    = fold_or_unfold_link :act_id=>act.id, :act_view=>act_view, :rev_nr=>rev_nr, :current_rev_nr=>current_rev_nr
+  
+  .action-container{:style=>("clear: left;" if act_view == :expanded)}
+    - act.relevant_actions_for(card).each do |action|
+      = send("_render_action_#{ act_view }", :action=>action )
+      }
+      end
+    end
+  end
+  
+  view :action_summary do |args|
+    render_action :summary, args
+  end
+  
+  view :action_expanded do |args|
+    render_action :expanded, args
+  end
+
+  def render_action action_view, args
+    action = args[:action] || card.last_action
+    render_haml :action => action, 
+                :action_view=>action_view, 
+                :hide_diff=>Env.params["hide_diff"]=="true" || args[:hide_diff] do
+      %{
+.action
+  .summary
+    %span.ampel   
+      %i.fa.fa-circle{:class=>(action.red? ? 'diff-red' : 'diff-invisible')}
+      %i.fa.fa-circle{:class=>(action.green? ? 'diff-green' : 'diff-invisible')}
+    -if action.card == card
+      = wrap_diff :name do
+        - name_changes(action, hide_diff)
+    -else
+      =  link_to path(:view=>:related, :related=>{:view=>"history",:name=>action.card.name}), :class=>'slotter name-diff', 
+                   :slotSelector=>".card-slot.card-frame", :remote=>true do
+        - name_changes(action, hide_diff)    
+    -if action.new_type?
+      = wrap_diff :type do
+        - type_changes action, hide_diff
+    -if action.new_content?
+      %i.fa.fa-arrow-right.arrow
+      -if action_view == :summary 
+        = wrap_diff :content do
+          - action.card.format.render_content_changes :action=>action, :diff_type=>action_view, :hide_diff=>hide_diff
+  -if action.new_content? and action_view == :expanded
+    .expanded
+      = wrap_diff :content do
+        - action.card.format.render_content_changes :action=>action, :diff_type=>action_view, :hide_diff=>hide_diff
+        }
+    end
+  end
+
+  def wrap_diff field, &block
+    content = block.call
+    if content.present?
+      %{
+         <span class="#{field}-diff">
+         #{content}
+         </span>
+      }
+    end
+  end
+  
+  def name_changes action, hide_diff=false
+    old_name = (name = action.old_values[:name] and showname(name).to_s)
+    if action.new_name?
+      new_name = showname(action.new_values[:name]).to_s
+      if hide_diff 
+        new_name
+      else
+        Card::Diff::DiffBuilder.new(old_name,new_name).complete
+      end
+    else
+      old_name
+    end
+  end
+  
+  def type_changes action, hide_diff=false
+    change = hide_diff ? action.new_values[:cardtype] : action.cardtype_diff
+    "(#{change})"
+  end
+  
+  view :content_changes do |args|
+    if args[:hide_diff]
+      args[:action].new_values[:content]
+    else 
+      args[:action].content_diff(args[:diff_type])
+    end
+  end
+
+  def rollback_link action_ids
+    if card.ok?(:update) 
+      "| " + link_to('Save as current', path(:action=>:update, :view=>:open, :action_ids=>action_ids,),
+        :class=>'slotter',:slotSelector=>'.card-slot.card-frame', :remote=>true, :method=>:post, :rel=>'nofollow')
+    end
+  end
+
+  def fold_or_unfold_link args
+    if (args[:act_view] == :expanded)
+      toggled_view = :act_summary
+    else
+      toggled_view = :act_expanded
+    end
+    link_to '', path(args.merge(:view=>toggled_view)), 
+              :class=>"slotter revision-#{args[:act_id]} #{ args[:act_view]==:expanded ? "arrow-down" : "arrow-right"}", 
+              :remote=>true
+  end
+  
+  def show_or_hide_changes_link hide_diff, args
+    "| " +  link_to_view( (hide_diff ? "Show" : "Hide") + " changes", :act_expanded, 
+      :path_opts=>args.merge(:hide_diff=>!hide_diff), 
+      :class=>'slotter', :remote=>true )
+  end
+end