octopolo 0.0.1

data/lib/octopolo/pivotal.rb

@@ -0,0 +1,44 @@
+require "pivotal-tracker" # this is the gem we're currently using
+require_relative "scripts/pivotal_auth"
+
+module Octopolo
+  module Pivotal
+    # NOTE Should probably extract out to
+    class Client
+      include UserConfigWrapper
+      # Public: Initialize a new instance of Pivotal::Client wrapper class
+      def initialize
+        # no idea why this is off by default (as of 2013-04-18)
+        ::PivotalTracker::Client.use_ssl = true
+        begin
+          ::PivotalTracker::Client.token = user_config.pivotal_token
+        rescue UserConfig::MissingPivotalAuth
+          Scripts::PivotalAuth.run
+          ::PivotalTracker::Client.token = UserConfig.parse.pivotal_token
+        end
+      end
+
+      # Public: Fetch an API token for the given authentication
+      #
+      # email - a String containing the email address used to log in
+      # password - a String containing the password
+      #
+      # Returns a String or raises BadCredentials
+      def self.fetch_token(email, password)
+        ::PivotalTracker::Client.token(email, password)
+      rescue RestClient::Unauthorized
+        raise BadCredentials, "No token received from Pivotal Tracker. Please check your credentials and try again."
+      end
+
+      def find_story(story_id)
+        @projects = PivotalTracker::Project.all
+        @projects.map{ |project| project.stories.find(story_id) }.compact.first || raise(StoryNotFound, "No Story was found with that ID in your Projects")
+      end
+    end
+
+    # the credentials that you've entered are wrong
+    BadCredentials = Class.new(StandardError)
+    # 404 from the PT api
+    StoryNotFound = Class.new(StandardError)
+  end
+end

data/lib/octopolo/pivotal/story_commenter.rb

@@ -0,0 +1,19 @@
+require_relative '../pivotal'
+
+module Octopolo
+  module Pivotal
+    class StoryCommenter
+      attr_accessor :story
+      attr_accessor :comment
+
+      def initialize(story_id, comment)
+        self.story = Pivotal::Client.new.find_story(story_id)
+        self.comment = comment
+      end
+
+      def perform
+        story.notes.new(:owner => story, :text => comment).create
+      end
+    end
+  end
+end

data/lib/octopolo/pull_request_merger.rb

@@ -0,0 +1,99 @@
+require_relative "scripts"
+require_relative "git"
+require_relative "github/pull_request"
+require_relative "dated_branch_creator"
+
+module Octopolo
+  class PullRequestMerger
+    include ConfigWrapper
+    include CLIWrapper
+    include GitWrapper
+
+    attr_accessor :branch_type, :pull_request_id, :options, :pull_request
+
+    # Public: Initialize a new instance of DatedBranchCreator
+    #
+    # branch_type - Name of the type of branch (e.g., staging or deployable)
+    # pull_request_id - The pull request id to use for the merge
+    # options - hash of options
+    #   - post_comment - whether or not to post a comment on the pull-request
+    def initialize(branch_type, pull_request_id, options={})
+      self.branch_type = branch_type
+      self.pull_request_id = pull_request_id
+      self.options = options
+    end
+
+    # Public: Create a new branch of the given type for today's date
+    #
+    # branch_type - Name of the type of branch (e.g., staging or deployable)
+    # post_comment - Whether or not to comment on the pull-request
+    #
+    # Returns a DatedBranchCreator
+    def self.perform(branch_type, pull_request_id, options={})
+      new(branch_type, pull_request_id, options).tap do |creator|
+        creator.perform
+      end
+    end
+
+    # Public: Create the branch and handle related processing
+    def perform
+      git.if_clean do
+        check_out_branch
+        merge_pull_request
+        comment_about_merge
+      end
+    rescue GitHub::PullRequest::NotFound
+      cli.say "Unable to find pull request #{pull_request_id}. Please retry with a valid ID."
+    rescue Git::MergeFailed
+      cli.say "Merge failed. Please identify the source of this merge conflict resolve this conflict in your pull request's branch. NOTE: Merge conflicts resolved in the #{branch_type} branch are NOT used when deploying."
+    rescue Git::CheckoutFailed
+      cli.say "Checkout of #{branch_to_merge_into} failed. Please contact Infrastructure to determine the cause."
+    rescue GitHub::PullRequest::CommentFailed
+      cli.say "Unable to write comment. Please navigate to #{pull_request.url} and add the comment, '#{comment_body}'"
+    end
+
+   # Public: Check out the branch
+    def check_out_branch
+      git.check_out branch_to_merge_into
+    rescue Git::NoBranchOfType
+      cli.say "No #{branch_type} branch available. Creating one now."
+      git.check_out DatedBranchCreator.perform(branch_type).branch_name
+    end
+
+    # Public: Merge the pull request's branch into the checked-out branch
+    def merge_pull_request
+      git.merge pull_request.branch
+    end
+
+    # Public: Comment that the pull request was merged into the branch
+    def comment_about_merge
+      pull_request.write_comment comment_body
+    end
+
+    # Public: The content of the comment to post when merged
+    #
+    # Returns a String
+    def comment_body
+      body = "Merged into #{branch_to_merge_into}."
+      if options[:user_notifications]
+        body << " /cc #{options[:user_notifications].map {|name| "@#{name}"}.join(' ')}"
+      end
+      body
+    end
+
+    # Public: Find the pull request
+    #
+    # Returns a GitHub::PullRequest
+    def pull_request
+      @pull_request ||= GitHub::PullRequest.new config.github_repo, pull_request_id
+    end
+
+    # Public: Find the branch
+    #
+    # Returns a String
+    def branch_to_merge_into
+      @branch_to_merge_into ||= git.latest_branch_for(branch_type)
+    end
+  end
+end
+

data/lib/octopolo/renderer.rb

@@ -0,0 +1,37 @@
+require "erb"
+require "ostruct"
+
+module Octopolo
+  class Renderer
+    # Constants for the template file names
+    PULL_REQUEST_BODY = "pull_request_body"
+
+    # Public: Render a given ERB template
+    #
+    # template - A String contianing the name of the ERB template
+    # locals - A Hash containing variables to render. The keys must match the variable names in the template
+    #
+    # Lifted from [Stack Overflow](http://stackoverflow.com/questions/8954706/render-an-erb-template-with-values-from-a-hash)
+    #
+    # Example
+    #
+    #   render "first_last_name_template", {first: "Bob", last: "Person"}
+    #   # => "Bob Person"
+    #
+    # Returns a String containing the rendered template
+    def self.render template, locals
+      # template_string, safe_mode = 0, "-" to trim whitespace in ERB tags ending -%> (like Rails)
+      ERB.new(contents_of(template), 0, "-").result(OpenStruct.new(locals).instance_eval { binding })
+    end
+
+    # Public: The contents of the named template
+    def self.contents_of template
+      File.read File.join(template_base_path, "#{template}.erb")
+    end
+
+    # Public: Path to the directory containing the templates
+    def self.template_base_path
+      File.expand_path(File.join(__FILE__, "../templates"))
+    end
+  end
+end

data/lib/octopolo/reports.rb

@@ -0,0 +1,18 @@
+require "csv"
+
+module Octopolo
+  module Reports
+    # Public: Write the report data to the given file name
+    #
+    # data - Array of report data, each element being a line of the CSV
+    # filename - The name of the file to write to
+    def self.write_csv data, filename
+      CSV.open filename, "w" do |file|
+        data.each do |line|
+          file.puts line
+        end
+      end
+    end
+  end
+end
+

data/lib/octopolo/scripts.rb

@@ -0,0 +1,23 @@
+require_relative "git"
+
+module Octopolo
+  module Scripts
+    module Base
+      def self.included(klass)
+        class << klass
+          attr_accessor :config
+          attr_accessor :cli
+        end
+
+        klass.config = Octopolo.config
+        klass.cli = Octopolo::CLI
+      end
+    end
+  end
+end
+
+# Mostly used for tests
+unless defined?(GLI)
+  require 'gli'
+  include GLI::App
+end

data/lib/octopolo/scripts/accept_pull.rb

@@ -0,0 +1,67 @@
+require_relative "../git"
+require_relative "../github"
+require_relative "../github/pull_request"
+require_relative "../scripts"
+
+module Octopolo
+  module Scripts
+    class AcceptPull
+      include Base
+      include GitWrapper
+      include ConfigWrapper
+      include CLIWrapper
+
+      attr_accessor :pull_request_id
+
+      def self.execute(pull_request_id)
+        pull_request_id ||= Integer(cli.prompt "Pull Request ID: ")
+        new(pull_request_id).execute
+      end
+
+      def initialize(pull_request_id)
+        @pull_request_id = pull_request_id
+      end
+
+      # Public: Perform the script
+      def execute
+        GitHub.connect do
+          pull_request = GitHub::PullRequest.new(config.github_repo, pull_request_id)
+          merge pull_request
+          update_changelog pull_request
+        end
+      rescue GitHub::PullRequest::NotFound
+        cli.say "Unable to find a pull request #{pull_request_id} for #{config.github_repo}. Please verify."
+      end
+
+      def merge pull_request
+        Git.fetch
+        if pull_request.mergeable?
+          cli.perform "git merge --no-ff origin/#{pull_request.branch} -m \"Merge pull request ##{pull_request_id} from origin/#{pull_request.branch}\""
+        else
+          cli.say "There is a merge conflict with this branch and #{config.deploy_branch}."
+          cli.say "Please update this branch with #{config.deploy_branch} or perform the merge manually and fix any conflicts"
+        end
+      end
+
+      def changelog
+        @changelog ||= Changelog.new
+      end
+
+      def update_changelog pull_request
+        title = pull_request.title
+        authors = pull_request.author_names
+        commenters = pull_request.commenter_names
+        url = pull_request.url
+
+        changelog.open do |log|
+          log.puts "* #{title}"
+          log.puts
+          log.puts "  > #{authors.join(", ")}: #{commenters.join(', ')}: #{url}"
+          log.puts
+        end
+      end
+
+    end
+  end
+end
+

data/lib/octopolo/scripts/compare_release.rb

@@ -0,0 +1,52 @@
+require_relative "../scripts"
+
+module Octopolo
+  module Scripts
+    class CompareRelease
+      include Base
+      include GitWrapper
+      include ConfigWrapper
+      include CLIWrapper
+
+      attr_accessor :start
+      attr_accessor :stop
+
+      def self.execute(start, stop)
+        new(start, stop).execute
+      end
+
+      def initialize(start=nil, stop=nil)
+        @start = start
+        @stop  = stop
+      end
+
+      def execute
+        ask_starting_tag
+        ask_stopping_tag
+        open_compare_page
+      end
+
+      # Public: Ask, if not already set, which tag to start with
+      def ask_starting_tag
+        self.start ||= cli.ask("Start with which tag?", git.recent_release_tags)
+      end
+
+      # Public: Ask, if not already set, which tag to end with
+      def ask_stopping_tag
+        self.stop ||= cli.ask("Compare from #{start} to which tag?", git.recent_release_tags)
+      end
+
+      # Public: Open the GitHub compare URL for the starting and ending branches
+      def open_compare_page
+        cli.copy_to_clipboard compare_url
+        cli.open compare_url
+      end
+
+      # Public: The GitHub compare URL for the selected tags
+      def compare_url
+        "https://github.com/#{config.github_repo}/compare/#{start}...#{stop}?w=1"
+      end
+    end
+  end
+end
+

data/lib/octopolo/scripts/deployable.rb

@@ -0,0 +1,27 @@
+require_relative "../scripts"
+require_relative "../pull_request_merger"
+
+module Octopolo
+  module Scripts
+    class Deployable
+      include CLIWrapper
+      include ConfigWrapper
+
+      attr_accessor :pull_request_id
+
+      def self.execute(pull_request_id=nil)
+        new(pull_request_id).execute
+      end
+
+      def initialize(pull_request_id=nil)
+        @pull_request_id = pull_request_id
+      end
+
+      # Public: Perform the script
+      def execute
+        self.pull_request_id ||= cli.prompt("Pull Request ID: ")
+        PullRequestMerger.perform Git::DEPLOYABLE_PREFIX, Integer(@pull_request_id), :user_notifications => config.user_notifications
+      end
+    end
+  end
+end

data/lib/octopolo/scripts/github_auth.rb

@@ -0,0 +1,87 @@
+require "json"
+require_relative "../github"
+require_relative "../scripts"
+
+module Octopolo
+  module Scripts
+    class GithubAuth
+      include CLIWrapper
+      include UserConfigWrapper
+
+      attr_accessor :username
+      attr_accessor :password
+      attr_accessor :auth_response
+      attr_accessor :user_defined_token
+
+      def execute
+        case ask_auth_method
+        when "Generate an API token with my credentials"
+          ask_credentials
+          request_token
+        when "I'll enter an access token manually"
+          ask_token
+          verify_token
+        end
+        store_token
+      rescue GitHub::BadCredentials => e
+        cli.say e.message
+      end
+
+      # Private: Give option to manually get token from GitHub and use it instead of using creds (For people that use 2FA)
+      def ask_auth_method
+        question = "Would you like to generate an GitHub API token with your credentials or enter one manually?\n"\
+                   "You *must* enter a token manually if you are using GitHub's Two Factor Authentication.\n"\
+                   "For more information, see https://help.github.com/articles/creating-an-access-token-for-command-line-use\n\n"
+        choices = ["Generate an API token with my credentials", "I'll enter an access token manually"]
+        selected = cli.ask(question, choices)
+      end
+      private :ask_auth_method
+
+      # Private: Request the user's GitHub username and password
+      def ask_credentials
+        self.username = cli.prompt "Your GitHub username: "
+        self.password = cli.prompt_secret "Your GitHub password (never stored): "
+      end
+      private :ask_credentials
+
+      # Private: Request an auth token from GitHub
+      def request_token
+        json = cli.perform_quietly %Q(curl -u '#{username}:#{password}' -d '{"scopes": ["repo"], "notes": "Octopolo"}' https://api.github.com/authorizations)
+        self.auth_response = JSON.parse json
+      end
+      private :request_token
+
+      # Private: Verify a user_defined_token with GitHub
+      def verify_token
+        json = cli.perform_quietly %Q(curl -u #{user_defined_token}:x-oauth-basic https://api.github.com/user)
+        self.auth_response = JSON.parse json
+      end
+      private :verify_token
+
+      # Private: Request the user to give a token to be set manually (required for 2FA)
+      def ask_token
+        self.username = cli.prompt "Your GitHub username: "
+        self.user_defined_token = cli.prompt_secret "Your GitHub API token: "
+      end
+      private :ask_token
+
+      # Private: Store the token recieved from GitHub
+      #
+      # If a token is present in the response, store it in the user config.
+      # Otherwise indicate that the authorization did not succeed.
+      def store_token
+        token = auth_response["login"] ? user_defined_token : auth_response["token"]
+        if token
+          user_config.set :github_user, username
+          user_config.set :github_token, token
+          cli.say "Successfully stored GitHub API token."
+        else
+          raise GitHub::BadCredentials, "Uh oh, your access token couldn't be generated/verified. Please check your credentials and try again."
+        end
+      end
+      private :store_token
+
+    end
+  end
+end
+