wagn 1.13.0 → 1.14.0.pre1

data/{spec/mod/standard → mod/05_standard/spec}/set/type/toggle_spec.rb

@@ -6,7 +6,7 @@ describe Card::Set::Type::Toggle do
   end
 
   it "should have yes/no as processed content" do
-    render_card(:core, :type=>'Toggle', :content=>"0").should == 'no'
-    render_card(:closed_content, :type=>'Toggle', :content=>"1").should == 'yes'
+    expect(render_card(:core, :type=>'Toggle', :content=>"0")).to eq('no')
+    expect(render_card(:closed_content, :type=>'Toggle', :content=>"1")).to eq('yes')
   end
 end

data/mod/06_email/format/email_text_format.rb

@@ -0,0 +1,7 @@
+# -*- encoding : utf-8 -*-
+
+class Card::EmailTextFormat < Card::TextFormat  
+  def internal_url relative_path
+    wagn_url relative_path
+  end
+end

data/mod/06_email/set/all/email_html.rb

@@ -0,0 +1,9 @@
+format :email_html do
+  view :missing        do |args| '' end
+  view :closed_missing do |args| '' end
+end
+
+
+def clean_html?
+  false
+end

data/mod/{standard/set/all/email_html.rb → 06_email/set/all/email_text.rb}

@@ -1,5 +1,6 @@
 
-format :email do
+
+format :email_text do  
   view :missing        do |args| '' end
   view :closed_missing do |args| '' end
 end

data/mod/06_email/set/right/bcc.rb

@@ -0,0 +1,31 @@
+def chunk_list  #turn off autodetection of uri's 
+  :inclusion_and_link
+end
+
+def process_email_addresses context_card, format_args, args
+  format(format_args).render_email_addresses(args.merge(:context=>context_card))
+end
+
+
+
+format :email_text do
+  view :email_addresses do |args|
+    context = args[:context] || self
+    card.item_names.map do |item_name|
+      item_name = item_name.to_name.to_absolute(context).to_s
+      if item_name.match /.+\@.+\..+/ 
+        item_name
+      elsif item_card = Card.fetch( item_name )
+        if item_card.account
+          item_card.account.email
+        else
+          item_card.contextual_content(context,:format=>:email_text).split( /[,\n]/ )
+        end
+      end          
+    end.flatten.compact.join(', ')
+  end
+end
+
+
+
+# _user, info@mail.com, Ethan, Pointer -> ..., _left+email, my email address -> info@mail.com

data/mod/06_email/set/right/cc.rb

@@ -0,0 +1,2 @@
+include Bcc
+format(:email_text) { include Bcc::EmailTextFormat }

data/mod/06_email/set/right/from.rb

@@ -0,0 +1,2 @@
+include Bcc
+format(:email_text) { include Bcc::EmailTextFormat }

data/mod/06_email/set/right/html_message.rb

@@ -0,0 +1,3 @@
+def clean_html?
+  false
+end

data/mod/06_email/set/right/to.rb

@@ -0,0 +1,2 @@
+include Bcc
+format(:email_text) { include Bcc::EmailTextFormat }

data/mod/06_email/set/type/email_template.rb

@@ -0,0 +1,99 @@
+def clean_html?
+  false
+end
+
+def deliver args={}
+  mail = format.render_mail(args)
+  mail.deliver 
+end
+
+def process_email_field field, args
+  if args[field] 
+    args[field]
+  elsif field_card = fetch(:trait=>field)
+    # configuration can be anything visible to configurer
+    Auth.as( field_card.updater ) do
+      res = field_card.send(*yield)
+    end
+  else 
+    ''
+  end
+end
+
+
+
+def email_config args={}
+  config = {}
+  context_card = args[:context] || self
+
+  [:to, :from, :cc, :bcc].each do |field_name|
+    config[field_name] = process_email_field( field_name, args ) do 
+      [:process_email_addresses, context_card, {:format=>'email_text'}, args]
+    end
+  end
+
+  config[:attach] = process_email_field( :attach, args ) do 
+      [:extended_item_contents, context_card]
+    end
+  
+  [:subject, :text_message].each do |field_name|
+    config[field_name] = process_email_field( field_name, args ) do 
+      [:contextual_content, context_card, {:format=>'email_text'}, args]
+    end
+  end
+
+  config[:html_message] = process_email_field :html_message, args do
+    [:contextual_content, context_card, {:format=>'email_html'}, args]
+  end
+
+  config[:html_message] = Card::Mailer.layout(config[:html_message])
+  config[:from] ||= Card[Card::WagnBotID].account.email
+  config.select {|k,v| v.present? }
+end
+
+
+format do     
+  view :mail do |args|
+    args = card.email_config(args)
+    text_message = args.delete(:text_message)
+    html_message = args.delete(:html_message)
+    attachment_list = args.delete(:attach)
+    alternative = text_message.present? and html_message.present?
+    mail = Card::Mailer.new_mail(args) do
+      if alternative 
+        if attachment_list and !attachment_list.empty?
+          content_type 'multipart/mixed'
+          part :content_type => 'multipart/alternative' do |copy|
+            copy.part :content_type => 'text/plain' do |plain|
+              plain.body = text_message
+            end
+            copy.part :content_type => 'text/html' do |html|
+              html.body = html_message
+            end
+          end    
+        else
+          text_part { body text_message }
+          html_part do
+            content_type 'text/html; charset=UTF-8'
+            body html_message
+          end
+        end
+      elsif html_message.present?
+        content_type 'text/html; charset=UTF-8'
+        body html_message
+      else
+        text_part { body text_message }
+      end
+      
+      if attachment_list
+        attachment_list.each_with_index do |cardname, i|
+          if c = Card[ cardname ] and c.respond_to?(:attach)
+            add_file :filename => "attachment-#{i + 1}.#{c.attach_extension}", :content => File.read( c.attach.path )
+          end
+        end
+      end    
+    end   #TODO add error handling
+    mail
+  end
+  
+end

data/spec/controllers/card_controller_spec.rb

@@ -3,43 +3,43 @@
 describe CardController do
 
   include Wagn::Location
-
+  include Capybara::DSL
   describe "- route generation" do
 
     it "should recognize type" do
-      { :get => "/new/Phrase" }.should route_to( :controller => 'card', :action=>'read', :type=>'Phrase', :view=>'new' )
+      expect({ :get => "/new/Phrase" }).to route_to( :controller => 'card', :action=>'read', :type=>'Phrase', :view=>'new' )
     end
 
     it "should recognize .rss on /recent" do
-      {:get => "/recent.rss"}.should route_to(:controller=>"card", :action=>"read", :id=>":recent", :format=>"rss")
+      expect({:get => "/recent.rss"}).to route_to(:controller=>"card", :action=>"read", :id=>":recent", :format=>"rss")
     end
 
     it "should handle RESTful posts" do
-      { :put => '/mycard' }.should route_to( :controller=>'card', :action=>'update', :id=>'mycard')
-      { :put => '/' }.should route_to( :controller=>'card', :action=>'update')
+      expect({ :put => '/mycard' }).to route_to( :controller=>'card', :action=>'update', :id=>'mycard')
+      expect({ :put => '/' }).to route_to( :controller=>'card', :action=>'update')
       
     end
 
     it "handle asset requests" do
-       { :get => "/asset/application.js" }.should route_to( :controller => 'card',:action=>'asset', :id => 'application', :format=> 'js' )
+       expect({ :get => "/asset/application.js" }).to route_to( :controller => 'card',:action=>'asset', :id => 'application', :format=> 'js' )
     end
 
     ["/wagn",""].each do |prefix|
       describe "routes prefixed with '#{prefix}'" do
         it "should recognize .rss format" do
-          {:get => "#{prefix}/*recent.rss"}.should route_to(
+          expect({:get => "#{prefix}/*recent.rss"}).to route_to(
             :controller=>"card", :action=>"read", :id=>"*recent", :format=>"rss"
           )
         end
 
         it "should recognize .xml format" do
-          {:get => "#{prefix}/*recent.xml"}.should route_to(
+          expect({:get => "#{prefix}/*recent.xml"}).to route_to(
             :controller=>"card", :action=>"read", :id=>"*recent", :format=>"xml"
           )
         end
 
         it "should accept cards without dots" do
-          {:get => "#{prefix}/random"}.should route_to(
+          expect({:get => "#{prefix}/random"}).to route_to(
             :controller=>"card",:action=>"read",:id=>"random"
           )
         end
@@ -65,8 +65,8 @@ describe CardController do
       }
       assert_response 302
       c=Card["NewCardFoo"]
-      c.type_code.should == :basic
-      c.content.should == "Bananas"
+      expect(c.type_code).to eq(:basic)
+      expect(c.content).to eq("Bananas")
     end
 
     it "handles permission denials" do
@@ -75,16 +75,16 @@ describe CardController do
         :type => 'Html'
       }
       assert_response 403
-      Card['LackPerms'].should be_nil
+      expect(Card['LackPerms']).to be_nil
     end
 
     # no controller-specific handling.  move test elsewhere
     it "creates cardtype cards" do
       xhr :post, :create, :card=>{"content"=>"test", :type=>'Cardtype', :name=>"Editor"}
-      assigns['card'].should_not be_nil
+      expect(assigns['card']).not_to be_nil
       assert_response 200
       c=Card["Editor"]
-      c.type_code.should == :cardtype
+      expect(c.type_code).to eq(:cardtype)
     end
 
     # no controller-specific handling.  move test elsewhere
@@ -94,7 +94,7 @@ describe CardController do
       post :create, :card=>{"name"=>"Problem","type"=>"Phrase","content"=>"noof"}
       assert_response 302
       c=Card["Problem"]
-      c.type_code.should == :phrase
+      expect(c.type_code).to eq(:phrase)
     end
 
     
@@ -107,7 +107,7 @@ describe CardController do
             "subcards"=>{"+text"=>{"content"=>"<p>abraid</p>"}}
           }, "view"=>"open"
         assert_response 422
-        assigns['card'].errors[:name].first.should == "can't be blank"
+        expect(assigns['card'].errors[:name].first).to eq("can't be blank")
       end
 
       it "creates card with subcards" do
@@ -121,9 +121,9 @@ describe CardController do
           }
         }
         assert_response 200
-        Card["Gala"].should_not be_nil
-        Card["Gala+kind"].content.should == 'apple'
-        Card["Gala+color"].type_name.should == 'Phrase'
+        expect(Card["Gala"]).not_to be_nil
+        expect(Card["Gala+kind"].content).to eq('apple')
+        expect(Card["Gala+color"].type_name).to eq('Phrase')
       end
     end
 
@@ -137,7 +137,7 @@ describe CardController do
       xhr :post, :create, :success => 'REDIRECT: /thank_you', :card => { "name" => "Wombly" }
       assert_response 200
       json = JSON.parse response.body
-      json['redirect'].should =~ /^http.*\/thank_you$/
+      expect(json['redirect']).to match(/^http.*\/thank_you$/)
     end
 
     it "redirects to card if thanks is blank" do
@@ -157,11 +157,11 @@ describe CardController do
   describe "#read" do
     it "works for basic request" do
       get :read, {:id=>'Sample_Basic'}
-      response.body.match(/\<body[^>]*\>/im).should be_true
+      expect(response.body.match(/\<body[^>]*\>/im)).to be_truthy
       # have_selector broke in commit 8d3bf2380eb8197410e962304c5e640fced684b9, presumably because of a gem (like capybara?)
       #response.should have_selector('body')
       assert_response :success
-      'Sample Basic'.should == assigns['card'].name
+      expect('Sample Basic').to eq(assigns['card'].name)
     end
 
 
@@ -199,7 +199,7 @@ describe CardController do
 
       it "should work on index" do
         get :read, :view=>'new'
-        assigns['card'].name.should == ''
+        expect(assigns['card'].name).to eq('')
         assert_response :success, "response should succeed"
         assert_equal Card::BasicID, assigns['card'].type_id, "@card type should == Basic"
       end
@@ -229,7 +229,7 @@ describe CardController do
       
       it "should use card params name over id in new cards" do
         get :read, :id=>'my_life', :card=>{:name =>'My LIFE'}, :view=>'new'
-        assigns['card'].name.should == 'My LIFE'
+        expect(assigns['card'].name).to eq('My LIFE')
       end
       
     end
@@ -284,8 +284,9 @@ describe CardController do
       filename = "asset-test.txt"
       args = { :id=>filename, :format=>'txt', :explicit_file=>true }
       path = File.join( Wagn.paths['gem-assets'].existent.first, filename)
-      File.open(path, "w") { |f| f.puts "test" } 
-      visit "assets/#{filename}"
+      File.open(path, "w") { |f| f.puts "test" }
+      args = { :filename => "#{filename}" }
+      visit "/assets/#{filename}"
       expect(page.body).to eq ("test\n")
       FileUtils.rm path
     end
@@ -307,7 +308,7 @@ describe CardController do
     describe "#update" do
       it "works" do
         xhr :post, :update, { :id=>"~#{@simple_card.id}",
-          :card=>{:current_revision_id=>@simple_card.current_revision.id, :content=>'brand new content' }}
+          :card=>{:content=>'brand new content' }}
         assert_response :success, "edited card"
         assert_equal 'brand new content', Card['Sample Basic'].content, "content was updated"
       end
@@ -318,15 +319,15 @@ describe CardController do
           :name => "Newt",
           :update_referencers => "false",
         }
-        assigns['card'].errors.empty?.should_not be_nil
+        expect(assigns['card'].errors.empty?).not_to be_nil
         assert_response :success
-        Card["Newt"].should_not be_nil
+        expect(Card["Newt"]).not_to be_nil
       end
 
       it "update type_code" do
         xhr :post, :update, :id=>"~#{@simple_card.id}", :card=>{ :type=>"Date" }
         assert_response :success, "changed card type"
-        Card['Sample Basic'].type_code.should == :date
+        expect(Card['Sample Basic'].type_code).to eq(:date)
       end
     end
 
@@ -336,7 +337,7 @@ describe CardController do
       c = Card.create( :name=>"Boo", :content=>"booya")
       post :delete, :id=>"~#{c.id}"
       assert_response :redirect
-      Card["Boo"].should == nil
+      expect(Card["Boo"]).to eq(nil)
     end
 
     it "should comment" do
@@ -345,22 +346,9 @@ describe CardController do
       end
       post :update, :id=>'basicname', :card=>{:comment => " and more\n  \nsome lines\n\n"}
       cont = Card['basicname'].content
-      cont.should =~ /basiccontent/
-      cont.should =~ /some lines/
-    end
-
-    it "should watch" do
-      login_as('joe_user')
-      post :watch, :id=>"Home", :toggle=>'on'
-      assert c=Card["Home+*watchers"]
-      c.content.should == "[[Joe User]]"
-
-      post :watch, :id=>"Home", :toggle=>'off'
-      assert c=Card["Home+*watchers"]
-      c.content.should == ''
+      expect(cont).to match(/basiccontent/)
+      expect(cont).to match(/some lines/)
     end
 
-
-
   end
 end

data/spec/lib/card/action_spec.rb

@@ -0,0 +1,14 @@
+# -*- encoding : utf-8 -*-
+
+describe Card::Action do
+  describe '#delete_old_actions' do
+    it 'puts all changes on one action' do
+      a = Card['A']
+      a.update_attributes!(:name=>"New A")
+      a.update_attributes!(:content=>"New content")
+      a.delete_old_actions
+      expect(a.actions.count).to eq(1)
+      expect(a.actions.last.new_values[:name]).to eq("New A")
+    end
+  end
+end

data/spec/lib/card/chunk_spec.rb

@@ -4,12 +4,12 @@ require 'card/chunk'
 describe Card::Chunk, "Chunk" do
   context "Class" do
     it "should populate prefix map on load" do
-      Card::Chunk.prefix_map.keys.size.should > 0
-      Card::Chunk.prefix_map['{'][:class].should == Card::Chunk::Include
+      expect(Card::Chunk.prefix_map.keys.size).to be > 0
+      expect(Card::Chunk.prefix_map['{'][:class]).to eq(Card::Chunk::Include)
     end
     
     it "should find Chunk classes using matched prefix" do
-      Card::Chunk.find_class_by_prefix('{{').should == Card::Chunk::Include
+      expect(Card::Chunk.find_class_by_prefix('{{')).to eq(Card::Chunk::Include)
     end
     
   end

data/spec/lib/card/codename_spec.rb

@@ -7,18 +7,18 @@ describe Card::Codename, "Codename" do
   end
 
   it "should be sane" do    
-    Card[@codename].codename.should == @codename.to_s #would prefer Symbol eventually
+    expect(Card[@codename].codename).to eq(@codename.to_s) #would prefer Symbol eventually
     card_id = Card::Codename[@codename]
-    card_id.should be_a_kind_of Integer
-    Card::Codename[card_id].should == @codename
+    expect(card_id).to be_a_kind_of Integer
+    expect(Card::Codename[card_id]).to eq(@codename)
   end
 
   it "should make cards indestructable" do
     Card::Auth.as_bot do
       card = Card[@codename]
       card.delete
-      card.errors[:delete].first.should match 'is a system card'
-      Card[@codename].should be
+      expect(card.errors[:delete].first).to match 'is a system card'
+      expect(Card[@codename]).to be
     end
   end