RubyGems - JasonKing-inline_attachment - Versions diffs - 0.3.7 → 0.4.0 - Mend

JasonKing-inline_attachment 0.3.7 → 0.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

data/README CHANGED Viewed

@@ -3,77 +3,66 @@
 This package adds full support for embedding inline images into your HTML emails
 through ActionMailer.
-It is created from a Rails patch #2179 (found at http://dev.rubyonrails.org/ticket/2179).
-The goal of this gem is to remove the need for manual patching.
 == Installation
 To perform a system wide installation:
-<tt>gem install inline_attachment</tt>
+<tt>gem source -a http://gems.github.com</tt>
+<tt>gem install JasonKing-inline_attachment</tt>
 To use inline_attachment in your project, add the following line to your project's
 config/environment.rb:
-<tt>require 'inline_attachment'</tt>
+<tt>config.gem 'inline_attachment'</tt>
 == Usage
-==== Embed Images Manually
-The code to add inline attachments into your HTML emails is pretty simple:
-	@cid = Time.now.to_f.to_s + "foobar.png@domain.com"
-	inline_attachment :content_type => "image/png",
-	                  :body => File.read("#{RAILS_ROOT}/public/images/foobar.png"),
-	                  :filename => "foobar.png",
-	                  :cid => "<#{@cid}>"
-Note that the above code should go into your ActionMailer.
-The instance variable @cid is the unique identifier your MIME email will be using to
-locate the attached image. All you have to do is then pass it over to your email
-template, and display it like so:
-	<img src="cid:<%= @cid %>" alt="Foo Bar" />
-==== Embed Images Automatically
-As of version 0.2.0, Inline Attachment automatically embeds any images found within
-your ActionMailer templates. There is no longer any extra code required when adding images
-into your mail templates. Though, you must use rails image_tag helper when displaying
-images within your mailer views.
-With version 0.3.0, you are now able to embed images into nested parts by specifying
-a part container to place the attached images into. For example:
-	class Notifier < ActionMailer::Base
-	  def images
-	    recipients   "test@test.com"
-	    from         "test@test.com"
-	    subject      "Test"
-	    content_type "multipart/alternative"
-	    part "text/plain" do |p|
-	      p.body = render_message("images.text.plain.rhtml", {})
-	      p.content_disposition = ""
-	      p.transfer_encoding = "7bit"
-	      p.charset = "ISO-8859-15"
-	    end
-	    part "multipart/related" do |p|
-	      p.parts << ActionMailer::Part.new(
-	        :content_type => "text/html", :body => render_message("images.text.html.rhtml", :part_container => p),
-	        :disposition => "",
-	        :charset => "ISO-8859-15",
-	        :transfer_encoding => "7bit"
-	      )
-	    end
-	  end
+I've rewritten most of Edmond's great work in this version.  I now override
+path_to_image instead of image_tag because a big reason for all the Rails2
+breakages was because image_tag was basically reproduced in previous versions,
+so broke when that method changed.
+Now we override the very simple path_to_image, and most importantly we really
+just add our own stuff for ActionMailer templates, and resort to the existing
+code for everything else.
+I've also integrated in with the new implicit multipart stuff.  So now, there is
+so little code required!
+  class Notifier < ActionMailer::Base
+    def signup
+	    recipients %q{"Testing IA" <testing@handle.it>}
+		  from       %q{"Mr Tester" <tester@handle.it>}
+		  subject "Here's a funky test"
+    end
 	end
-You can see that we passed in the variable :part_container => p into the body of the nested part.
-This needs to be done so that the images are embedded into the part that they are used in.
+	# Oh yeah baby!  Read it and weep!  So how's this work?  Well, you'll need
+	# your templates named properly - see the `Multipart email` section of the
+	# ActionMailer::Base docs.
+	# signup.text.plain.erb
+	Your username is: <%= @username %>
+  # signup.text.html.erb
+	<html><head><title>Signup Notification</title></head><body>
+	  <%= image_tag "logo.png" %>
+		<p>Your username is: <%=h @username %>
+	</body></html>
+That's it!  InlineAttachment will look for
+"#{RAILS_ROOT}/public/images/logo.png" and will do the right thing and embed it
+inline into the HTML version of the email.  ActionMailer will do the right thing
+and offer the recipient both the text/plain and text/html parts as alternatives.
+Note, that you should still be able to use this in the 0.3.0 way if you have
+code that uses that.  But there were a lot of alternatives, and the examples in
+here didn't show a crucial step of shuffling the parts around to be sure that
+the image parts came after the html.
+You can also do the old "manual" method if you want.

data/lib/inline_attachment.rb CHANGED Viewed

@@ -1,4 +1,5 @@
 TMail::HeaderField::FNAME_TO_CLASS.delete('content-id')
+CID_NAME = 'Content-Id'
 module ActionMailer
   module PartContainer
@@ -8,59 +9,40 @@ module ActionMailer
       params = { :disposition => "inline",
                  :transfer_encoding => "base64" }.merge(params)
       params[:headers] ||= {}
-      params[:headers]['Content-ID'] = params[:cid]
+      params[:headers][CID_NAME] = params[:cid]
       part(params, &block)
     end
   end
-  class Part
-    def to_mail(defaults)
-      part = TMail::Mail.new
-      if @parts.empty?
-        part.content_transfer_encoding = transfer_encoding || "quoted-printable"
-        case (transfer_encoding || "").downcase
-          when "base64" then
-            part.body = TMail::Base64.folding_encode(body)
-          when "quoted-printable"
-            part.body = [Utils.normalize_new_lines(body)].pack("M*")
-          else
-            part.body = body
+  class Base
+    alias_method :ia_original_create_mail, :create_mail
+    def create_mail
+      # sniff out inline html parts with inline images and wrap them up in a
+      # multipart/related mime part
+      got_inlines = false
+      related_parts = []
+      for_deletion = []
+      @parts.each_with_index do |p,i|
+        logger.debug "Considering #{i}"
+        if p.content_disposition == 'inline' && p.content_type =~ %r{^image/}i && p.headers[CID_NAME]
+          logger.debug "Just adding [#{i}] to the list\n#{p.filename}"
+          for_deletion << i
+          related_parts << p
+          got_inlines = true
         end
-        # Always set the content_type after setting the body and or parts
-        # CHANGE: treat attachments and inline files the same
-        if content_disposition == "attachment" || ((content_disposition == "inline") && filename)
-            part.set_content_type(content_type || defaults.content_type, nil,
-            squish("charset" => nil, "name" => filename))
-        else
-          part.set_content_type(content_type || defaults.content_type, nil,
-            "charset" => (charset || defaults.charset))
-        end
-        part.set_content_disposition(content_disposition, squish("filename" => filename)) unless content_disposition.blank?
-        headers.each {|k,v| part[k] = v }
-        # END CHANGE
-      else
-        if String === body
-          part = TMail::Mail.new
-          part.body = body
-          part.set_content_type content_type, nil, { "charset" => charset }
-          part.set_content_disposition "inline"
-          m.parts << part
+        if got_inlines && p.content_type =~ %r{text/html}i
+          @parts[i] = ActionMailer::Part.new( :content_type => "multipart/related" )
+          @parts[i].parts << p
+          related_parts.each do |rp|
+            @parts[i].parts << rp
+          end
+          got_inlines = false
+          related_parts = []
         end
-        @parts.each do |p|
-          prt = (TMail::Mail === p ? p : p.to_mail(defaults))
-          part.parts << prt
-        end
-        part.set_content_type(content_type, nil, { "charset" => charset }) if content_type =~ /multipart/
       end
-      part
+      for_deletion.sort{|a,b|b<=>a}.each {|i|@parts.delete_at(i)}
+      ia_original_create_mail
     end
   end
 end
@@ -68,39 +50,29 @@ end
 module ActionView
   module Helpers #:nodoc:
     module AssetTagHelper
-      def image_tag(source, options = {})
-        options.symbolize_keys!
+      alias_method :ia_original_path_to_image, :path_to_image
+      def path_to_image(source)
         @part_container ||= @controller
         if @part_container.is_a?(ActionMailer::Base) or @part_container.is_a?(ActionMailer::Part)
-          file_path = "#{RAILS_ROOT}/public#{image_path(source).split('?').first}"
-          basename  = File.basename(file_path)
-          ext       = basename.split('.').last
-          cid       = Time.now.to_f.to_s + "#{basename}@inline_attachment"
-          file      = File.open(file_path, 'rb')
-          @part_container.inline_attachment(:content_type => "image/#{ext}",
-                                        :body         => file.read,
-                                        :filename     => basename,
-                                        :cid          => "<#{cid}>",
-                                        :disposition  => "inline")
-          options[:src] = "cid:#{cid}"
-          options[:alt] = basename.split('.').first.capitalize
-        else
-          options[:src] = image_path(source)
-          options[:alt] ||= File.basename(options[:src], '.*').split('.').first.capitalize
-        end
-        if options[:size]
-          options[:width], options[:height] = options[:size].split("x") if options[:size] =~ %r{^\d+x\d+$}
-          options.delete(:size)
-        end
+          file_path = "#{RAILS_ROOT}/public#{ia_original_path_to_image(source).split('?').first}"
+          if File.exists?(file_path)
+            basename  = File.basename(file_path)
+            ext       = basename.split('.').last
+            cid       = Time.now.to_f.to_s + "#{basename}@inline_attachment"
+            file      = File.open(file_path, 'rb')
-        tag("img", options)
+            @part_container.inline_attachment(:content_type => "image/#{ext}",
+                                          :body         => file.read,
+                                          :filename     => basename,
+                                          :cid          => "<#{cid}>",
+                                          :disposition  => "inline")
+            return "cid:#{cid}"
+          end
+        end
+        return ia_original_path_to_image(source)
       end
     end
   end
 end

metadata CHANGED Viewed

@@ -1,16 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: JasonKing-inline_attachment
 version: !ruby/object:Gem::Version
-  version: 0.3.7
+  version: 0.4.0
 platform: ruby
 authors:
 - Jason King
-- Edmond Leung
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2009-01-31 00:00:00 -08:00
+date: 2009-02-01 00:00:00 -08:00
 default_executable:
 dependencies:
 - !ruby/object:Gem::Dependency