toolshed 1.0.2 → 1.0.3

data/lib/toolshed/commands/checkout_branch.rb

@@ -1,10 +1,23 @@
+require 'toolshed/git'
+
 module Toolshed
   module Commands
     class CheckoutBranch
+      def self.cli_options
+        {
+          banner: 'Usage: checkout_branch [options]',
+          options: {
+            branch_name: {
+              short_on: '-b',
+            }
+          }
+        }
+      end
+
       def execute(args, options = {})
         branch_name = read_user_input("Ticket ID or Branch Name:", options)
-        branch_name = Toolshed::Git::Base.checkout(branch_name)
-        puts "Switched to '#{branch_name}'"
+        Toolshed::Git::Branch.checkout(branch_name)
+        Toolshed.die
       end
 
       def read_user_input(message, options)

data/lib/toolshed/commands/create_branch.rb

@@ -1,39 +1,46 @@
+require 'toolshed/git'
+
 module Toolshed
   module Commands
+    # Create a branch from a given set of parameters
     class CreateBranch
-      def execute(args, options = {})
-        begin
-          branch_name = read_user_input_branch_name("Branch name:", options)
-          branch_from = read_user_input_branch_from("Branch from:", options)
-
-          puts "Branch name: #{branch_name}"
-          puts "Branching from: #{branch_from}"
+      def self.cli_options # rubocop:disable Metrics/MethodLength
+        {
+          banner: 'Usage: create_branch [options]',
+          options: {
+            branch_name: {
+              short_on: '-b'
+            },
+            branch_from: {
+              short_on: '-f'
+            }
+          }
+        }
+      end
 
-          git = Toolshed::Git::Base.new({
-            from_remote_branch_name: branch_from,
-            to_remote_branch_name: branch_name,
-          })
-          git.create_branch
+      def execute(_args, options = {}) # rubocop:disable Metrics/MethodLength
+        branch_name = read_user_input_branch_name('Branch name:', options)
+        branch_from = read_user_input_branch_from('Branch from:', options)
 
-          puts "Branch #{branch_name} has been created"
-          return
-        rescue Veto::InvalidEntity => e
-          puts "Unable to create branch due to the following errors"
-          e.message.each do |key, value|
-            puts "#{key}: #{value}"
-          end
-          return
+        branch = Toolshed::Git::Branch.new(from_remote_branch_name: branch_from, to_remote_branch_name: branch_name) # rubocop:disable Metrics/LineLength
+        branch.create
+        Toolshed.die
+      rescue Veto::InvalidEntity => e
+        Toolshed.logger.fatal 'Unable to create branch due to the following errors' # rubocop:disable Metrics/LineLength
+        e.message.each do |key, value|
+          Toolshed.logger.fatal "#{key}: #{value}"
         end
+        Toolshed.die
       end
 
       def read_user_input_branch_name(message, options)
-        return options[:branch_name] if (options.has_key?(:branch_name))
+        return options[:branch_name] if options.key?(:branch_name)
 
         puts message
         value = $stdin.gets.chomp
 
-        until (!value.empty?)
-          puts "Branch name cannot be empty"
+        while value.empty?
+          puts 'Branch name cannot be empty'
           puts message
           value = $stdin.gets.chomp
         end
@@ -42,18 +49,16 @@ module Toolshed
       end
 
       def read_user_input_branch_from(message, options)
-        return options[:branch_from] if (options.has_key?(:branch_from))
+        return options[:branch_from] if options.key?(:branch_from)
 
         # if branch-name was supplied then default to master if not supplied
-        if (options.has_key?(:branch_name))
-          return Toolshed::Git::DEFAULT_BRANCH_FROM
-        end
+        return Toolshed::Git::DEFAULT_BRANCH_FROM if options.key?(:branch_name)
 
         puts message
         value = $stdin.gets.chomp
 
-        until (!value.empty?)
-          puts "Branch from cannot be empty"
+        while value.empty?
+          puts 'Branch from cannot be empty'
           puts message
           value = $stdin.gets.chomp
         end

data/lib/toolshed/commands/create_pivotal_tracker_note.rb

@@ -1,11 +1,17 @@
+require 'toolshed/git'
+
 module Toolshed
   module Commands
     class CreatePivotalTrackerNote
+      def branch
+        @branch ||= Toolshed::Git::Branch.new
+      end
+
       def execute(args, options = {})
-        print "Project ID (Default: #{Toolshed::Client.default_pivotal_tracker_project_id})? "
+        print "Project ID (Default: #{Toolshed::Client.instance.default_pivotal_tracker_project_id})? "
         project_id = $stdin.gets.chomp.strip
         if (project_id == '')
-          project_id = Toolshed::Client.default_pivotal_tracker_project_id
+          project_id = Toolshed::Client.instance.default_pivotal_tracker_project_id
         end
 
         pivotal_tracker = Toolshed::TicketTracking::PivotalTracker.new({
@@ -14,7 +20,7 @@ module Toolshed
             password: Toolshed::TicketTracking::PivotalTracker.password,
         })
 
-        default_story_id = Toolshed::TicketTracking::PivotalTracker::story_id_from_branch_name(Toolshed::Git::Base.branch_name)
+        default_story_id = Toolshed::TicketTracking::PivotalTracker::story_id_from_branch_name(branch.branch_name)
         print "Story ID (Default: #{default_story_id})? "
         story_id = $stdin.gets.chomp.strip
         if (story_id == '')

data/lib/toolshed/commands/create_pull_request.rb

@@ -1,36 +1,70 @@
 require 'toolshed/commands/base'
+require 'toolshed/git'
+require 'toolshed/git/github'
 
 module Toolshed
   module Commands
-    class CreatePullRequest < Base
+    # Allow a user to create pull request based on information in .toolshedrc and prompts
+    class CreatePullRequest < Toolshed::Commands::Base # rubocop:disable ClassLength, LineLength
       attr_accessor :ticket_tracking_url, :ticket_tracking_title,
                     :ticket_id, :ticket_tracker,
                     :ticket_tracker_class, :ticket_tracker_project_id,
                     :pull_request_url, :git_tool,
                     :pull_request_title, :pull_request_body
 
-      def initialize(options={})
+      def initialize(options = {})
         super(options)
         self.ticket_tracker_class = nil
         self.pull_request_url = ''
       end
 
-      def execute(args, options = {})
+      def self.cli_options # rubocop:disable Metrics/MethodLength
+        {
+          banner: 'Usage: push_branch [options]',
+          options: {
+            tool: {
+              short_on: '-a'
+            },
+            ticket_system: {
+              short_on: '-m'
+            },
+            use_defaults: {
+              short_on: '-d'
+            },
+            title: {
+              short_on: '-t'
+            },
+            body: {
+              short_on: '-b'
+            },
+            skip_ticket: {
+              short_on: '-s',
+              default: true
+            }
+          }
+        }
+      end
+
+      def branch
+        @branch ||= Toolshed::Git::Branch.new
+      end
+
+      def execute(_args, options = {})
         output_begining_messages
         options = execute_ticket_tracking(options)
-        options = execute_pull_request(options) unless options.nil?
+        execute_pull_request(options) unless options.nil?
       end
 
       private
 
         def read_user_input_add_note_to_ticket(message)
-          return true if Toolshed::Client.use_defaults
+          return true if Toolshed::Client.instance.use_defaults
 
           puts message
           value = $stdin.gets.chomp
 
           until %w(y n).include?(value.downcase)
-            puts "Value must be Y or N"
+            puts 'Value must be Y or N'
             puts message
             value = $stdin.gets.chomp
           end
@@ -43,103 +77,116 @@ module Toolshed
         end
 
         def output_begining_messages
-          puts "Current Branch: #{Toolshed::Git::Base.branch_name}"
-          puts "Branched From: #{Toolshed::Git::Base.branched_from}"
-          puts "Using Defaults: #{(Toolshed::Client.use_defaults.nil?) ? 'No' : 'Yes'}"
+          Toolshed.logger.info "Current Branch: #{branch.name}"
+          Toolshed.logger.info "Branched From: #{Toolshed::Git::Branch.from}"
+          Toolshed.logger.info "Using Defaults: #{(Toolshed::Client.instance.use_defaults.nil?) ? 'No' : 'Yes'}" # rubocop:disable Metrics/LineLength
         end
 
         def get_ticket_id(options)
           self.ticket_id = read_user_input_ticket_tracker_ticket_id(
-            "Ticket ID (Default: #{Toolshed::TicketTracking::story_id_from_branch_name(Toolshed::Git::Base.branch_name)}):", {
-              default: Toolshed::TicketTracking::story_id_from_branch_name(Toolshed::Git::Base.branch_name),
-            }
+            "Ticket ID (Default: #{Toolshed::TicketTracking.story_id_from_branch_name(branch.name)}):", # rubocop:disable Metrics/LineLength
+            default: Toolshed::TicketTracking.story_id_from_branch_name(branch.name)
           )
-          options.merge!({
-            ticket_id: self.ticket_id,
-          })
+          options.merge!(ticket_id: ticket_id)
           options
         end
 
         def output_ticket_information
-          puts "Ticket Tracking URL: #{ticket_tracking_url}"
-          puts "Ticket Tracking title: #{ticket_tracking_title}"
-          puts "Ticket ID: #{ticket_id}"
+          Toolshed.logger.info "Ticket Tracking URL: #{ticket_tracking_url}"
+          Toolshed.logger.info "Ticket Tracking title: #{ticket_tracking_title}"
+          Toolshed.logger.info "Ticket ID: #{ticket_id}"
         end
 
-        def execute_ticket_tracking(options)
-          unless Toolshed::Client.ticket_tracking_tool.nil? || Toolshed::Client.ticket_tracking_tool.empty?
-            begin
-              self.ticket_tracker_class =  Object.const_get("Toolshed::TicketTracking::#{Toolshed::Client.ticket_tracking_tool.camel_case}")
-              options = get_ticket_project_information(options)
-              initialize_ticket_tracker_properties(options)
-
-              output_ticket_information
-            rescue Exception => e
-              puts e.inspect
-              puts e.backtrace
-              puts "Ticket tracking tool is not supported at this time"
-              return
-            end
-            options
+        def execute_ticket_tracking(options) # rubocop:disable Metrics/AbcSize
+          return options if options[:skip_ticket]
+          return options if Toolshed::Client.instance.ticket_tracking_tool.nil? || Toolshed::Client.instance.ticket_tracking_tool.empty? # rubocop:disable Metrics/LineLength
+
+          begin
+            self.ticket_tracker_class =  Object.const_get("Toolshed::TicketTracking::#{Toolshed::Client.instance.ticket_tracking_tool.camel_case}") # rubocop:disable Metrics/LineLength
+            options = get_ticket_project_information(options)
+            initialize_ticket_tracker_properties(options)
+            output_ticket_information
+          rescue StandardError => e
+            Toolshed.logger.fatal e.inspect
+            Toolshed.logger.fatal e.backtrace
+            Toolshed.logger.fatal 'Ticket tracking tool is not supported at this time'
+            Toolshed.die
           end
+
           options
         end
 
         def add_note_to_ticket
-          add_note_to_ticket_response = read_user_input_add_note_to_ticket(
-            "Would you like to add a note with the pull request url?"
-          )
-          if add_note_to_ticket_response
-            result = self.ticket_tracker.add_note(pull_request_url)
-            default_completed_status = Object.const_get("#{ticket_tracker_class}::DEFAULT_COMPLETED_STATUS") rescue false
-            default_completed_status = Toolshed::Client.ticket_status_for_complete unless default_completed_status
-            ticket_tracker.update_ticket_status(default_completed_status)
+          add_note_to_ticket_response = read_user_input_add_note_to_ticket('Would you like to add a note with the pull request url?') # rubocop:disable Metrics/LineLength
+          return unless add_note_to_ticket_response
+
+          ticket_tracker.add_note(pull_request_url)
+          completed_status = Toolshed::Client.instance.ticket_status_for_complete unless default_completed_status # rubocop:disable Metrics/LineLength
+          ticket_tracker.update_ticket_status(completed_status)
+        end
+
+        def default_completed_status
+          default_completed_status = nil
+          begin
+            default_completed_status = Object.const_get("#{ticket_tracker_class}::DEFAULT_COMPLETED_STATUS") # rubocop:disable Metrics/LineLength
+          rescue
+            false
           end
+          default_completed_status
         end
 
         def pull_request_created_message
-          puts "Created Pull Request: #{pull_request_url}"
+          Toolshed.logger.info "Created Pull Request: #{pull_request_url}"
         end
 
-        def execute_pull_request(options)
-          begin
-            self.git_tool = Object.const_get("Toolshed::Git::#{Toolshed::Client.git_tool.camel_case}").create_instance
-
-            options = set_pull_request_title(options)
-            options = set_pull_request_body(options)
-            send_pull_request
-            add_note_to_ticket unless ticket_tracker_class.nil?
-            pull_request_created_message
-          rescue => e
-            puts e.message
-            exit
-          end
+        def execute_pull_request(options) # rubocop:disable Metrics/AbcSize
+          self.git_tool = Object.const_get("Toolshed::Git::#{Toolshed::Client.instance.git_tool.camel_case}").create_instance # rubocop:disable Metrics/LineLength
+
+          options = get_pull_request_title(options)
+          get_pull_request_body(options)
+          send_pull_request
+          add_note_to_ticket unless ticket_tracker_class.nil?
+          pull_request_created_message
+          self
+        rescue => e
+          Toolshed.logger.fatal e.message
+          Toolshed.die
         end
 
-        def set_pull_request_title(options)
+        def get_pull_request_title(options)
           self.pull_request_title = read_user_input_title(
-            "Pull request title (Default: #{self.ticket_tracking_title}):",
-            options.merge!({
-              default: self.ticket_tracking_title,
-            })
+            "Pull request title (Default: #{ticket_tracking_title}):",
+            options.merge!(default: ticket_tracking_title)
           )
           options
         end
 
-        def set_pull_request_body(options)
+        def get_pull_request_body(options)
           self.pull_request_body = read_user_input_body(
-            "Pull request body (Default: #{self.ticket_tracking_url}):",
-            options.merge!({
-              default: self.ticket_tracking_url
-            })
+            "Pull request body (Default: #{ticket_tracking_url}):",
+            options.merge!(default: ticket_tracking_url)
           )
           options
         end
 
         def send_pull_request
-          puts "Pull request being created"
-          git_pull_request_result = self.git_tool.create_pull_request(pull_request_title, pull_request_body)
-          self.pull_request_url = git_pull_request_result["html_url"]
+          Toolshed.logger.info 'Your pull request is being created.'
+          git_pull_request_result = git_tool.create_pull_request(pull_request_title, pull_request_body) # rubocop:disable Metrics/LineLength
+
+          self.pull_request_url = git_pull_request_result['html_url']
+          return if git_pull_request_result['message'].nil?
+
+          if git_pull_request_result['message'].downcase == 'bad credentials'
+            Toolshed.logger.fatal 'Bad Credentials please try again.'
+            Toolshed.die
+          end
+
+          if git_pull_request_result['message'].downcase == 'not found'
+            Toolshed.logger.fatal 'Pull request not found please try again.'
+            Toolshed.die
+          end
+
+          self.pull_request_url = git_pull_request_result['html_url']
         end
 
         def get_ticket_project_information(options)

data/lib/toolshed/commands/create_ticket_comment.rb

@@ -1,4 +1,5 @@
 require 'toolshed/commands/base'
+require 'toolshed/git'
 
 module Toolshed
   module Commands
@@ -8,13 +9,28 @@ module Toolshed
         super(options)
       end
 
+      def self.cli_options
+        {
+          banner: 'Usage: create_ticket_comment [options]',
+          options: {
+            use_defaults: {
+              short_on: '-d'
+            }
+          }
+        }
+      end
+
+      def branch
+        @branch ||= Toolshed::Git::Branch.new
+      end
+
       def execute(args, options = {})
         ticket_tracker_class =  Object.const_get("Toolshed::TicketTracking::#{Toolshed::Client.ticket_tracking_tool.camel_case}")
 
         options = use_ticket_tracker_project_id(options)
         options = use_ticket_tracker_project_name(options)
 
-        default_ticket_id = Toolshed::TicketTracking::story_id_from_branch_name(Toolshed::Git::Base.branch_name)
+        default_ticket_id = Toolshed::TicketTracking::story_id_from_branch_name(branch.name)
         ticket_id = read_user_input("Ticket ID (Default: #{default_ticket_id}):", options.merge!({ default: default_ticket_id }))
         options.merge!({ ticket_id: ticket_id })
 

data/lib/toolshed/commands/delete_branch.rb

@@ -1,11 +1,32 @@
+require 'toolshed/git'
+
+require 'highline/import'
+
 module Toolshed
   module Commands
     class DeleteBranch
+      attr_accessor :branch
+
+      def self.cli_options
+        {
+          banner: 'Usage: delete_branch [options]',
+          options: {
+            branch_name: {
+              short_on: '-b',
+            }
+          }
+        }
+      end
+
       def execute(args, options = {})
         branch_name = read_user_input("Ticket ID or branch name:", options)
-        branch_name = Toolshed::Git::Base.delete(branch_name)
-        puts "#{branch_name} has been deleted"
-        return
+        self.branch = Toolshed::Git::Branch.new(branch_name: branch_name)
+        if confirm_delete
+          branch.delete(branch_name)
+        else
+          Toolshed.logger.info "Branch '#{branch.name}' was not deleted."
+        end
+        Toolshed.die
       end
 
       def read_user_input(message, options)
@@ -22,6 +43,16 @@ module Toolshed
 
         value
       end
+
+      def confirm_delete
+        choices = "yn"
+        answer = ask("Are you sure you want to delete #{branch.name} [#{choices}]? ") do |q|
+          q.echo      = false
+          q.character = true
+          q.validate  = /\A[#{choices}]\Z/
+        end
+        answer == 'y'
+      end
     end
   end
 end