capistrano-committed 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e0a4cbd5d40c614432cafb96c384335df53c9a32
-  data.tar.gz: cacda04b507f455bcf753ee2f8c2f91b578d417b
+  metadata.gz: 5fe7f70c9b07f59c5bc350622702aa0aa9ab7fec
+  data.tar.gz: 21b3b32dcc4195be1bd68cd5cff667ad6f4301ab
 SHA512:
-  metadata.gz: b3b0241825e0bb3ad169e2560dc39a80e4d6505f00304c0db8361d06107772e1c32e52e1f5a1f1f06ede442765a0ef2f32ddda3bcc5b3921493a4f79aebec635
-  data.tar.gz: a337d0a2b55eee5fb85adffebd8f21d6ee865d3f2bb8efdaaa6817175d2c6a9a5ea89bd0938f8cff5496e5ed126d9107802492cd3052b81502e3435f92efb169
+  metadata.gz: f4677d783f58853501d7705bde6e459916c642d467fe79f83ff02bd6fc814bbbf266b6c566a62fc1c72fef9a78f78ff1ebbe235e7286fa59081a26bee08544ab
+  data.tar.gz: bcc8b8781b1b674e5a026b42acc9cb7fd15ef96bdbc99de0bd93662b7581c6f78a4a694924130c3ae48ea497efff30b13c4f9502c10696efc803ea9d5c6462b9

data/.codeclimate.yml

@@ -6,15 +6,20 @@ engines:
       - ruby
   fixme:
     enabled: true
-    exclude_fingerprints:
-    - ee0a31701f95b21db4aff40647a56a3d
-    - b86af833d6b2b1fa18da63471e2278d9
-    - cdc1cac1f5cb7afe72dca9f9bca8a237
   rubocop:
     enabled: true
 ratings:
   paths:
   - "**.rb"
   - "**.rake"
+  - "Rakefile"
 exclude_paths:
+- bin/**/*
+- icons/**/*
 - spec/**/*
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- "LICENSE.md"
+- "README.md"

data/README.md

@@ -101,8 +101,7 @@ set :committed_output_path, '%s/public/committed.txt'
 # 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.
+# setting should specify a string, not a Ruby Regexp object.
 set :committed_issue_match, '\[\s?([a-zA-Z0-9]+\-[0-9]+)\s?\]'
 
 # This is an array of methods which should be applied to matched issue numbers
@@ -118,7 +117,8 @@ set :committed_issue_postprocess, -> { [] }
 # disable issue matching altogether.
 set :committed_issue_url, 'https://example.jira.com/browse/%s'
 
-# Register deployments in GitHub via the GitHub Deployments API
+# Register deployments in GitHub via the GitHub Deployments API (not
+# implemented yet)
 set :committed_deployments, false
 ```
 

data/capistrano-committed.gemspec

@@ -7,7 +7,7 @@ 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.email         = ["sam@wopr.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.}

data/lib/capistrano/committed/version.rb

@@ -1,5 +1,5 @@
 module Capistrano
   module Committed
-    VERSION = '0.0.6'
+    VERSION = '0.0.7'
   end
 end

data/lib/capistrano/committed.rb

@@ -5,6 +5,144 @@ require 'capistrano/committed/github_api'
 module Capistrano
   module Committed
     class << self
+      def revision_search_regex(revision_line)
+        check_type __callee__, 'revision_line', revision_line.is_a?(String)
+
+        search = Regexp.escape(revision_line)
+        search = search.gsub('%\{', '(?<').gsub('\}', '>.+)')
+        Regexp.new(search)
+      end
+
+      def get_revisions_from_lines(lines, search, branch, limit)
+        check_type __callee__, 'lines', lines.is_a?(Array)
+        lines.each_with_index { |line, index|
+          check_type __callee__,
+                     format('lines[%d]', index),
+                     line.is_a?(String)
+        }
+        check_type __callee__, 'search', search.is_a?(Regexp)
+        check_type __callee__, 'branch', (branch.is_a?(Symbol) || branch.is_a?(String))
+        check_type __callee__, 'limit', limit.is_a?(Integer)
+
+        revisions = {}
+        lines.each do |line|
+          matches = search.match(line)
+          next if matches.nil?
+          next unless matches[:branch].to_s == branch.to_s
+          revisions[matches[:release]] = {
+            branch:   matches[:branch],
+            sha:      matches[:sha],
+            release:  matches[:release],
+            user:     matches[:user],
+            entries:  {}
+          }
+          # Only store a certain number of revisions
+          break if revisions.count == limit
+        end
+        pad_revisions(revisions)
+      end
+
+      def add_dates_to_revisions(revisions, github, git_user, git_repo)
+        check_type __callee__, 'revisions', revisions.is_a?(Hash)
+        check_type __callee__, 'github', github.is_a?(Capistrano::Committed::GithubApi)
+        check_type __callee__, 'git_user', git_user.is_a?(String)
+        check_type __callee__, 'git_repo', git_repo.is_a?(String)
+
+        revisions.each do |release, revision|
+          next if release == :next || release == :previous
+          commit = github.get_commit(git_user,
+                                     git_repo,
+                                     revision[:sha])
+          unless commit.nil?
+            revisions[release][:date] = commit[:commit][:committer][:date]
+          end
+        end
+        revisions
+      end
+
+      def get_earliest_date_from_revisions(revisions)
+        check_type __callee__, 'revisions', revisions.is_a?(Hash)
+
+        revisions.values.map{ |r| Time.parse(r[:date]) unless r[:date].nil? }.compact.min
+      end
+
+      def days_to_seconds(days)
+        check_type __callee__, 'days', days.is_a?(Numeric)
+
+        days * 24 * 60 * 60
+      end
+
+      def add_buffer_to_time(time, buffer_in_days)
+        check_type __callee__, 'time', time.is_a?(Time)
+        check_type __callee__, 'buffer_in_days', buffer_in_days.is_a?(Numeric)
+
+        (time - days_to_seconds(buffer_in_days)).iso8601
+      end
+
+      def format_revision_header(release, revision)
+        check_type __callee__, 'release', (release.is_a?(Symbol) || release.is_a?(String))
+        check_type __callee__, 'revision', revision.is_a?(Hash)
+
+        output = ['']
+        output << ('=' * 94)
+        case release
+        when :next
+          output << t('committed.output.next_release')
+        when :previous
+          output << t('committed.output.previous_release',
+                      time: revision[:date])
+        else
+          output << t('committed.output.current_release',
+                      release_time: Time.parse(revision[:release]).iso8601,
+                      sha: revision[:sha],
+                      commit_time: revision[:date])
+        end
+        output << ('=' * 94)
+        output << ''
+      end
+
+      def format_commit(commit, pad, issue_pattern, postprocess, url_pattern)
+        check_type __callee__, 'commit', commit.is_a?(Hash)
+        check_type __callee__, 'pad', pad.is_a?(String)
+        # issue_pattern, postprocess, and url_pattern get type checked by `get_issue_urls`
+
+        # Print the commit ref
+        output = [format('%s * %s',
+                         pad,
+                         t('committed.output.commit_sha', sha: commit[:sha]))]
+        output << pad
+
+        # Print the commit message
+        lines = commit[:commit][:message].chomp.split("\n")
+        unless lines.empty?
+          lines.each do |line|
+            output << format('%s   > %s', pad, line)
+          end
+          output << pad
+
+          # Get any issue numbers referred to in the commit message
+          # and print links to them
+          urls = get_issue_urls(issue_pattern,
+                                postprocess,
+                                url_pattern,
+                                commit[:commit][:message])
+          output += format_issue_urls(urls, pad)
+        end
+
+        # Committer details
+        output << format('%s   %s',
+                         pad,
+                         t('committed.output.committed_on', time: commit[:commit][:committer][:date]))
+        output << format('%s   %s',
+                         pad,
+                         t('committed.output.committed_by', login: commit[:committer][:login]))
+        output << pad
+
+        # Print a link to the commit in GitHub
+        output << format('%s   %s', pad, commit[:html_url])
+        output << pad
+      end
+
       def get_issue_urls(issue_pattern, postprocess, url_pattern, message)
         check_type __callee__,
                    'issue_pattern',
@@ -22,13 +160,14 @@ module Capistrano
 
         matches = message.scan(Regexp.new(issue_pattern))
         return [] unless matches
-        matches.map { |match|
+        matches.map! { |match|
           issue = match[0]
           postprocess.each { |method|
             issue = issue.send(method)
           }
           format(url_pattern, issue)
         }
+        matches.uniq
       end
 
       def format_issue_urls(urls, pad = '')
@@ -47,6 +186,20 @@ module Capistrano
                         method: method,
                         param: param) unless condition
       end
+
+      def pad_revisions(revisions)
+        check_type __callee__, 'revisions', revisions.is_a?(Hash)
+
+        unless revisions.empty?
+          # Sort revisions by release date
+          revisions = Hash[revisions.sort { |a, b| b[1][:release] <=> a[1][:release] }]
+          # Add the "previous" revision
+          revisions.merge!(previous: { entries: {} })
+          # Add the "next" revision
+          revisions = {next: { entries: {} }}.merge(revisions)
+        end
+        revisions
+      end
     end
   end
 end

data/lib/capistrano/tasks/committed.rake

@@ -95,27 +95,10 @@ namespace :committed do
 
       # 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)
+      search = ::Capistrano::Committed.revision_search_regex(fetch(:committed_revision_line))
 
       # Build the revisions hash
-      revisions = {}
-      lines.each do |line|
-        matches = search.match(line)
-        next if matches.nil?
-        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
+      revisions = ::Capistrano::Committed.get_revisions_from_lines(lines, search, fetch(:branch), fetch(:committed_revision_limit))
 
       # No revisions, no log
       if revisions.empty?
@@ -125,29 +108,14 @@ namespace :committed do
         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
+      revisions = ::Capistrano::Committed.add_dates_to_revisions(revisions, github, fetch(:committed_user), fetch(:committed_repo))
+
+      # Get the earliest revision date
+      earliest_date = ::Capistrano::Committed.get_earliest_date_from_revisions(revisions)
 
       # No commit data on revisions, no log
       if earliest_date.nil?
@@ -157,9 +125,8 @@ namespace :committed do
         return
       end
 
-      # Go back an extra N day
-      buffer = fetch(:committed_commit_buffer) * 24 * 60 * 60
-      earliest_date = (Time.parse(earliest_date) - buffer).iso8601
+      # Go back an extra N days
+      earliest_date = ::Capistrano::Committed.add_buffer_to_time(earliest_date, fetch(:committed_commit_buffer))
       revisions[:previous][:date] = earliest_date
 
       # Get all the commits on this branch
@@ -245,27 +212,14 @@ namespace :committed do
 
       # Loop through the revisions to create the output
       output = []
-      revisions.each do |sha, revision|
+      revisions.each do |release, revision|
         # Build the revision header
-        output << ''
-        output << ('=' * 94)
-        case sha
-        when :next
-          output << t('committed.output.next_release')
-        when :previous
-          output << t('committed.output.previous_release',
-                      time: revision[:date])
-        else
-          output << t('committed.output.current_release',
-                      release_time: Time.parse(revision[:release]).iso8601,
-                      sha: revision[:sha],
-                      commit_time: revision[:date])
-        end
-        output << ('=' * 94)
-        output << ''
+        output += ::Capistrano::Committed.format_revision_header(release,
+                                                                 revision)
 
         # Loop through the entries in this revision
-        revision[:entries].sort_by { |date, _entries| date }.reverse.to_h.each do |_date, entries|
+        items = Hash[revision[:entries].sort_by { |date, _entries| date }.reverse]
+        items.each do |_date, entries|
           entries.each do |entry|
             case entry[:type]
             when :pull_request
@@ -311,41 +265,11 @@ namespace :committed do
                 entry[:commits].each do |commit|
                   output << ('    ' + ('-' * 90))
                   output << '   |'
-
-                  # Print the commit ref
-                  output << format('   | * %s',
-                                   t('committed.output.commit_sha',
-                                     sha: commit[:sha]))
-                  output << '   |'
-
-                  # Print the commit message
-                  lines = commit[:commit][:message].chomp.split("\n")
-                  unless lines.empty?
-                    output << format('   |   > %s', lines.join("\n   |   > "))
-                    output << '   |'
-
-                    # Get any issue numbers referred to in the commit message
-                    # and print links to them
-                    urls = ::Capistrano::Committed.get_issue_urls(fetch(:committed_issue_match),
+                  output += ::Capistrano::Committed.format_commit(commit,
+                                                                  '   |',
+                                                                  fetch(:committed_issue_match),
                                                                   fetch(:committed_issue_postprocess),
-                                                                  fetch(:committed_issue_url),
-                                                                  commit[:commit][:message])
-                    output += ::Capistrano::Committed.format_issue_urls(urls,
-                                                                        '   |')
-                  end
-
-                  # Committer details
-                  output << format('   |   %s',
-                                   t('committed.output.committed_on',
-                                     time: commit[:commit][:committer][:date]))
-                  output << format('   |   %s',
-                                   t('committed.output.committed_by',
-                                     login: commit[:committer][:login]))
-                  output << '   |'
-
-                  # Print a link to the commit in GitHub
-                  output << format('   |   %s', commit[:html_url])
-                  output << '   |'
+                                                                  fetch(:committed_issue_url))
                 end
                 output << ('    ' + ('-' * 90))
                 output << ''
@@ -354,40 +278,11 @@ namespace :committed do
             when :commit
               # These are commits that are included in this revision, but are
               # not in any pull requests
-
-              # Print the commit ref
-              output << format(' * %s',
-                               t('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 << format('   > %s', lines.join("\n   > "))
-                output << ''
-
-                # Get any issue numbers referred to in the commit message and
-                # print links to them
-                urls = ::Capistrano::Committed.get_issue_urls(fetch(:committed_issue_match),
+              output += ::Capistrano::Committed.format_commit(entry[:info],
+                                                              '',
+                                                              fetch(:committed_issue_match),
                                                               fetch(:committed_issue_postprocess),
-                                                              fetch(:committed_issue_url),
-                                                              entry[:info][:commit][:message])
-                output += ::Capistrano::Committed.format_issue_urls(urls)
-              end
-
-              # Committer details
-              output << format('   %s',
-                               t('committed.output.committed_on',
-                                 time: entry[:info][:commit][:committer][:date]))
-              output << format('   %s',
-                               t('committed.output.committed_by',
-                                 login: entry[:info][:committer][:login]))
-              output << ''
-
-              # Print a link to the commit in GitHub
-              output << format('   %s', entry[:info][:html_url])
-              output << ''
+                                                              fetch(:committed_issue_url))
             end
 
             output << ('-' * 94)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: capistrano-committed
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - Sam Bauers
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-02-16 00:00:00.000000000 Z
+date: 2016-05-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: capistrano
@@ -83,7 +83,7 @@ dependencies:
 description: Tells you what Capistrano 3 is going to deploy based on GitHub commits
   since the last release.
 email:
-- sam@redant.com.au
+- sam@wopr.com.au
 executables: []
 extensions: []
 extra_rdoc_files: []