capistrano-committed 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 826501e1548e90eaebadb55f869d10323df83b2f
+  data.tar.gz: c3cae25051c1dfbb5ac0c5bea849d6824cd8a48a
+SHA512:
+  metadata.gz: 924a0422e7448dea1d2a970a116a81d7daba68994c2000c3655af2f3ff471d1e7575d838c921d3237012ae67199fb0080d5410d3ac00dd4b77d98843c4701a8a
+  data.tar.gz: 354ece8591d11a4e8238c0d71dafbca8ef5f76d1c16d56db3e8dd2acf7e378c5c2543c6a00160bb1ed5f9fc950b5706d19265e8e7bcc2eeed0c5df97e7a61faf

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.3
+before_install: gem install bundler -v 1.10.6

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in capistrano-release-log.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Sam Bauers
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,108 @@
+# Capistrano Committed
+
+Capistrano Committed is an extension to Capistrano 3 which helps to determine what you are about to deploy.
+
+It creates a report, which lets you know which GitHub commits and pull requests are not yet deployed to the target stage (server).
+
+It does this by:
+
+1. reading the revision log on the server;
+2. getting all the commits on the specified branch from GitHub (via API);
+3. looking through those commits and finding all the pull requests;
+4. getting the info and commits in each pull request;
+5. pumping all that data into a report;
+6. uploading that report to the server.
+
+At the moment this only works with GitHub repositories, if you have another Git service you would like it to support then please submit a pull request.
+
+## Installation
+
+Add this line to your application's Gemfile (usually in the `:development` group):
+
+```ruby
+gem 'capistrano-committed'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install capistrano-committed
+
+In your projects Capfile add this line:
+
+```ruby
+require 'capistrano/committed'
+```
+
+## Usage
+
+In `config/deploy.rb` (in Rails) you need to set at least these options:
+
+```ruby
+# This is the GitHub user or organisation for the repository
+set :committed_user, nil
+set :committed_repo, nil
+```
+
+You will usually need to set the `:committed_github_config` option in order to authenticate, this setting is a hash of options which are passed directly to the [GitHub API gem](https://github.com/peter-murach/github). The full list of GitHub API configuration option are in the [GitHub API gem read me file](https://github.com/peter-murach/github#2-configuration).
+
+Example of personal access token usage:
+
+```ruby
+set :committed_github_config, {
+  :oauth_token => '65741acbd6473216583421cdef'
+}
+```
+
+Example of basic auth usage:
+
+```ruby
+set :committed_github_config, {
+  :basic_auth => 'my-username:my-p455w0rd'
+}
+```
+
+The following settings are optional, the default values are shown here:
+
+```ruby
+# This describes the line that we are looking for and matching against to get
+# revision details from the revision log. Grabbing this from Capistrano locales
+# by default.
+set :committed_revision_line, I18n.t('capistrano.revision_log_message')
+
+# The config passed to the GitHub API gem - will usually contain auth details.
+set :committed_github_config, {}
+
+# How far back in the revision log we should look
+set :committed_revision_limit, 10
+
+# How many days beyond the last revision we fetch should we look for commits
+set :committed_commit_buffer, 1
+
+# Where to upload the report - '%s' is replaced with `current_path` if present.
+# `nil` will stop the report from uploading at all, and print to STDOUT instead.
+set :committed_output_path, '%s/public/committed.txt'
+
+# This is a regexp pattern that describes issue numbers in commit titles and
+# descriptions. This example matches JIRA numbers enclosed in square braces -
+# e.g. "[ABC-12345]" with the part inside the braces being captured "ABC-12345".
+# Setting this to `nil` will disable issue matching altogether. Note that this
+# setting should specify a string, not a Ruby Regexp object. Specifying a Regexp
+# object might work, but it is not tested.
+set :committed_issue_match, '\[\s?([A-Z0-9]+\-[0-9]+)\s?\]'
+
+# This is the URL structure for issues which are found. The default is for a
+# JIRA on Demand instance - e.g. https://example.jira.com/browse/ABC-12345
+# "%s" will be replaced with the issue number. Setting this to `nil` will also
+# disable issue matching altogether.
+set :committed_issue_url, 'https://example.jira.com/browse/%s'
+```
+
+Once your required settings are all in place, you can generate a report by running:
+
+```shell
+$ cap <stage> committed:generate
+```

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "capistrano/committed"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/capistrano-committed.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'capistrano/committed/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "capistrano-committed"
+  spec.version       = Capistrano::Committed::VERSION
+  spec.authors       = ["Sam Bauers"]
+  spec.email         = ["sam@redant.com.au"]
+  spec.license       = 'MIT'
+
+  spec.summary       = %q{Tells you what Capistrano 3 is going to deploy based on GitHub commits since the last release.}
+  spec.description   = %q{Tells you what Capistrano 3 is going to deploy based on GitHub commits since the last release.}
+  spec.homepage      = "https://github.com/sambauers/capistrano-committed"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "capistrano", '~> 3.4'
+  spec.add_dependency "github_api", "~> 0.12"
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.4"
+end

data/lib/capistrano/committed/github_api.rb

@@ -0,0 +1,70 @@
+require 'github_api'
+
+module Capistrano
+  module Committed
+    class GithubApi
+      def initialize(config_options = {})
+        raise TypeError, '`initialize` requires a hash to be passed as the first and only argument' unless config_options.is_a?(Hash)
+
+        config_options.merge!({
+          :adapter => :net_http,
+          :ssl => {:verify => false},
+          :per_page => 100,
+          :user_agent => 'Committed Ruby Gem (via Github API Ruby Gem)'
+        })
+
+        @client = ::Github.new config_options
+      end
+
+      def get_commit(user, repo, sha)
+        validate_user_and_repo(user, repo)
+        raise TypeError, sprintf('`%s` requires a valid commit SHA.', __callee__) unless sha.is_a?(String)
+
+        begin
+          @client.repos.commits.get(:user => user, :repo => repo, :sha => sha)
+        rescue ::Github::Error::GithubError => e
+          rescue_github_errors(e)
+        end
+      end
+
+      def get_commits_since(user, repo, date, branch = 'master')
+        validate_user_and_repo(user, repo)
+        date = Time.parse(date) if date.is_a?(String)
+        raise TypeError, sprintf('`%s` requires a valid date.', __callee__) unless date.is_a?(Time)
+        raise TypeError, sprintf('`%s` requires a valid branch.', __callee__) unless branch.is_a?(String)
+
+        begin
+          @client.repos.commits.list(:user => user, :repo => repo, :sha => branch, :since => date.iso8601)
+        rescue ::Github::Error::GithubError => e
+          rescue_github_errors(e)
+        end
+      end
+
+      def get_pull_request(user, repo, number)
+        validate_user_and_repo(user, repo)
+        raise TypeError, sprintf('`%s` requires a valid pull request number.', __callee__) unless number.is_a?(Integer)
+
+        begin
+          info = @client.pull_requests.get(:user => user, :repo => repo, :number => number)
+          commits = @client.pull_requests.commits(:user => user, :repo => repo, :number => number)
+          return {:info => info, :commits => commits}
+        rescue ::Github::Error::GithubError => e
+          rescue_github_errors(e)
+        end
+      end
+
+      def validate_user_and_repo(user, repo)
+        raise TypeError, sprintf('`%s` requires a valid GitHub user.', __caller__) unless user.is_a?(String)
+        raise TypeError, sprintf('`%s` requires a valid GitHub repository.', __caller__) unless repo.is_a?(String)
+      end
+
+      def rescue_github_errors(e)
+        if e.is_a? ::Github::Error::ServiceError
+          raise e, 'There seems to be a problem with the GitHub service.'
+        elsif e.is_a? ::Github::Error::ClientError
+          raise e, 'There seems to be a problem with the request that was made to GitHub, check that your settings are correct.'
+        end
+      end
+    end
+  end
+end

data/lib/capistrano/committed/i18n.rb

@@ -0,0 +1,38 @@
+require 'i18n'
+
+en = {
+  error: {
+    prerequisites: {
+      nil:                      '`:%{variable}` variable is `nil`, it needs to contain the %{name} name.',
+      empty:                    '`:%{variable}` variable is empty, it needs to contain the %{name} name.',
+      string:                   '`:%{variable}` variable is not a string.',
+      hash:                     '`:%{variable}` variable is not a hash.',
+      integer:                  '`:%{variable}` variable is not a integer.',
+      string_or_nil:            '`:%{variable}` variable is not a string or `nil`.',
+      string_or_regexp_or_nil:  '`:%{variable}` variable is not a string or `Regexp` object or `nil`.'
+    },
+    runtime: {
+      revisions_empty:          'The %{branch} branch has never been deployed to the %{stage} stage. No log has been generated.',
+      revision_commit_missing:  'No commit data has been found for the %{branch} branch on the %{stage} stage. No log has been generated.',
+      commits_empty:            'No commit data has been found for the %{branch} branch on the %{stage} stage since %{time}. No log has been generated.'
+    }
+  },
+  output: {
+    next_release:         'Next release',
+    previous_release:     'Commits before %{time} are omitted from the report   ¯\_(ツ)_/¯',
+    current_release:      'Release on %{release_time} from commit %{sha} at %{commit_time}',
+    pull_request_number:  'Pull Request #%{number}',
+    issue_links:          'Issue links:',
+    merged_on:            'Merged on: %{time}',
+    merged_by:            'Merged by: %{login}',
+    commit_sha:           'Commit %{sha}',
+    committed_on:         'Committed on: %{time}',
+    committed_by:         'Committed by: %{login}'
+  }
+}
+
+I18n.backend.store_translations(:en, { capistrano: { committed: en } })
+
+if I18n.respond_to?(:enforce_available_locales=)
+  I18n.enforce_available_locales = true
+end

data/lib/capistrano/committed/version.rb

@@ -0,0 +1,5 @@
+module Capistrano
+  module Committed
+    VERSION = '0.0.3'
+  end
+end

data/lib/capistrano/committed.rb

@@ -0,0 +1,22 @@
+require "capistrano/committed/version"
+require 'capistrano/committed/i18n'
+require "capistrano/committed/github_api"
+
+module Capistrano
+  module Committed
+    class << self
+      def scan_for_issues(pattern, string)
+        raise TypeError, sprintf('`%s` requires a valid pattern.', __callee__) unless pattern.is_a?(String) || pattern.is_a?(Regexp)
+        raise TypeError, sprintf('`%s` requires a valid string.', __callee__) unless pattern.is_a?(String)
+
+        matches = Regexp.new(pattern).match(string)
+        return unless matches && matches[1]
+        matches = matches.to_a
+        matches.shift
+        matches
+      end
+    end
+  end
+end
+
+load File.expand_path("../tasks/committed.rake", __FILE__)

data/lib/capistrano/tasks/committed.rake

@@ -0,0 +1,390 @@
+namespace :committed do
+  task :check_prerequisites do
+    # Checks all the settings to make sure they are OK - mostly just checks type
+    {:committed_user => 'user', :committed_repo => 'repository'}.each do |variable, name|
+      raise TypeError,
+            I18n.t('capistrano.committed.error.prerequisites.nil', variable: variable, name: name) if fetch(variable).nil?
+      raise ArgumentError,
+            I18n.t('capistrano.committed.error.prerequisites.empty', variable: variable, name: name) if fetch(variable).empty?
+    end
+
+    raise TypeError,
+          I18n.t('capistrano.committed.error.prerequisites.string', variable: 'committed_revision_line') unless fetch(:committed_revision_line).is_a?(String)
+    raise TypeError,
+          I18n.t('capistrano.committed.error.prerequisites.hash', variable: 'committed_github_config') unless fetch(:committed_github_config).is_a?(Hash)
+    raise TypeError,
+          I18n.t('capistrano.committed.error.prerequisites.integer', variable: 'committed_revision_limit') unless fetch(:committed_revision_limit).is_a?(Integer)
+    raise TypeError,
+          I18n.t('capistrano.committed.error.prerequisites.integer', variable: 'committed_commit_buffer') unless fetch(:committed_commit_buffer).is_a?(Integer)
+    raise TypeError,
+          I18n.t('capistrano.committed.error.prerequisites.string_or_nil', variable: 'committed_output_path') unless fetch(:committed_output_path).is_a?(String) || fetch(:committed_output_path).nil?
+    raise TypeError,
+          I18n.t('capistrano.committed.error.prerequisites.string_or_regexp_or_nil', variable: 'committed_issue_match') unless fetch(:committed_issue_match).is_a?(String) || fetch(:committed_issue_match).is_a?(Regexp) || fetch(:committed_issue_match).nil?
+    raise TypeError,
+          I18n.t('capistrano.committed.error.prerequisites.string_or_nil', variable: 'committed_issue_url') unless fetch(:committed_issue_url).is_a?(String) || fetch(:committed_issue_url).nil?
+  end
+
+  desc 'Generetes a report of commit and pull request status on the current stage'
+  task :generate do
+    invoke 'committed:check_prerequisites'
+
+    # Only do this on the primary web server
+    on primary :web do
+      # Get the Capistrano revision log
+      lines = capture(:cat, revision_log).split("\n").reverse
+
+      # Build the regex to search for revision data in the log, by default this
+      # is the localised string from Capistrano
+      search = fetch(:committed_revision_line)
+      search = Regexp.escape(search)
+      search = search.gsub('%\{', '(?<').gsub('\}', '>.+)')
+      search = Regexp.new(search)
+
+      # Build the revisions hash
+      revisions = {}
+      lines.each do |line|
+        matches = search.match(line)
+        next unless matches[:branch].to_s == fetch(:branch).to_s
+        revisions[matches[:sha]] = {
+          :branch => matches[:branch],
+          :sha => matches[:sha],
+          :release => matches[:release],
+          :user => matches[:user],
+          :entries => {}
+        }
+        # Only store a certain number of revisions
+        break if revisions.count == fetch(:committed_revision_limit)
+      end
+
+      # No revisions, no log
+      if revisions.empty?
+        info I18n.t('capistrano.committed.error.runtime.revisions_empty',
+                    branch: fetch(:branch).to_s,
+                    stage: fetch(:stage).to_s)
+        return
+      end
+
+      # Sort revisions by release date
+      revisions = revisions.sort_by{|sha, matches| matches[:release]}.to_h
+      # Add the "next" revision
+      revisions.merge!({
+        :next => {
+          :entries => {}
+        }
+      })
+      # Reverse the order of revisions in the hash (most recent first)
+      revisions = revisions.to_a.reverse.to_h
+      revisions.merge!({
+        :previous => {
+          :entries => {}
+        }
+      })
+
+      # Initialize the GitHub API client
+      github = ::Capistrano::Committed::GithubApi.new(fetch(:committed_github_config))
+
+      # Get the actual date of the commit referenced to by the revision
+      earliest_date = nil
+      revisions.each do |sha, revision|
+        next if sha == :next || sha == :previous
+        commit = github.get_commit(fetch(:committed_user), fetch(:committed_repo), sha)
+        unless commit.nil?
+          earliest_date = commit[:commit][:committer][:date]
+          revisions[sha][:date] = earliest_date
+        end
+      end
+
+      # No commit data on revisions, no log
+      if earliest_date.nil?
+        info I18n.t('capistrano.committed.error.runtime.revision_commit_missing',
+                    branch: fetch(:branch).to_s,
+                    stage: fetch(:stage).to_s)
+        return
+      end
+
+      # Go back an extra N day
+      earliest_date = (Time.parse(earliest_date) - (fetch(:committed_commit_buffer) * 24 * 60 * 60)).iso8601
+      revisions[:previous][:date] = earliest_date
+
+      # Get all the commits on this branch
+      commits = github.get_commits_since(fetch(:committed_user),
+                                         fetch(:committed_repo),
+                                         earliest_date,
+                                         fetch(:branch).to_s)
+
+      # No commits, no log
+      if commits.empty?
+        info I18n.t('capistrano.committed.error.runtime.commits_empty',
+                    branch: fetch(:branch).to_s,
+                    stage: fetch(:stage).to_s,
+                    time: earliest_date)
+        return
+      end
+
+      # Map commits to a hash keyed by sha
+      commits = Hash[commits.map { |commit| [commit[:sha], commit] }]
+
+      # Get all pull requests listed in the commits
+      revision_index = 0
+      commits.each do |sha, commit|
+        # Match to GitHub generated commit message, or don't
+        matches = /^Merge pull request \#([0-9]+)/.match(commit[:commit][:message])
+        next unless matches && matches[1]
+
+        # Get the pull request from GitHub
+        pull_request = github.get_pull_request(fetch(:committed_user),
+                                               fetch(:committed_repo),
+                                               matches[1].to_i)
+
+        # Get the previous revisions commit time and the merge time of the pull request
+        previous_revision = revisions[revisions.keys[revision_index + 1]]
+        previous_revision_date = Time.parse(previous_revision[:date])
+        merged_at = Time.parse(pull_request[:info][:merged_at])
+
+        # Unless this pull request was merged before the previous release reference was committed
+        unless merged_at > previous_revision_date
+          # Move to the previous revision
+          revision_index += 1
+        end
+
+        # Push pull request data in to the revision entries hash
+        revisions[revisions.keys[revision_index]][:entries][pull_request[:info][:merged_at]] = [{
+          :type => :pull_request,
+          :info => pull_request[:info],
+          :commits => pull_request[:commits]
+        }]
+
+        # Delete commits which are in this pull request from the hash of commits
+        commits.delete(sha)
+        next if pull_request[:commits].empty?
+        pull_request[:commits].each do |c|
+          commits.delete(c[:sha])
+        end
+      end
+
+      # Loop through remaining commits and push them into th revision entries hash
+      revision_index = 0
+      commits.each do |sha, commit|
+        previous_revision = revisions[revisions.keys[revision_index + 1]]
+        previous_revision_date = Time.parse(previous_revision[:date])
+        committed_at = Time.parse(commit[:commit][:committer][:date])
+
+        unless committed_at > previous_revision_date
+          revision_index += 1
+        end
+
+        if revisions[revisions.keys[revision_index]][:entries][commit[:commit][:committer][:date]].nil?
+          revisions[revisions.keys[revision_index]][:entries][commit[:commit][:committer][:date]] = []
+        end
+        revisions[revisions.keys[revision_index]][:entries][commit[:commit][:committer][:date]] << {
+          :type => :commit,
+          :info => commit
+        }
+      end
+
+      # Loop through the revisions to create the output
+      output = []
+      revisions.each do |sha, revision|
+
+        # Build the revision header
+        output << ''
+        output << '==============================================================================================='
+        case sha
+        when :next
+          output << I18n.t('capistrano.committed.output.next_release')
+        when :previous
+          output << I18n.t('capistrano.committed.output.previous_release',
+                           time: revision[:date])
+        else
+          output << I18n.t('capistrano.committed.output.current_release',
+                           release_time: Time.parse(revision[:release]).iso8601,
+                           sha: revision[:sha],
+                           commit_time: revision[:date])
+        end
+        output << '==============================================================================================='
+        output << ''
+
+        # Loop through the entries in this revision
+        revision[:entries].sort_by{|date, entries| date}.reverse.to_h.each do |date, entries|
+          entries.each do |entry|
+            case entry[:type]
+            when :pull_request
+              # These are pull requests that are included in this revision
+
+              # Print out the pull request number and title
+              output << sprintf(' * %s',
+                                I18n.t('capistrano.committed.output.pull_request_number',
+                                       number: entry[:info][:number]))
+              output << sprintf('   %s', entry[:info][:title])
+              output << ''
+
+              # Print out each line of the pull request description
+              lines = entry[:info][:body].chomp.split("\n")
+              unless lines.empty?
+                output << sprintf('   %s', lines.join("\n   "))
+                output << ''
+              end
+
+              unless fetch(:committed_issue_match).nil? || fetch(:committed_issue_url).nil?
+                # Get any issue numbers referred to in the commit info and print links to them
+                issues = ::Capistrano::Committed.scan_for_issues(fetch(:committed_issue_match),
+                                                                 entry[:info][:title] + entry[:info][:body])
+                unless issues.nil?
+                  output << sprintf('   %s',
+                                    I18n.t('capistrano.committed.output.issue_links'))
+                  issues.each do |issue|
+                    url = sprintf(fetch(:committed_issue_url), issue)
+                    output << sprintf('   - %s', url)
+                  end
+                  output << ''
+                end
+              end
+
+              # Merger details
+              output << sprintf('   %s',
+                                I18n.t('capistrano.committed.output.merged_on',
+                                       time: entry[:info][:merged_at]))
+              output << sprintf('   %s',
+                                I18n.t('capistrano.committed.output.merged_by',
+                                       login: entry[:info][:merged_by][:login]))
+              output << ''
+
+              # Print a link to the pull request on GitHub
+              output << sprintf('   %s', entry[:info][:html_url])
+              output << ''
+
+              # Loop through the commits in this pull request
+              unless entry[:commits].nil?
+                entry[:commits].each do |commit|
+                  output << '    -------------------------------------------------------------------------------------------'
+                  output << '   |'
+
+                  # Print the commit ref
+                  output << sprintf('   | * %s',
+                                    I18n.t('capistrano.committed.output.commit_sha',
+                                           sha: commit[:sha]))
+                  output << '   |'
+
+                  # Print the commit message
+                  lines = commit[:commit][:message].chomp.split("\n")
+                  unless lines.empty?
+                    output << sprintf('   |   > %s', lines.join("\n   |   > "))
+                    output << '   |'
+
+                    unless fetch(:committed_issue_match).nil? || fetch(:committed_issue_url).nil?
+                      # Get any issue numbers referred to in the commit message and print links to them
+                      issues = ::Capistrano::Committed.scan_for_issues(fetch(:committed_issue_match),
+                                                                       commit[:commit][:message])
+                      unless issues.nil?
+                        output << sprintf('   |   %s',
+                                          I18n.t('capistrano.committed.output.issue_links'))
+                        issues.each do |issue|
+                          url = sprintf(fetch(:committed_issue_url), issue)
+                          output << sprintf('   |   - %s' , url)
+                        end
+                        output << '   |'
+                      end
+                    end
+                  end
+
+                  # Committer details
+                  output << sprintf('   |   %s',
+                                    I18n.t('capistrano.committed.output.committed_on',
+                                           time: commit[:commit][:committer][:date]))
+                  output << sprintf('   |   %s',
+                                    I18n.t('capistrano.committed.output.committed_by',
+                                           login: commit[:committer][:login]))
+                  output << '   |'
+
+                  # Print a link to the commit in GitHub
+                  output << sprintf('   |   %s', commit[:html_url])
+                  output << '   |'
+                end
+                output << '    -------------------------------------------------------------------------------------------'
+                output << ''
+              end
+
+            when :commit
+              # These are commits that are included in this revision, but are not in any pull requests
+
+              # Print the commit ref
+              output << sprintf(' * %s',
+                                I18n.t('capistrano.committed.output.commit_sha',
+                                       sha: entry[:info][:sha]))
+              output << ''
+
+              # Print the commit message
+              lines = entry[:info][:commit][:message].chomp.split("\n")
+              unless lines.empty?
+                output << sprintf('   > %s', lines.join("\n   > "))
+                output << ''
+
+                unless fetch(:committed_issue_match).nil? || fetch(:committed_issue_url).nil?
+                  # Get any issue numbers referred to in the commit message and print links to them
+                  issues = ::Capistrano::Committed.scan_for_issues(fetch(:committed_issue_match),
+                                                                   entry[:info][:commit][:message])
+                  unless issues.nil?
+                    output << sprintf('   %s',
+                                      I18n.t('capistrano.committed.output.issue_links'))
+                    issues.each do |issue|
+                      url = sprintf(fetch(:committed_issue_url), issue)
+                      output << sprintf('   - %s', url)
+                    end
+                    output << ''
+                  end
+                end
+              end
+
+              # Committer details
+              output << sprintf('   %s',
+                                I18n.t('capistrano.committed.output.committed_on',
+                                       time: entry[:info][:commit][:committer][:date]))
+              output << sprintf('   %s',
+                                I18n.t('capistrano.committed.output.committed_by',
+                                       login: entry[:info][:committer][:login]))
+              output << ''
+
+              # Print a link to the commit in GitHub
+              output << sprintf('   %s', entry[:info][:html_url])
+              output << ''
+            end
+
+            output << '-----------------------------------------------------------------------------------------------'
+            output << ''
+          end
+        end
+
+        output << ''
+      end
+
+      # Send the output to screen, or to a file on the server
+      if fetch(:committed_output_path).nil?
+        # Just print to STDOUT
+        puts output
+      else
+        # Determine the output path and upload the output there
+        output_path = sprintf(fetch(:committed_output_path), current_path)
+        upload! StringIO.new(output.join("\n")), output_path
+
+        # Make sure the report is world readable
+        execute(:chmod, 'a+r', output_path)
+      end
+    end
+  end
+end
+
+# Load the default settings
+namespace :load do
+  task :defaults do
+    # See README for descriptions of each setting
+    set :committed_user,            ->{ nil }
+    set :committed_repo,            ->{ nil }
+    set :committed_revision_line,   ->{ I18n.t('capistrano.revision_log_message') }
+    set :committed_github_config,   ->{ {} }
+    set :committed_revision_limit,  ->{ 10 }
+    set :committed_commit_buffer,   ->{ 1 }
+    set :committed_output_path,     ->{ '%s/public/committed.txt' }
+    set :committed_issue_match,     ->{ '\[\s?([A-Z0-9]+\-[0-9]+)\s?\]' }
+    set :committed_issue_url,       ->{ 'https://example.jira.com/browse/%s' }
+  end
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: capistrano-committed
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Sam Bauers
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-12-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: capistrano
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: github_api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+description: Tells you what Capistrano 3 is going to deploy based on GitHub commits
+  since the last release.
+email:
+- sam@redant.com.au
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- capistrano-committed.gemspec
+- lib/capistrano/committed.rb
+- lib/capistrano/committed/github_api.rb
+- lib/capistrano/committed/i18n.rb
+- lib/capistrano/committed/version.rb
+- lib/capistrano/tasks/committed.rake
+homepage: https://github.com/sambauers/capistrano-committed
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Tells you what Capistrano 3 is going to deploy based on GitHub commits since
+  the last release.
+test_files: []
+has_rdoc: