capistrano-mailgun 1.0.2 → 1.1.0

data/CHANGELOG.md

@@ -0,0 +1,30 @@
+## 2012-10-?? - v1.1.0
+ * default subject now includes stage
+ * built-in templates
+ * support for custom messages
+
+## 2012-10-15 - v1.0.2
+ * Minor release
+ * documentation changes
+
+## 2012-10-15 - v1.0.1
+ * Minor release
+ * documentation changes
+
+## 2012-10-15 - v1.0.0
+ * Version 1.0.0!
+ * Proper definitions of dependencies
+ * Proper documentation
+ * Full support for Mailgun API options in `mailgun.send_email`
+ * Deduplication of email addresses in `mailgun.build_recipients`
+ * Support for custom domain in `mailgun.build_recipients`
+ * Support for HTML and text templates in emails using `mailgun.notify_of_deploy`
+ * Full rspec test suite
+
+## 2012-10-11 - v0.1.1
+
+ * Fixed a bug where it would blow up if you `require` the gem inside a non-Capistrano environment
+
+## 2012-10-11 - v0.1.0
+
+Initial Release

data/README.md

@@ -1,11 +1,12 @@
-# Capistrano-Mailgun  [![Build Status](https://travis-ci.org/spikegrobstein/capistrano-mailgun.png)](https://travis-ci.org/spikegrobstein/capistrano-mailgun)
+# Capistrano::Mailgun  [![Build Status](https://travis-ci.org/spikegrobstein/capistrano-mailgun.png)](https://travis-ci.org/spikegrobstein/capistrano-mailgun)
 
 *Bust a cap in your deployment notifications*
 
-Send emails with erb template bodies easily from inside your capistrano recipes.
+Mailgun.org is an excellent, API-driven email provider. So, bust out your nine, pop in the clip and send emails
+easily from inside your Capistrano recipes.
 
-Although built primarily for sending notification emails of deploys, it also includes nice helper methods
-for sending any kind of email via the Mailgun API.
+`Capistrano::Mailgun` provides a simple interface for notifying of deploys, exposing your Capistrano
+variables to your ERB template built on top of a more robust public interface to the Mailgun API.
 
 ## Installation
 
@@ -34,18 +35,14 @@ To send a notification after deploy, add the following to your `deploy.rb` file:
     set :mailgun_from, 'deployment@example.com' # who the email will appear to come from
     set :mailgun_recipients, [ 'you@example.com', 'otherguy@example.com' ] # who will receive the email
 
-    # The erb template will have visibility into all your capistrano variables.
-    # this template will be the text body of the notification email
-    set :mailgun_text_template, File.join(File.dirname(__FILE__), 'mail.erb')
-
     # create an after deploy hook
-    after(:deploy) { mailgun.notify_of_deploy }
-
-You should then create a `mail.erb` file in the same directory as `deploy.rb`:
+    after :deploy, 'mailgun_notify'
 
-    <%= application %> has just been deployed by <%= deployer_name %>, yay!
+That's it. When you do a deploy, it should automatically send an email using the built-in text and HTML
+templates.
 
-That's it. When you do a deploy, it should automatically send an email.
+`Capistrano::Mailgun` defines a `mailgun_notify` task which calls the `mailgun.notify_of_deploy` function,
+using your Capistrano configuration to send the notification.
 
 ## Example using mailgun.send_email
 
@@ -57,6 +54,8 @@ in your `deploy.rb` file:
     set :mailgun_api_key, 'key-12345678901234567890123456789012' # your mailgun API key
     set :mailgun_domain, 'example.com' # your mailgun email domain
 
+    set :mailgun_recipient_domain, 'example.com' # append this to any unqualified email addresses
+
     set(:email_body) { abort "Please set email_body using `-s email_body='this is the body of the email'" }
 
     # some variables that we'll use when calling mailgun.send_email
@@ -67,7 +66,7 @@ in your `deploy.rb` file:
     namespace :email do
       task :ops do
         mailgun.send_email(
-          :to => mailgun.build_recipients(ops_emails, 'example.com'), # use build_recipients to format TO field properly
+          :to => ops_emails, # build_recipients gets called automatically by Capistrano::Mailgun
           :from => 'some_dude@example.com',
           :subject => 'you have just been mailgunned',
           :text => email_body
@@ -78,7 +77,7 @@ in your `deploy.rb` file:
         mailgun.send_email(
           :to => 'no-reply@example.com',
           :from => 'no-reply@example.com',
-          :bcc => mailgun.build_recipients(dev_emails, 'example.com'),
+          :bcc => mailgun.build_recipients(dev_emails, 'audit.example.com'), # note the different domain
           :subject => 'You guys are just developers',
           :text => email_body
         )
@@ -98,7 +97,7 @@ Also, notice the use of `mailgun.build_recipients`. See documentation below for
 
 ## Capistrano Variables
 
-`capistrano-mailgun` leverages variables defined in Capistrano to reduce the amount of configuration
+`Capistrano::Mailgun` leverages variables defined in Capistrano to reduce the amount of configuration
 you need to do. The following are all variables it supports:
 
 ### mailgun_api_key (required)
@@ -115,55 +114,124 @@ The email address that your notifications will appear to come from (by default).
 
 ### mailgun_recipients (required for notify_of_deploy)
 
-An array of email addresses who should recieve a notification when a deployment completes.
+The email address as a string or an array of email addresses who should recieve an email from `notify_of_deploy`.
 
-You can optionally only specify just the part of the email address before the @ and `capistrano-mailgun` will
+You can optionally only specify just the part of the email address before the @ and `Capistrano::Mailgun` will
 automatically append the `mailgun_recipient_domain` to it. See `mailgun_recipient_domain`.
 
+If you omit the domain and don't specify `mailgun_recipient_domain`, a error will be raised.
+
+### mailgun_cc
+
+An array of email addresses who should be CC'd when `mailgun.notify_of_deploy` is called. This will
+follow the same rules as the `mailgun_recipients` variable with respect to the handling of unqualified
+email addresses.
+
+### mailgun_bcc
+
+An array of email addresses who should be BCC'd when `mailgun.notify_of_deploy` is called. This will
+follow the same rules as the `mailgun_recipients` variable with respect to the handling of unqualified
+eail addresses.
+
 ### mailgun_text_template (required for notify_of_deploy)
 
-This is the path to the ERB template that `Capistrano::Mailgun` will use to create the text body of
+This is the path to the ERB template that `mailgun.notify_of_deploy` will use to create the text body of
 your email. This is only required if you do not use the `mailgun_html_template` variable. You can
 specify both text and html templates and the emails will contain the proper bodies where the client
 supports it.
 
+The default setting for this is `:deploy_text` which is a built-in template. See "Built-in Templates"
+below for more information.
+
 ### mailgun_html_template (required for notify_of_deploy)
 
 This is the path to the ERB template that will be used to generate the HTML body of the email. It is only
 required if you do not specify the `mailgun_text_template` variable. You can specify both text and html
 templates and emails will contain the proper bodies where the client supports it.
 
+The default setting for this is `:deploy_html` which is a built-in template. See "Built-in Templates"
+below for more information.
+
 ### mailgun_recipient_domain
 
 The domain that will be automatically appended to incomplete email addresses in the `mailgun_recipients`.
 
+Example:
+
+    set :mailgun_recipient_domain, 'example.com'
+    set :mailgun_recipients, [ 'alice', 'bob', 'carl@contractors.net' ]
+
+When an email is sent from `Capistrano::Mailgun`, the recipients will be processed and the email will be sent to:
+
+ * alice@example.com
+ * bob@example.com
+ * carl@contractors.net
+
+If `mailgun_recipient_domain` is not set, `Capistrano::Mailgun` will raise an error.
+
 ### mailgun_subject
 
 The subject to be used in deployment emails. This defaults to:
 
-    [Deployment] #{ application.capitalize } complete
+    [Deployment] #{ application.capitalize } deploy completed
+
+In the event that you're using multistage, it will include that:
+
+    [Deployment] #{ stage.capitalize } #{ application.capitalize } deploy completed
+
+Setting this variable yourself will override the default.
+
+### mailgun_message
+
+An optional message can be specified to be included in the email. This is used inside the default templates,
+so if you use your own templates, you'll have to include support for this variable yourself.
 
-Setting this will override the default.
+The purpose of this variable is to be set when calling capistrano so you can have a custom, per-deploy message.
+You would call it in the following manner:
+
+    cap deploy -s mailgun_message="Fixes that really nasty bug where our site does not work"
+
+### github_url
+
+If your project is hosted on Github and you'd like to have links to the Github repository in the deployment
+notifications, set this. It should be in the following format:
+
+    https://github.com/USERNAME/PROJECT
+
+This is used for linking to commits from the log and linking to the Github page for the exact revision that
+was deployed.
+
+## Capistrano Tasks
+
+### mailgun_notify
+
+This task is defined strictly for convenience in defining Capistrano hooks and for sending a notification
+from the commandline. All it does is run `mailgun.notify_of_deploy` on your local machine.
+
+Normally, you'd want to have an after-hook on `deploy` defined as follows:
+
+    after :deploy, 'mailgun_notify'
 
 ## Function API
 
-`capistrano-mailgun` has a couple of methods to enable you to send emails easily. The following are the functions:
+`Capistrano::Mailgun` has a couple of functions to simplify some common tasks. The following are the functions:
 
 ### mailgun.build_recipients( recipients, default_domain=nil )
 
 Given an array of email addresses, this will join them with a comma so any recipients field with more than 1 recipient
-will be formatted properly, have the recipients list deduplicated and returned as a string. Typically, you will only use
-this function in the event that you're calling `mailgun.send_email` directly.
+will be formatted properly, have the recipients list deduplicated and returned as a string. Typically, you will not call
+this function directly as `Capistrano::Mailgun` calls it implicitely on your `to`, `cc` and `bcc` fields before hitting
+the Mailgun API.
 
 You can also pass an alternate `default_domain`. This is useful if you're not using the global `mailgun_recipient_domain`
-Capistrano variable of if you want to override the behavior in this one use-case. `mailgun.build_recipients` will always
-choose the specified `default_domain` over `mailgun_recipient_domain`.
+Capistrano variable of if you want to override the behavior in a specific case. `mailgun.build_recipients` will always
+choose the specified `default_domain` passed to the function over the Capistrano variable `mailgun_recipient_domain`.
 
 ### mailgun.notify_of_deploy
 
-This is a convenience function to send an email via the Mailgun api using your Capistrano variables for
-basic configuration. It will use either/or `mailgun_html_template` and `mailgun_text_template` to generate the
-email body, `mailgun_recipients` for who to address the email to, `mailgun_from` for the reply-to field
+This is a convenience function to send an email via the Mailgun api using your Capistrano variables for declarative
+configuration. It will use `mailgun_html_template` and `mailgun_text_template` to generate the email body when set,
+`mailgun_recipients` for who to address the email to, `mailgun_from` for the reply-to field
 of the email and `mailgun_subject` for the subject of the email.
 
 See Quickstart, above, for an example.
@@ -182,9 +250,13 @@ This function also takes the following additional options:
  * `:text_template` -- a path to an ERB template for the text body of the email.
  * `:html_template` -- a path to an ERB template for the HTML body of the email.
 
-The templates will have access to all of your Capistrano variables.
+The templates will have access to all of your Capistrano variables and anything else that Capistrano can see
+such as methods and Capistrano plugins (including `Capistrano::Mailgun`).
 
-Of course, you can also pass `:text` and `:html` options for the exact text/html bodies of the sent emails.
+Of course, you can also pass `:text` and `:html` options for the exact text/html bodies of the sent emails as they
+will be passed directly to the Mailgun API.
+
+No validation is done from this function, so errors from Mailgun will percolate up to you.
 
 ### deployer_username
 
@@ -192,10 +264,28 @@ This is a default capistrano variable that is defined in the gem. It will use th
 configured as `:git` or use `whoami` if not. This is handy if you want to notify people of which user
 actually did the deployment.
 
+## Built-in Templates
+
+`Capistrano::Mailgun` comes with built-in templates for use with `mailgun.notify_of_deploy`. There are both HTML and Text
+templates which include information such as the sha1 and ref that has been deployed as well as logs of the last
+commits. Use of the Capistrano variable `github_url` will enable links back to the repository and direct links
+to the commits in the log.
+
+These files live inside the gem in the `lib/templates` directory, so feel free to pull them out, copy into
+your project and customize.
+
+By default, `mailgun.notify_of_deploy` sets `mailgun_text_template` to `:default_text` and `mailgun_html_template`
+to `:default_html`, which signals it to use these built-in templates. Overriding those variables with absolute
+paths to your own templates will signal mailgun to use those. Setting either variable to `nil` will prevent
+`mailgun.notify_of_deploy` from using anything for either the text or HTML portion of the email.
+
 ## Limitations
 
  * Only supports ERB for templates. This should be changed in a future release.
  * Currently requires that ERB templates are on the filesystem. Future releases may allow for inline templates.
+ * Support for VCSs other than `:git` is lacking. `Capistrano::Mailgun` has been built with git and Github in mind.
+   If anyone has interest in adding support for other another version control system, that would be great.
+   Using this with a VCS other than Git may yeild unpredictable results.
 
 ## Contributing
 
@@ -204,3 +294,13 @@ actually did the deployment.
 3. Commit your changes (`git commit -am 'Added some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request
+
+## Acknowledgements
+
+`Capistrano::Mailgun` is written by Spike Grobstein and is used in production at [Ticket Evolution](http://www.ticketevolution.com)
+
+`Capistrano::Mailgun` leverages the awesome email sending API of [Mailgun.org](http://mailgun.org). You should definitely check it out.
+
+## License
+
+`Capistrano::Mailgun` is &copy;2012 Spike Grobstein and licensed under the MIT License. See `LICENSE` file.

data/lib/capistrano-mailgun.rb

@@ -14,7 +14,9 @@ module Capistrano
 
         Capistrano.plugin :mailgun, Capistrano::Mailgun
 
-        set(:mailgun_subject) { "[Deployment] #{ application.capitalize } completed" }
+        set(:mailgun_subject) do
+          [ "[Deployment]", fetch(:stage, '').to_s.capitalize, fetch(:application, '').capitalize, 'deploy completed'].join(' ').gsub(/\s+/, ' ')
+        end
 
         set(:mailgun_api_key)           { abort "Please set mailgun_api_key accordingly" }
         set(:mailgun_domain)            { abort "Please set mailgun_domain accordingly" }
@@ -22,22 +24,39 @@ module Capistrano
         set(:mailgun_recipients)        { abort "Please specify mailgun_recipients" }
         set(:mailgun_recipient_domain)  { abort "Please set mailgun_recipient_domain accordingly" }
 
+        # set these to nil to not use, or set to path to your custom template
+        set :mailgun_text_template, :deploy_text
+        set :mailgun_html_template, :deploy_html
+
         set(:deployer_username) do
-          if fetch(:scm, nil).to_sym == :git
+          if fetch(:scm, '').to_sym == :git
             `git config user.name`.chomp
           else
             `whoami`.chomp
           end
         end
 
+        # default mailgun email tasks
+        desc <<-DESC
+          Send a mailgun deployment notification.
+
+          This is here for convenience so you can force a notification to
+          be sent from the commandline and also to simplify configuring
+          after-deploy hooks and even after-mailgun-notify hooks.
+        DESC
+        task :mailgun_notify do
+          mailgun.notify_of_deploy
+        end
+
+
 
       end # config.load
     end
 
     # Simple wrapper for sending an email with a given template
     # Supports all options that the Mailgun API supports. In addition, it also accepts:
-    #  +:text_template+ -- the path to the template for the text body. It will be processed and interpolated and set the +text+ field when doing the API call.
-    #  +:html_template+ -- the path to the template for the html body. It will be processed and interpolated and set the +html+ field when doing the API call.
+    # * +:text_template+ -- the path to the template for the text body. It will be processed and interpolated and set the +text+ field when doing the API call.
+    # * +:html_template+ -- the path to the template for the html body. It will be processed and interpolated and set the +html+ field when doing the API call.
     def send_email(options)
       options = process_send_email_options(options)
 
@@ -46,38 +65,35 @@ module Capistrano
 
     # Sends the email via the Mailgun API using variables configured in Capistrano.
     # It depends on the following Capistrano vars in addition to the default:
-    #  +mailgun_recipients+
-    #  +mailgun_from+
-    #  +mailgun_subject+
+    # * +mailgun_recipients+
+    # * +mailgun_from+
+    # * +mailgun_subject+
     # Requires one or both of the following:
-    #  +mailgun_text_template+
-    #  +mailgun_html_template+
+    # * +mailgun_text_template+
+    # * +mailgun_html_template+
     #
     # See README for explanations of the above variables.
     def notify_of_deploy
       options = {
-        :to => build_recipients( fetch(:mailgun_recipients) ),
+        :to => fetch(:mailgun_recipients),
         :from => fetch(:mailgun_from),
         :subject => fetch(:mailgun_subject)
       }
 
+      options[:cc] = fetch(:mailgun_cc) if fetch(:mailgun_cc, nil)
+      options[:bcc] = fetch(:mailgun_bcc) if fetch(:mailgun_bcc, nil)
+
       if fetch(:mailgun_text_template, nil).nil? && fetch(:mailgun_html_template, nil).nil?
         abort "You must specify one (or both) of mailgun_text_template and mailgun_html_template to use notify_of_deploy"
       end
 
-      options[:text_template] = fetch(:mailgun_text_template) if fetch(:mailgun_text_template, nil)
-      options[:html_template] = fetch(:mailgun_html_template) if fetch(:mailgun_html_template, nil)
+      options[:text_template] = fetch(:mailgun_text_template, nil)
+      options[:html_template] = fetch(:mailgun_html_template, nil)
 
       send_email options
     end
 
-    # Placeholder method for hunting down templates. Currently does nothing.
-    def find_template(t)
-      return t
-      File.join( File.dirname(__FILE__), t )
-    end
-
-    # Given an array of +recipients+, it returns a comma-delimited, deduplicated string, suitable for populating the +to+ field of a Mailgun API call.
+    # Given an array of +recipients+, it returns a comma-delimited, deduplicated string, suitable for populating the +to+, +cc+, and +bcc+ fields of a Mailgun API call.
     # Optionally, it will take a +default_domain+ which will automatically be appended to any unqualified recipients (eg: 'spike' => 'spike@example.com')
     def build_recipients(recipients, default_domain=nil)
       [*recipients].map do |r|
@@ -86,19 +102,64 @@ module Capistrano
         else
           "#{ r }@#{ default_domain || fetch(:mailgun_recipient_domain) }"
         end
-      end.uniq
+      end.uniq.sort.join(',')
+    end
+
+    # git log between +first_ref+ to +last_ref+
+    def log_output(first_ref, last_ref)
+      return @log_output unless @log_output.nil?
+
+      log_output = run_locally("git log --oneline #{ first_ref }..#{ last_ref }")
+
+      @log_output = log_output = log_output.split("\n").map do |line|
+        fields = line.split("\s", 2)
+        [ fields[0], fields[1] ]
+      end
     end
 
     private
 
+    def default_deploy_text_template_path
+      default_template_path 'default.txt.erb'
+    end
+
+    def default_deploy_html_template_path
+      default_template_path 'default.html.erb'
+    end
+
+    def default_template_path(name)
+      File.join( File.dirname(__FILE__), 'templates', name)
+    end
+
+    def find_template(t)
+      case t
+      when :deploy_text then default_deploy_text_template_path
+      when :deploy_html then default_deploy_html_template_path
+      else
+        abort "Unknown template symbol: #{ t }" if t.is_a?(Symbol)
+        abort "Template not found: #{ t }" unless File.exists?(t)
+        t
+      end
+    end
+
     # apply templates and all that jazz
     def process_send_email_options(options)
       text_template = options.delete(:text_template)
       html_template = options.delete(:html_template)
 
+      options[:to] = build_recipients(options[:to]) unless options[:to].nil?
+      options[:cc] = build_recipients(options[:cc]) unless options[:cc].nil?
+      options[:bcc] = build_recipients(options[:bcc]) unless options[:bcc].nil?
+
       options[:text] = ERB.new( File.open( find_template(text_template) ).read ).result(self.binding) if text_template
       options[:html] = ERB.new( File.open( find_template(html_template) ).read ).result(self.binding) if html_template
 
+      # clean up the text template a little
+      if options[:text]
+        options[:text].gsub! /^ +/, ''
+        options[:text].gsub! /\n{3,}/, "\n\n"
+      end
+
       options
     end
 

data/lib/capistrano-mailgun/version.rb

@@ -1,5 +1,5 @@
 module Capistrano
   module Mailgun
-    VERSION = "1.0.2"
+    VERSION = "1.1.0"
   end
 end

data/lib/templates/default.html.erb

@@ -0,0 +1,149 @@
+<html>
+<head>
+  <style>
+    body {
+      font: 12px "Helvetica", "Lucida Grande", "Trebuchet MS", Verdana, sans-serif;
+    }
+    .section h2 {
+      color: #999;
+      margin: 0;
+    }
+
+    .section {
+      margin-bottom: 10px;
+      border-radius: 10px;
+      background-color: #eee;
+
+      padding: 5px 20px;
+    }
+
+    dt {
+      width: 15%;
+      margin-right: 10px;
+      display: inline-block;
+      white-space: nowrap;
+
+      clear: both;
+    }
+
+    dd {
+      width: 65%;
+      display: inline-block;
+    }
+
+    dl dt {
+      font-weight: bold;
+    }
+
+    .log ul {
+      font-family: monospace;
+
+      list-style: none;
+    }
+
+    .log ul li {
+      margin: 5px;
+    }
+
+    .log ul li a {
+      font-weight: bold;
+      padding: 2px 5px;
+      background-color: #eee;
+      color: #666;
+      text-decoration: none;
+    }
+
+    .log ul li a:hover {
+      text-decoration: underline;
+      color: black;
+    }
+
+  </style>
+</head>
+<body>
+
+  <h1>
+    <%= fetch(:stage, '').to_s.capitalize %> <%= application.capitalize %> deployment completed!
+  </h1>
+
+  <div class="section">
+    <h2>Deployment Overview</h2>
+
+    <dl>
+      <dt>Deployed by:</dt>
+      <dd><%= deployer_username %></dd>
+
+      <dt>Deployed at:</dt>
+      <dd><%= Time.now %></dd>
+    </dl>
+
+    <dl>
+      <dt>Application:</dt>
+      <dd><%= fetch(:application, 'N/A') %></dd>
+
+      <dt>Repository:</dt>
+      <dd><%= fetch(:repository, 'N/A') %></dd>
+
+      <% if fetch(:stage, nil) %>
+      <dt>Environment:</dt>
+      <dd><%= stage %></dd>
+      <% end %>
+    </div>
+
+    <div class="section">
+      <h2>Deployment Details</h2>
+
+      <dl>
+        <% if fetch(:branch, nil) %>
+        <dt>Ref:</dt>
+        <dd><%= branch %></dd>
+        <% end %>
+
+        <dt>Sha1:</dt>
+        <dd><%= fetch(:latest_revision, 'N/A') %></dd>
+
+        <dt>Release:</dt>
+        <dd><%= fetch(:release_name, 'N/A') %></dd>
+
+      </dl>
+
+      <% if fetch(:github_url, nil) %>
+      <dl>
+        <dt>WWW:</dt>
+        <dd><%= github_url %>/tree/<%= latest_revision %></dd>
+      </dl>
+      <% end %>
+    </div>
+
+    <% if fetch(:mailgun_message, nil) %>
+    <div id="mailgun_message" class="section">
+      <h2>Custom Message:</h2>
+      <p>
+        <%= fetch(:mailgun_message) %>
+      </p>
+    </div>
+    <% end %>
+
+<% log_output = mailgun.log_output(latest_revision, real_revision) %>
+<% unless log_output.count == 0 %>
+    <div class="log">
+      <h2>Log:</h2>
+
+      <ul>
+        <% mailgun.log_output(latest_revision, real_revision).each do |line| %>
+          <li>
+            <% if fetch(:github_url, nil) %>
+            <a href="<%= github_url %>/commit/<%= line[0] %>"><%= line[0] %></a>
+            <% else %>
+            <%= line[0] %>
+            <% end %>
+
+            <%= line[1] %>
+          </li>
+        <% end %>
+      </ul>
+    </div>
+<% end %>
+
+</body>
+</html>

data/lib/templates/default.txt.erb

@@ -0,0 +1,26 @@
+<%= fetch(:stage, '').to_s.capitalize %> <%= application.capitalize %> deployment completed!
+
+Deployed by: <%= deployer_username %>
+Deployed at: <%= Time.now %>
+
+Application: <%= fetch(:application, 'N/A') %>
+Repository:  <%= fetch(:repository, 'N/A') %>
+<% if fetch(:stage, nil) %>Environment: <%= stage %><% end %>
+
+<% if fetch(:branch, nil) %>Ref:         <%= branch %><% end %>
+Sha1:        <%= fetch(:latest_revision, 'N/A') %>
+Release:     <%= fetch(:release_name, 'N/A') %>
+<% if fetch(:mailgun_message, nil) %>
+  Custom Message:
+  <%= fetch(:mailgun_message) %>
+<% end %>
+
+<% if fetch(:url, nil) %>WWW:         <%= fetch(:url) %><% end %>
+<% log_output = mailgun.log_output(latest_revision, real_revision) %>
+<% unless log_output.count == 0 %>
+Log:
+---------------------------------------------------------------------------------
+<% log_output.each do |line| %>
+  <%= line.join(' ') %>
+<% end %>
+<% end %>

data/spec/capistrano-mailgun_spec.rb

@@ -8,9 +8,11 @@ describe Capistrano::Mailgun do
 
   before do
     Capistrano::Mailgun.load_into(config)
+
+    RestClient.stub(:post)
   end
 
-  let!(:mailgun) { config.mailgun }
+  let(:mailgun) { config.mailgun }
 
   context '#buid_recipients' do
     let(:email_1) { 'spike@example.com' }
@@ -21,15 +23,15 @@ describe Capistrano::Mailgun do
     end
 
     it "should accept a single recipient (not an array)" do
-      build_recipients(email_1).should == [email_1]
+      build_recipients(email_1).should == email_1
     end
 
     it "should accept an array of recipeints" do
-      build_recipients( [email_1, email_2] ).should == [email_1, email_2]
+      build_recipients( [email_1, email_2] ).should == [email_1, email_2].sort.join(',')
     end
 
     it "should deduplicate emails in the recipients" do
-      build_recipients( [email_1, email_2, email_1] ).should == [email_1, email_2]
+      build_recipients( [email_1, email_2, email_1] ).should == [email_1, email_2].sort.join(',')
     end
 
     context "when working with unqualified email addresses" do
@@ -40,11 +42,11 @@ describe Capistrano::Mailgun do
       end
 
       it "should add the mailgun_recipient_domain to any unqualified email addresses" do
-        build_recipients( %w( spike ) ).should == ['spike@another.com']
+        build_recipients( %w( spike ) ).should == 'spike@another.com'
       end
 
       it "should accept a mix of qualified and unqualified email addresses" do
-        build_recipients( [email_1, 'spike']).should == [email_1, 'spike@another.com']
+        build_recipients( [email_1, 'spike']).should == [email_1, 'spike@another.com'].sort.join(',')
       end
 
     end
@@ -57,7 +59,7 @@ describe Capistrano::Mailgun do
 
       it "should use the passed default_domain over the mailgun_recipient_domain if it's passed" do
         config.load { set :mailgun_recipient_domain, 'example.com' }
-        build_recipients( ['spike'], 'awesome.com' ).should == ['spike@awesome.com']
+        build_recipients( ['spike'], 'awesome.com' ).should == 'spike@awesome.com'
       end
     end
 
@@ -66,9 +68,46 @@ describe Capistrano::Mailgun do
 
   context "#find_template" do
 
-    # future behavior might be different
-    it "should return the path passed to it" do
-      mailgun.find_template('asdf').should == 'asdf'
+    def find_template(t)
+      mailgun.send(:find_template, t)
+    end
+
+    context "when dealing with a path" do
+
+      it "should return the path if the file exists" do
+        File.stub!(:exists? => true)
+
+        find_template('asdf').should == 'asdf'
+      end
+
+      it "should not raise an error if the file exists" do
+        File.stub!(:exists? => true)
+
+        lambda { find_template('adsf') }.should_not raise_error
+      end
+
+      it "should raise an error if the path doesn't exist" do
+        File.stub!(:exists? => false)
+
+        lambda { find_template('asdf') }.should raise_error
+      end
+
+    end
+
+    context "when dealing with a symbol" do
+
+      it "should return the default_deploy_text_template_path for :deploy_text" do
+        mailgun.should_receive(:default_deploy_text_template_path)
+
+        find_template(:deploy_text)
+      end
+
+      it "should return the default_deploy_html_template_path for :deploy_html" do
+        mailgun.should_receive(:default_deploy_html_template_path)
+
+        find_template(:deploy_html)
+      end
+
     end
 
   end
@@ -132,6 +171,65 @@ describe Capistrano::Mailgun do
       lambda { mailgun.notify_of_deploy }.should_not raise_error
     end
 
+    context "when using cc and bcc" do
+      let(:cc_email) { 'cc_email@example.com' }
+      let(:bcc_email) { 'bcc_email@example.com' }
+
+      context "when cc and bcc are included" do
+        before do
+
+          ERB.stub!(:new => mock(:result => 'completed template'))
+
+          config.load do
+            set :application, 'some application'
+
+            set :mailgun_api_key, 'asdfasdf'
+            set :mailgun_domain, 'example.com'
+
+            set :mailgun_cc, 'cc_email@example.com'
+            set :mailgun_bcc, 'bcc_email@example.com'
+
+            set :mailgun_recipient_domain, 'example.com'
+          end
+        end
+
+        after do
+          mailgun.notify_of_deploy
+        end
+
+        it "should recieve process_send_email_options with cc and bcc values" do
+          mailgun.should_receive(:process_send_email_options) do |options|
+            options[:cc].should_not be_nil
+            options[:bcc].should_not be_nil
+          end
+        end
+
+        it "should run build_recipients on cc and bcc" do
+          mailgun.should_receive(:build_recipients).with('people@example.com')
+          mailgun.should_receive(:build_recipients).with(cc_email)
+          mailgun.should_receive(:build_recipients).with(bcc_email)
+        end
+
+        it "should set the options in send_email to include cc if it's there" do
+          config.load do
+            set :mailgun_cc, nil
+          end
+
+          mailgun.should_not_receive(:build_recipients).with(cc_email)
+        end
+
+        it "should set the options in send_email to include bcc if it's there" do
+          config.load do
+            set :mailgun_cc, nil
+          end
+
+          mailgun.should_not_receive(:build_recipients).with(cc_email)
+        end
+
+      end
+
+    end
+
   end
 
   context "#process_send_email_options" do

data/spec/integration_spec.rb

@@ -0,0 +1,165 @@
+require 'spec_helper'
+
+describe "Integration testing for Capistrano::Mailgun" do
+
+  let(:config) do
+    Capistrano::Configuration.new
+  end
+
+  before do
+    Capistrano::Mailgun.load_into(config)
+
+    RestClient.stub(:post)
+  end
+
+  let(:mailgun) { config.mailgun }
+
+  context "when overriding defaults" do
+
+    before do
+      config.stub!(:run_locally => 'local output')
+
+      config.load do
+        set :application, 'testing'
+        set :scm, :git
+
+        # deploy stuff stubbing
+        set :latest_revision, 'asdfasdf'
+        set :real_revision, 'asdfasdf'
+
+        # base Capistrano::Mailgun config
+        set :mailgun_api_key, 'api-dummy-key'
+        set :mailgun_domain, 'example.com'
+      end
+    end
+
+    context "when using mailgun.notify_of_deploy" do
+      before do
+        config.load do
+          set :mailgun_from, 'noreply@example.com'
+          set :mailgun_recipients, 'everyone@example.com'
+        end
+      end
+
+      after do
+        mailgun.notify_of_deploy
+      end
+
+
+      it "should allow user to unset text template" do
+        config.load do
+          set :mailgun_text_template, nil
+        end
+
+        RestClient.should_receive(:post) do |url, opts|
+          opts.has_key?(:text).should be_false
+          opts.has_key?(:html).should be_true
+        end
+      end
+
+      it "should allow user to unset html template" do
+        config.load do
+          set :mailgun_html_template, nil
+        end
+
+        RestClient.should_receive(:post) do |url, opts|
+          opts.has_key?(:text).should be_true
+          opts.has_key?(:html).should be_false
+        end
+      end
+
+      context "email subject" do
+
+        it "should include the stage if that's defined" do
+          config.load do
+            set :stage, 'production'
+          end
+
+          RestClient.should_receive(:post) do |url, opts|
+            opts[:subject].should match(/\bproduction\b/i)
+          end
+        end
+
+        it "should allow overriding of subject" do
+          config.load do
+            set :mailgun_subject, 'Test subject'
+          end
+
+          RestClient.should_receive(:post) do |url, opts|
+            opts[:subject].should == 'Test subject'
+          end
+        end
+      end
+
+      it "should use mailgun_from for :from field" do
+        RestClient.should_receive(:post) do |url, opts|
+          opts[:from].should == 'noreply@example.com'
+        end
+      end
+
+      it "should use mailgun_recipients for :to field" do
+        RestClient.should_receive(:post) do |url, opts|
+          opts[:to].should == 'everyone@example.com'
+        end
+      end
+
+      context "when using mailgun_cc" do
+        it "should use CC field if it's set" do
+          config.load do
+            set :mailgun_cc, 'cc@example.com'
+          end
+
+          RestClient.should_receive(:post) do |url, opts|
+            opts[:cc].should == 'cc@example.com'
+          end
+        end
+
+        it "should not use CC field if it's not set" do
+          RestClient.should_receive(:post) do |url, opts|
+            opts.has_key?(:cc).should be_false
+          end
+        end
+      end
+
+      context "when using mailgun_bcc" do
+        it "should use bcc field if it's set" do
+          config.load do
+            set :mailgun_bcc, 'bcc@example.com'
+          end
+
+          RestClient.should_receive(:post) do |url, opts|
+            opts[:bcc].should == 'bcc@example.com'
+          end
+        end
+
+        it "should not use bcc field if it's not set" do
+          RestClient.should_receive(:post) do |url, opts|
+            opts.has_key?(:bcc).should be_false
+          end
+        end
+      end
+
+      context "when using mailgun_message" do
+        it "should include a mailgun_message if set" do
+          config.load do
+            set :mailgun_message, '_custom_message_'
+          end
+
+          RestClient.should_receive(:post) do |url, opts|
+            opts[:text].should include('_custom_message_')
+            opts[:html].should include('_custom_message_')
+          end
+        end
+
+        it "should not have the custom_message div if no custom_message is set" do
+          RestClient.should_receive(:post) do |url, opts|
+            opts[:html].should_not include('id="mailgun_message"')
+          end
+        end
+      end
+
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -8,10 +8,6 @@ $: << File.dirname(__FILE__) + '/../lib'
 require 'capistrano'
 require 'capistrano-mailgun'
 
-Rspec.configure do |config|
-  # config
-end
-
 def fixture_path(filename)
   File.join( File.dirname(__FILE__), 'fixtures', filename )
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: capistrano-mailgun
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-15 00:00:00.000000000 Z
+date: 2012-10-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: capistrano
@@ -54,6 +54,7 @@ files:
 - .gitignore
 - .rspec
 - .travis.yml
+- CHANGELOG.md
 - Gemfile
 - LICENSE
 - README.md
@@ -61,9 +62,12 @@ files:
 - capistrano-mailgun.gemspec
 - lib/capistrano-mailgun.rb
 - lib/capistrano-mailgun/version.rb
+- lib/templates/default.html.erb
+- lib/templates/default.txt.erb
 - spec/capistrano-mailgun_spec.rb
 - spec/fixtures/html_body.erb
 - spec/fixtures/text_body.erb
+- spec/integration_spec.rb
 - spec/spec_helper.rb
 homepage: ''
 licenses: []
@@ -79,7 +83,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2168870135844714304
+      hash: 4576376367349129326
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -88,7 +92,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2168870135844714304
+      hash: 4576376367349129326
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24
@@ -99,4 +103,5 @@ test_files:
 - spec/capistrano-mailgun_spec.rb
 - spec/fixtures/html_body.erb
 - spec/fixtures/text_body.erb
+- spec/integration_spec.rb
 - spec/spec_helper.rb