pony 1.6.2 → 1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cd8ec51f958a8381a430a207d3c841c74062d7ca
-  data.tar.gz: 10fd40c67cedaa1e49501abb77c449aa33113681
+  metadata.gz: ce1e07719a6d6f72a10ac2ae08217d85fb3aa5f4
+  data.tar.gz: 9d8e1332919f03c78ab439e2b22b894b3afcc3a3
 SHA512:
-  metadata.gz: 6ff87c2cd04aa72fd42341d485d187eb64828f7cb1657bb239b5f27281709e11a281ee348f4e1af5bca6d8db44a157cb3006528e1d6cb5cbf679df49c6ae6b99
-  data.tar.gz: 55bf1444151fa19569c0c273043f65bb849fa4b029ae607332330c57fff99442a33b7f83430af6905e13538176b7854a5b24b9aef70920d672e2e4fa81fca00b
+  metadata.gz: 1343e76f77aa91409afbd022495de50580b376fee2e0954bc98b197f787043e58642ed3b216c1b08d9efd3d1e3af2d32ffe85513bc30a95da18b1780e84a7810
+  data.tar.gz: f867a5b22fbbfc411ae524e5020ae09d749f92b14aaeadec1365199891e6bcbcc6b8319814dd5b58dc103e70cef1202efa050831b4cd49cc477c1905e8bae476

data/README.rdoc

@@ -152,6 +152,9 @@ mailing list: ponyrb@googlegroups.com
 
 
 == Releases
+1.7
+* Better default content_type with attachments
+
 1.6
 * Unknown options are passed directly to mail to handle.  Remove deprecated syntax
 

data/lib/pony.rb

@@ -201,10 +201,29 @@ module Pony
     if mail.multipart? && options[:text_part_charset]
       mail.text_part.charset = options[:text_part_charset]
     end
-
+    set_content_type(mail, options[:content_type])
     mail
   end
 
+  def self.set_content_type(mail, user_content_type)
+    params = mail.content_type_parameters || {}
+    content_type =  case
+    when user_content_type
+       user_content_type
+    when mail.has_attachments?
+      if mail.attachments.detect { |a| a.inline? }
+        ["multipart", "related", params]
+      else
+        ["multipart", "mixed", params]
+      end
+    when mail.multipart?
+      ["multipart", "alternative", params]
+    else
+      false
+    end
+    mail.content_type = content_type if content_type
+  end
+
   def self.add_attachments(mail, attachments)
     attachments.each do |name, body|
       # mime-types wants to send these as "quoted-printable"

data/pony.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = 'pony'
-  s.version = "1.6.2"
+  s.version = "1.7"
 
   s.summary = "Send email in one command: Pony.mail(:to => 'someone@example.com', :body => 'hello')"
   s.description = s.summary
@@ -15,5 +15,5 @@ Gem::Specification.new do |s|
   s.rdoc_options = ["--inline-source", "--charset=UTF-8"]
   s.require_paths = ["lib"]
   s.add_runtime_dependency 'mail', '>= 2.0'
-  s.add_development_dependency "rspec", ">= 2.0.0"
+  s.add_development_dependency "rspec", ">= 2.14"
 end

data/spec/pony_spec.rb

@@ -4,169 +4,169 @@ require File.dirname(__FILE__) + '/base'
 describe Pony do
 
   before(:each) do
-    Pony.stub!(:deliver)
+    Pony.stub(:deliver)
   end
 
   it "sends mail" do
-    Pony.should_receive(:deliver) do |mail|
-      mail.to.should == [ 'joe@example.com' ]
-      mail.from.should == [ 'sender@example.com' ]
-      mail.subject.should == 'hi'
-      mail.body.should == 'Hello, Joe.'
+    expect(Pony).to receive(:deliver) do |mail|
+      expect(mail.to).to eq [ 'joe@example.com' ]
+      expect(mail.from).to eq [ 'sender@example.com' ]
+      expect(mail.subject).to eq 'hi'
+      expect(mail.body).to eq 'Hello, Joe.'
     end
     Pony.mail(:to => 'joe@example.com', :from => 'sender@example.com', :subject => 'hi', :body => 'Hello, Joe.')
   end
 
   it "requires :to param" do
-    lambda { Pony.mail({}) }.should raise_error(ArgumentError)
+    expect{ Pony.mail({}) }.to raise_error(ArgumentError)
   end
 
   it "doesn't require any other param" do
-    lambda { Pony.mail(:to => 'joe@example.com') }.should_not raise_error
+    expect{ Pony.mail(:to => 'joe@example.com') }.to_not raise_error
   end
 
   describe "builds a Mail object with field:" do
     it "to" do
-      Pony.build_mail(:to => 'joe@example.com').to.should == [ 'joe@example.com' ]
+      expect(Pony.build_mail(:to => 'joe@example.com').to).to eq [ 'joe@example.com' ]
     end
 
     it "to with multiple recipients" do
-      Pony.build_mail(:to => 'joe@example.com, friedrich@example.com').to.should == [ 'joe@example.com', 'friedrich@example.com' ]
+      expect(Pony.build_mail(:to => 'joe@example.com, friedrich@example.com').to).to eq [ 'joe@example.com', 'friedrich@example.com' ]
     end
 
     it "to with multiple recipients and names" do
-      Pony.build_mail(:to => 'joe@example.com, "Friedrich Hayek" <friedrich@example.com>').to.should == [ 'joe@example.com', 'friedrich@example.com' ]
+      expect(Pony.build_mail(:to => 'joe@example.com, "Friedrich Hayek" <friedrich@example.com>').to).to eq [ 'joe@example.com', 'friedrich@example.com' ]
     end
 
     it "to with multiple recipients and names in an array" do
-      Pony.build_mail(:to => ['joe@example.com', '"Friedrich Hayek" <friedrich@example.com>']).to.should == [ 'joe@example.com', 'friedrich@example.com' ]
+      expect(Pony.build_mail(:to => ['joe@example.com', '"Friedrich Hayek" <friedrich@example.com>']).to).to eq [ 'joe@example.com', 'friedrich@example.com' ]
     end
 
     it "cc" do
-      Pony.build_mail(:cc => 'joe@example.com').cc.should == [ 'joe@example.com' ]
+      expect(Pony.build_mail(:cc => 'joe@example.com').cc).to eq [ 'joe@example.com' ]
     end
 
     it "reply_to" do
-      Pony.build_mail(:reply_to => 'joe@example.com').reply_to.should == [ 'joe@example.com' ]
+      expect(Pony.build_mail(:reply_to => 'joe@example.com').reply_to).to eq [ 'joe@example.com' ]
     end
 
     it "cc with multiple recipients" do
-      Pony.build_mail(:cc => 'joe@example.com, friedrich@example.com').cc.should == [ 'joe@example.com', 'friedrich@example.com' ]
+      expect(Pony.build_mail(:cc => 'joe@example.com, friedrich@example.com').cc).to eq [ 'joe@example.com', 'friedrich@example.com' ]
     end
 
     it "from" do
-      Pony.build_mail(:from => 'joe@example.com').from.should == [ 'joe@example.com' ]
+      expect(Pony.build_mail(:from => 'joe@example.com').from).to eq [ 'joe@example.com' ]
     end
 
     it "bcc" do
-      Pony.build_mail(:bcc => 'joe@example.com').bcc.should == [ 'joe@example.com' ]
+      expect(Pony.build_mail(:bcc => 'joe@example.com').bcc).to eq [ 'joe@example.com' ]
     end
 
     it "bcc with multiple recipients" do
-      Pony.build_mail(:bcc => 'joe@example.com, friedrich@example.com').bcc.should == [ 'joe@example.com', 'friedrich@example.com' ]
+      expect(Pony.build_mail(:bcc => 'joe@example.com, friedrich@example.com').bcc).to eq [ 'joe@example.com', 'friedrich@example.com' ]
     end
 
     it "charset" do
       mail = Pony.build_mail(:charset => 'UTF-8')
-      mail.charset.should == 'UTF-8'
+      expect(mail.charset).to eq 'UTF-8'
     end
 
     it "text_part_charset" do
       mail = Pony.build_mail(:attachments => {"foo.txt" => "content of foo.txt"}, :body => 'test', :text_part_charset => 'ISO-2022-JP')
-      mail.text_part.charset.should == 'ISO-2022-JP'
+      expect(mail.text_part.charset).to eq 'ISO-2022-JP'
     end
 
     it "default charset" do
-      Pony.build_mail(body: 'body').charset.should eq 'UTF-8'
-      Pony.build_mail(html_body: 'body').charset.should eq 'UTF-8'
+      expect(Pony.build_mail(body: 'body').charset).to eq 'UTF-8'
+      expect(Pony.build_mail(html_body: 'body').charset).to eq 'UTF-8'
     end
 
     it "from (default)" do
-      Pony.build_mail({}).from.should == [ 'pony@unknown' ]
+      expect(Pony.build_mail({}).from).to eq [ 'pony@unknown' ]
     end
 
     it "subject" do
-      Pony.build_mail(:subject => 'hello').subject.should == 'hello'
+      expect(Pony.build_mail(:subject => 'hello').subject).to eq 'hello'
     end
 
     it "body" do
-      Pony.build_mail(body: 'What do you know, Joe?').body.should
-        eq 'What do you know, Joe?'
+      expect(Pony.build_mail(body: 'What do you know, Joe?').body)
+        .to eq 'What do you know, Joe?'
     end
 
     it "html_body" do
-      Pony.build_mail(html_body: 'What do you know, Joe?').parts.first.body.should
-        eq 'What do you know, Joe?'
-      Pony.build_mail(html_body: 'What do you know, Joe?').parts.first.content_type.should
-        eq 'text/html; charset=UTF-8'
+      expect(Pony.build_mail(html_body: 'What do you know, Joe?').parts.first.body)
+        .to eq 'What do you know, Joe?'
+      expect(Pony.build_mail(html_body: 'What do you know, Joe?').parts.first.content_type)
+        .to eq 'text/html; charset=UTF-8'
     end
 
     it 'content_type' do
-      Pony.build_mail(content_type: 'multipart/related').content_type.should
-        eq 'multipart/related'
+      expect(Pony.build_mail(content_type: 'multipart/related').content_type)
+        .to eq 'multipart/related'
     end
 
     it "date" do
       now = Time.now
-      Pony.build_mail(:date => now).date.should == DateTime.parse(now.to_s)
+      expect(Pony.build_mail(:date => now).date).to eq DateTime.parse(now.to_s)
     end
 
     it "message_id" do
-      Pony.build_mail(:message_id => '<abc@def.com>').message_id.should == 'abc@def.com'
+      expect(Pony.build_mail(:message_id => '<abc@def.com>').message_id).to eq 'abc@def.com'
     end
 
     it "custom headers" do
-      Pony.build_mail(:headers => {"List-ID" => "<abc@def.com>"})['List-ID'].to_s.should == '<abc@def.com>'
+      expect(Pony.build_mail(:headers => {"List-ID" => "<abc@def.com>"})['List-ID'].to_s).to eq '<abc@def.com>'
     end
 
     it "sender" do
-      Pony.build_mail(:sender => "abc@def.com")['Sender'].to_s.should == 'abc@def.com'
+      expect(Pony.build_mail(:sender => "abc@def.com")['Sender'].to_s).to eq 'abc@def.com'
     end
 
     it "utf-8 encoded subject line" do
       mail = Pony.build_mail(:to => 'btp@foo', :subject => 'Café', :body => 'body body body')
-      mail['subject'].encoded.should =~ /^Subject: =\?UTF-8/;
+      expect(mail['subject'].encoded).to match( /^Subject: =\?UTF-8/ )
     end
 
     it "attachments" do
       mail = Pony.build_mail(:attachments => {"foo.txt" => "content of foo.txt"}, :body => 'test')
-      mail.parts.length.should == 2
-      mail.parts.first.to_s.should =~ /Content-Type: text\/plain/
-      mail.attachments.first.content_id.should == "<foo.txt@#{Socket.gethostname}>"
+      expect(mail.parts.length).to eq 2
+      expect(mail.parts.first.to_s).to match( /Content-Type: text\/plain/ )
+      expect(mail.attachments.first.content_id).to eq "<foo.txt@#{Socket.gethostname}>"
     end
 
     it "suggests mime-type" do
       mail = Pony.build_mail(:attachments => {"foo.pdf" => "content of foo.pdf"})
-      mail.parts.length.should == 1
-      mail.parts.first.to_s.should =~ /Content-Type: application\/pdf/
-      mail.parts.first.to_s.should =~ /filename=foo.pdf/
-      mail.parts.first.content_transfer_encoding.to_s.should == 'base64'
+      expect(mail.parts.length).to eq 1
+      expect(mail.parts.first.to_s).to match( /Content-Type: application\/pdf/ )
+      expect(mail.parts.first.to_s).to match( /filename=foo.pdf/ )
+      expect(mail.parts.first.content_transfer_encoding.to_s).to eq 'base64'
     end
 
     it "encodes xlsx files as base64" do
       mail = Pony.build_mail(:attachments => {"foo.xlsx" => "content of foo.xlsx"})
-      mail.parts.length.should == 1
-      mail.parts.first.to_s.should =~ /Content-Type: application\/vnd.openxmlformats-officedocument.spreadsheetml.sheet/
-      mail.parts.first.to_s.should =~ /filename=foo.xlsx/
-      mail.parts.first.content_transfer_encoding.to_s.should == 'base64'
+      expect(mail.parts.length).to eq 1
+      expect(mail.parts.first.to_s).to match( /Content-Type: application\/vnd.openxmlformats-officedocument.spreadsheetml.sheet/ )
+      expect(mail.parts.first.to_s).to match( /filename=foo.xlsx/ )
+      expect(mail.parts.first.content_transfer_encoding.to_s).to eq 'base64'
     end
 
     it "passes cc and bcc as the list of recipients" do
       mail = Pony.build_mail(:to => ['to'], :cc => ['cc'], :from => ['from'], :bcc => ['bcc'])
-      mail.destinations.should ==  ['to', 'cc', 'bcc']
+      expect(mail.destinations).to eq  ['to', 'cc', 'bcc']
     end
   end
 
   describe "transport" do
     it "transports via smtp if no sendmail binary" do
-      Pony.stub!(:sendmail_binary).and_return('/does/not/exist')
-      Pony.should_receive(:build_mail).with(hash_including(:via => :smtp))
+      Pony.stub(:sendmail_binary).and_return('/does/not/exist')
+      expect(Pony).to receive(:build_mail).with(hash_including(:via => :smtp))
       Pony.mail(:to => 'foo@bar')
     end
 
     it "defaults to sendmail if no via is specified and sendmail exists" do
-      File.stub!(:executable?).and_return(true)
-      Pony.should_receive(:build_mail).with(hash_including(:via => :sendmail))
+      File.stub(:executable?).and_return(true)
+      expect(Pony).to receive(:build_mail).with(hash_including(:via => :sendmail))
       Pony.mail(:to => 'foo@bar')
     end
 
@@ -174,12 +174,12 @@ describe Pony do
 
       it "defaults to localhost as the SMTP server" do
         mail = Pony.build_mail(:to => "foo@bar", :enable_starttls_auto => true, :via => :smtp)
-        mail.delivery_method.settings[:address].should == 'localhost'
+        expect(mail.delivery_method.settings[:address]).to eq 'localhost'
       end
 
       it "enable starttls when tls option is true" do
         mail = Pony.build_mail(:to => "foo@bar", :enable_starttls_auto => true, :via => :smtp)
-        mail.delivery_method.settings[:enable_starttls_auto].should == true
+        expect(mail.delivery_method.settings[:enable_starttls_auto]).to eq true
       end
     end
   end
@@ -187,32 +187,32 @@ describe Pony do
   describe ":via option should over-ride the default transport mechanism" do
     it "should send via sendmail if :via => sendmail" do
       mail = Pony.build_mail(:to => 'joe@example.com', :via => :sendmail)
-      mail.delivery_method.kind_of?(Mail::Sendmail).should == true
+      expect(mail.delivery_method.kind_of?(Mail::Sendmail)).to eq true
     end
 
     it "should send via smtp if :via => smtp" do
       mail = Pony.build_mail(:to => 'joe@example.com', :via => :smtp)
-      mail.delivery_method.kind_of?(Mail::SMTP).should == true
+      expect(mail.delivery_method.kind_of?(Mail::SMTP)).to eq true
     end
 
   end
 
   describe "sendmail binary location" do
     it "should default to /usr/sbin/sendmail if not in path" do
-      Pony.stub!(:'`').and_return('')
-      Pony.sendmail_binary.should == '/usr/sbin/sendmail'
+      Pony.stub(:'`').and_return('')
+      expect(Pony.sendmail_binary).to eq '/usr/sbin/sendmail'
     end
   end
 
   describe "default options" do
     it "should use default options" do
-      Pony.should_receive(:build_mail).with(hash_including(:from => 'noreply@pony'))
+      expect(Pony).to receive(:build_mail).with(hash_including(:from => 'noreply@pony'))
       Pony.options = { :from => 'noreply@pony' }
       Pony.mail(:to => 'foo@bar')
     end
 
     it "should merge default options with options" do
-      Pony.should_receive(:build_mail).with(hash_including(:from => 'override@pony'))
+      expect(Pony).to receive(:build_mail).with(hash_including(:from => 'override@pony'))
       Pony.options = { :from => 'noreply@pony' }
       Pony.mail(:from => 'override@pony', :to => "foo@bar")
     end
@@ -221,7 +221,25 @@ describe Pony do
       input = { :from => 'noreply@pony' }
       Pony.options = input
       output = Pony.options
-      output.should == input
+      expect(output).to eq input
+    end
+  end
+
+  describe "content type" do
+    context "mail with attachments, html_body and body " do
+      subject(:mail) do
+        Pony.build_mail(
+          :body => 'test',
+          :html_body => 'What do you know, Joe?',
+          :attachments => {"foo.txt" => "content of foo.txt"},
+        )
+      end
+
+      it { expect(mail.parts.length).to eq 3 }
+      it { expect(mail.content_type.to_s).to include( 'multipart/mixed' ) }
+      it { expect(mail.parts[0].to_s).to include( 'Content-Type: text/html' ) }
+      it { expect(mail.parts[1].to_s).to include( 'Content-Type: text/plain' ) }
+      it { expect(mail.parts[2].to_s).to include( 'Content-Type: text/plain' ) }
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pony
 version: !ruby/object:Gem::Version
-  version: 1.6.2
+  version: '1.7'
 platform: ruby
 authors:
 - Adam Wiggins
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-05 00:00:00.000000000 Z
+date: 2014-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mail
@@ -31,14 +31,14 @@ dependencies:
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: '2.14'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: '2.14'
 description: 'Send email in one command: Pony.mail(:to => ''someone@example.com'',
   :body => ''hello'')'
 email: ben@throwingbones.com