toolshed 0.0.5 → 0.0.6

data/lib/toolshed/commands/create_pull_request.rb

@@ -0,0 +1,137 @@
+module Toolshed
+  module Commands
+    class CreatePullRequest
+      def execute(args, options = {})
+        # see what branch is checked out and where we are branched from
+        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'}"
+
+        unless (Toolshed::Client.ticket_tracking_tool.empty?)
+          ticket_tracking_url = ''
+          ticket_tracking_title = ''
+          ticket_id = ''
+
+          begin
+            ticket_tracker_class =  Object.const_get("Toolshed::TicketTracking::#{Toolshed::Client.ticket_tracking_tool.camel_case}")
+
+            if Object.const_get("#{ticket_tracker_class}::USE_PROJECT_ID")
+              ticket_tracker_project_id = read_user_input_ticket_tracker_project_id("Project ID (Default: #{Toolshed::Client.default_pivotal_tracker_project_id}):", { default: Toolshed::Client.default_pivotal_tracker_project_id })
+              options.merge!({ project_id: ticket_tracker_project_id })
+            end
+
+            ticket_tracker = ticket_tracker_class.create_instance(options)
+
+            # @TODO - refactor this code into the git module seems more appropriate since it's performing git functions
+            ticket_id = read_user_input_ticket_tracker_ticket_id("Ticket ID (Default: #{Toolshed::TicketTracking::PivotalTracker::story_id_from_branch_name(Toolshed::Git::Base.branch_name)}):", { default: Toolshed::TicketTracking::PivotalTracker::story_id_from_branch_name(Toolshed::Git::Base.branch_name) })
+            ticket_information = ticket_tracker.story_information(ticket_id)
+
+            ticket_tracking_url = ticket_information.url
+            ticket_tracking_title = ticket_tracker_class.clean(ticket_information.name)
+            ticket_id = ticket_information.id
+
+            puts "Ticket Tracking URL: #{ticket_tracking_url}"
+            puts "Ticket Tracking title: #{ticket_tracking_title}"
+            puts "Ticket ID: #{ticket_id}"
+          rescue
+            puts "Ticket tracking tool is not supported at this time"
+            return
+          end
+        end
+
+        pull_request_url = ''
+        begin
+          git_tool_class = Object.const_get("Toolshed::Git::#{Toolshed::Client.git_tool.camel_case}")
+          git_tool = git_tool_class.create_instance
+
+          # create the pull request prompt when needed
+          title = read_user_input_pull_request_title("Pull request title (Default: #{ticket_tracking_title}):", options.merge!({ :default => ticket_tracking_title }))
+          body = read_user_input_pull_request_body("Pull request body (Default: #{ticket_tracking_url}):", options.merge!({ :default => ticket_tracking_url }))
+
+          puts "Pull request being created"
+          git_pull_request_result = git_tool.create_pull_request(title, body)
+          pull_request_url = git_pull_request_result["html_url"]
+
+          add_note_to_ticket = read_user_input_add_note_to_ticket("Would you like to add a note with the pull request url?")
+          if (add_note_to_ticket)
+            result = ticket_tracker.add_note(ticket_id, pull_request_url)
+            result = ticket_tracker.update_ticket_status(ticket_id, Object.const_get("#{ticket_tracker_class}::DEFAULT_COMPLETED_STATUS"))
+          end
+
+          puts "Created Pull Request: #{pull_request_url}"
+        rescue => e
+          puts e.message
+          exit
+        end
+      end
+
+      def read_user_input_add_note_to_ticket(message)
+        return true if (Toolshed::Client.use_defaults)
+
+        puts message
+        value = $stdin.gets.chomp
+
+        until (%w(y n).include?(value.downcase))
+          puts "Value must be Y or N"
+          puts message
+          value = $stdin.gets.chomp
+        end
+
+        (value == 'y') ? true : false
+      end
+
+      def read_user_input_pull_request_title(message, options)
+        return options[:title] if (options.has_key?(:title))
+        return options[:default] if (Toolshed::Client.use_defaults)
+
+        puts message
+        value = $stdin.gets.chomp
+        if (value.empty?)
+          value = default
+        end
+
+        value
+      end
+
+      def read_user_input_pull_request_body(message, options)
+        return options[:body] if (options.has_key?(:body))
+        return options[:default] if (Toolshed::Client.use_defaults)
+
+        puts message
+        value = $stdin.gets.chomp
+
+        if (value.empty?)
+          value = default
+        end
+
+        value
+      end
+
+      def read_user_input_ticket_tracker_project_id(message, options)
+        return options[:default] if (Toolshed::Client.use_defaults)
+
+        puts message
+        value = $stdin.gets.chomp
+
+        if (value.empty?)
+          value = default
+        end
+
+        value
+      end
+
+      def read_user_input_ticket_tracker_ticket_id(message, options)
+        return options[:default] if (Toolshed::Client.use_defaults)
+
+        puts message
+        value = $stdin.gets.chomp
+
+        if (value.empty?)
+          value = default
+        end
+
+        value
+      end
+    end
+  end
+end

data/lib/toolshed/commands/delete_branch.rb

@@ -0,0 +1,27 @@
+module Toolshed
+  module Commands
+    class DeleteBranch
+      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
+      end
+
+      def read_user_input(message, options)
+        return options[:branch_name] if (options.has_key?(:branch_name))
+
+        puts message
+        value = $stdin.gets.chomp
+
+        until (!value.empty?)
+          puts "Branch name cannot be empty"
+          puts message
+          value = $stdin.gets.chomp
+        end
+
+        value
+      end
+    end
+  end
+end

data/lib/toolshed/commands/get_daily_time_update.rb

@@ -0,0 +1,21 @@
+module Toolshed
+  module Commands
+    class GetDailyTimeUpdate
+      def execute(args, options = {})
+        if (Toolshed::Client.time_tracking_tool == 'harvest')
+          harvest = Toolshed::TimeTracking::Harvest.new
+
+          puts "Getting time entries:"
+          
+          notes = harvest.previous
+          notes = "#{notes}\n\n#{harvest.today}"
+
+          puts notes
+        else
+          puts "Time tracking tool is undefined implementation needed"
+          exit
+        end
+      end
+    end
+  end
+end

data/lib/toolshed/commands/get_pivotal_tracker_story_information.rb

@@ -9,10 +9,13 @@ module Toolshed
             project_id = Toolshed::Client.default_pivotal_tracker_project_id
           end
 
-          pivotal_tracker = Toolshed::PivotalTracker.new({ project_id: project_id, username: Toolshed::PivotalTracker.username, password: Toolshed::PivotalTracker.password })
-          github = Toolshed::Github.new
+          pivotal_tracker = Toolshed::TicketTracking::PivotalTracker.new({
+              project_id: project_id,
+              username: Toolshed::TicketTracking::PivotalTracker.username,
+              password: Toolshed::TicketTracking::PivotalTracker.password,
+          })
 
-          default_story_id = Toolshed::PivotalTracker::story_id_from_branch_name(github.branch_name)
+          default_story_id = Toolshed::TicketTracking::PivotalTracker::story_id_from_branch_name(Toolshed::Git::Base.branch_name)
           print "Story ID (Default: #{default_story_id})? "
           story_id = $stdin.gets.chomp.strip
           if (story_id == '')

data/lib/toolshed/commands/list_branches.rb

@@ -0,0 +1,13 @@
+module Toolshed
+  module Commands
+    class ListBranches
+      def execute(args, options = {})
+        git = Toolshed::Git::Github.new
+        branches = git.list_branches
+        branches.each do |branch|
+          puts branch['name']
+        end
+      end
+    end
+  end
+end

data/lib/toolshed/commands/push_branch.rb

@@ -0,0 +1,11 @@
+module Toolshed
+  module Commands
+    class PushBranch
+      def execute(args, options = {})
+        branch_name = Toolshed::Git::Base.push(options)
+        puts "#{branch_name} has been pushed"
+        return
+      end
+    end
+  end
+end

data/lib/toolshed/commands/update_pivotal_tracker_story_status.rb

@@ -10,20 +10,23 @@ module Toolshed
           project_id = Toolshed::Client.default_pivotal_tracker_project_id
         end
 
-        pivotal_tracker = Toolshed::PivotalTracker.new({ project_id: project_id, username: Toolshed::PivotalTracker.username, password: Toolshed::PivotalTracker.password })
-        github = Toolshed::Github.new
+        pivotal_tracker = Toolshed::TicketTracking::PivotalTracker.new({
+            project_id: project_id,
+            username: Toolshed::TicketTracking::PivotalTracker.username,
+            password: Toolshed::TicketTracking::PivotalTracker.password,
+        })
 
-        default_story_id = Toolshed::PivotalTracker::story_id_from_branch_name(github.branch_name)
+        default_story_id = Toolshed::TicketTracking::PivotalTracker::story_id_from_branch_name(Toolshed::Git::Base.branch_name)
         print "Story ID (Default: #{default_story_id})? "
         story_id = $stdin.gets.chomp.strip
         if (story_id == '')
           story_id = default_story_id
         end
 
-        print "Status (Default: #{Toolshed::PivotalTracker::STORY_STATUS_DEFAULT})? "
+        print "Status (Default: #{Toolshed::TicketTracking::PivotalTracker::STORY_STATUS_DEFAULT})? "
         story_status = $stdin.gets.chomp.strip
         if (story_status == '')
-          story_status = Toolshed::PivotalTracker::STORY_STATUS_DEFAULT
+          story_status = Toolshed::TicketTracking::PivotalTracker::STORY_STATUS_DEFAULT
         end
 
         begin

data/lib/toolshed/git/git.rb

@@ -0,0 +1,134 @@
+module Toolshed
+  module Git
+    DEFAULT_GIT_TOOL = 'github'
+
+    def branch_name
+      # branch information
+      branch_name = `git rev-parse --abbrev-ref HEAD`.strip
+    end
+
+    def branched_from
+      branched_from = `git rev-parse --abbrev-ref --symbolic-full-name @{u}`.split('/')[-1].strip
+    end
+
+    def branch_name_from_id(id)
+      branch_name = `git branch | grep \"#{id}\"`.gsub("*", "").strip
+    end
+
+    def checkout(branch_name)
+      branch_name = Toolshed::Git::Base.branch_name_from_id(branch_name)
+      until system("git checkout #{branch_name} #{Toolshed::Client.git_quiet}")
+        sleep 1
+      end
+
+      unless (Toolshed::Git::Base.git_submodule_command.empty?)
+        until system(Toolshed::Git::Base.git_submodule_command)
+          sleep 1
+        end
+      end
+
+      branch_name
+    end
+
+    def delete(branch_name)
+      branch_name = Toolshed::Git::Base.branch_name_from_id(branch_name)
+
+      # if delete your current branch checkout master so it can be deleted
+      if (branch_name == Toolshed::Git::Base.branch_name)
+        Toolshed::Git::Base.checkout('master')
+      end
+
+      until system("git push #{Toolshed::Client.push_to_remote_name} :#{branch_name}; git branch -D #{branch_name}")
+        sleep 1
+      end
+
+      branch_name
+    end
+
+    def git_submodule_command
+      git_submodule_command = ''
+      if (Toolshed::Client.use_git_submodules)
+        git_submodule_command = "git submodule update #{Toolshed::Client.git_quiet}"
+      end
+
+      git_submodule_command
+    end
+
+    def clean_branch_name(branch_name)
+      branch_name.strip.downcase.tr(" ", "_").gsub("-", "").gsub("&", "").gsub("/", "_").gsub(".", "_").gsub("'", "").gsub("__", "_").gsub(":", "")
+    end
+
+    def push(options = {})
+      branch_name = (options.has_key?(:branch_name)) ? Toolshed::Git::Base.branch_name_from_id(options[:branch_name]) : Toolshed::Git::Base.branch_name
+      force_command = (options.has_key?(:force_command)) ? '--force' : ''
+
+      until system("git push #{Toolshed::Client.push_to_remote_name} #{branch_name} #{force_command}")
+        sleep 1
+      end
+
+      branch_name
+    end
+
+    class GitValidator
+      include Veto.validator
+
+      validates :from_remote_name,        :presence => true
+      validates :from_remote_branch_name, :presence => true
+      validates :to_remote_name,          :presence => true
+      validates :to_remote_branch_name,   :presence => true
+    end
+
+    class Base
+      extend Toolshed::Git
+
+      attr_accessor :from_remote_name, :from_remote_branch_name, :to_remote_name, :to_remote_branch_name, :validator
+
+      def initialize(options={})
+        # options with defaults
+        self.from_remote_name = Toolshed::Client.pull_from_remote_name
+        unless (options[:from_remote_name].nil?)
+         self.from_remote_name  = options[:from_remote_name]
+        end
+
+        self.to_remote_name = Toolshed::Client.push_to_remote_name
+        unless (options[:to_remote_name].nil?)
+         self.to_remote_name = options[:to_remote_name]
+        end
+
+        # options that do not have a default
+        unless (options[:from_remote_branch_name].nil?)
+         self.from_remote_branch_name = options[:from_remote_branch_name]
+        end
+
+        unless (options[:to_remote_branch_name].nil?)
+         self.to_remote_branch_name = options[:to_remote_branch_name]
+        end
+
+        self.validator = ::Toolshed::Git::GitValidator.new
+      end
+
+      def create_branch
+        self.validator.validate!(self)
+
+        new_branch_name = Toolshed::Git::Base.clean_branch_name(self.to_remote_branch_name)
+        until system("git remote update #{Toolshed::Client.git_quiet}")
+          sleep 1
+        end
+
+        until system("git checkout -b #{new_branch_name} #{self.from_remote_name}/#{self.from_remote_branch_name} #{Toolshed::Client.git_quiet}")
+          sleep 1
+        end
+
+        unless (Toolshed::Git::Base.git_submodule_command.empty?)
+          until system(Toolshed::Git::Base.git_submodule_command)
+            sleep 1
+          end
+        end
+
+        until system("git push #{self.to_remote_name} #{new_branch_name} #{Toolshed::Client.git_quiet}")
+          sleep 1
+        end
+      end
+    end
+  end
+end

data/lib/toolshed/git/github.rb

@@ -0,0 +1,88 @@
+module Toolshed
+  module Git
+    class Github < Base
+      extend Toolshed::Git
+      include HTTParty
+
+      attr_accessor :default_options
+
+      def initialize(options={})
+        super(options)
+
+        username = Toolshed::Client::github_username
+        password = Toolshed::Client::github_password
+
+        unless (options[:username].nil?)
+          username = options[:username]
+        end
+
+        unless (options[:password].nil?)
+           password = options[:password]
+        end
+
+        @auth = { username: username, password: password }
+        self.default_options = {
+          :headers => {
+              "User-Agent" => "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_2) AppleWebKit/537.17 (KHTML, like Gecko) Chrome/24.0.1309.0 Safari/537.17"
+          },
+          basic_auth: @auth,
+        }
+      end
+
+      def create_pull_request(title, body, options={})
+        options.merge!(self.default_options)
+        options.merge!({
+          body: {
+            title: title,
+             body: body,
+             head: "#{Toolshed::Client.github_username}:#{Toolshed::Git::Base.branch_name}",
+             base: Toolshed::Git::Base.branched_from
+          }.to_json
+        })
+
+        response = HTTParty.post("#{Toolshed::Client::GITHUB_BASE_API_URL}repos/#{Toolshed::Client.pull_from_repository_user}/#{Toolshed::Client.pull_from_repository_name}/pulls", options).response
+        response = JSON.parse(response.body)
+        if (response["errors"].nil?)
+          response
+        else
+          raise "validation errors #{response.inspect}"
+        end
+      end
+
+      def list_branches(options={})
+        options.merge!(self.default_options)
+
+        response = HTTParty.get("#{Toolshed::Client::GITHUB_BASE_API_URL}repos/#{Toolshed::Client.github_username}/#{Toolshed::Client.pull_from_repository_name}/branches", options).response
+        response = JSON.parse(response.body)
+      end
+
+      def self.username
+        username = Toolshed::Client::github_username
+        if (username.nil?)
+          # prompt to ask for username
+          puts "Github username? "
+          username = $stdin.gets.chomp.strip
+        end
+
+        return username
+      end
+
+      def self.password
+        password = Toolshed::Client::github_password
+        if (password.nil?)
+          # prompt to ask for password
+          system "stty -echo"
+          puts "Github password? "
+          password = $stdin.gets.chomp.strip
+          system "stty echo"
+        end
+
+        return password
+      end
+
+      def self.create_instance
+        Toolshed::Git::Github.new({ username: Toolshed::Git::Github.username, password: Toolshed::Git::Github.password })
+      end
+    end
+  end
+end

data/lib/toolshed/ticket_tracking/pivotal_tracker.rb

@@ -0,0 +1,111 @@
+module Toolshed
+  module TicketTracking
+    class PivotalTracker
+      extend TicketTracking
+      include HTTParty
+
+      DEFAULT_COMPLETED_STATUS = 'finished'
+      USE_PROJECT_ID = true
+
+      attr_accessor :project_id, :token
+
+      def initialize(options={})
+        username = Toolshed::Client::pivotal_tracker_username
+        password = Toolshed::Client::pivotal_tracker_password
+
+        unless (options[:username].nil?)
+          username = options[:username]
+        end
+
+        unless (options[:password].nil?)
+           password = options[:password]
+        end
+
+        self.token = ::PivotalTracker::Client.token(username, password)
+
+        self.project_id = (options[:project_id].nil?) ? Toolshed::Client.default_pivotal_tracker_project_id : options[:project_id]
+        @pt_project = ::PivotalTracker::Project.find(self.project_id)
+      end
+
+      #
+      # Instance methods
+      #
+      def story_information(story_id)
+        return @pt_project.stories.find(story_id)
+      end
+
+      def add_note(story_id, note_text)
+        story = @pt_project.stories.find(story_id)
+        results = story.notes.create(text: note_text)
+      end
+
+      def update_ticket_status(story_id, current_state, options={})
+        options.merge!({
+          :headers => {
+              "X-TrackerToken"  => self.token,
+              "User-Agent"      => "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_2) AppleWebKit/537.17 (KHTML, like Gecko) Chrome/24.0.1309.0 Safari/537.17",
+              "Content-Type"    => "application/json",
+          },
+          body: {
+            current_state: current_state
+          }.to_json
+        })
+
+        response = HTTParty.put("#{Toolshed::Client::PIVOTAL_TRACKER_BASE_API_URL}projects/#{self.project_id}/stories/#{story_id}", options).response
+        response = JSON.parse(response.body)
+
+        if (response["error"].nil?)
+          response
+        else
+          raise "validation errors #{response.inspect}"
+        end
+      end
+
+      #
+      # Class methods
+      #
+      def self.story_id_from_branch_name(branch_name)
+        story_id = branch_name.split("_")[0]
+      end
+
+      def self.username
+        username = Toolshed::Client::pivotal_tracker_username
+        if (username.nil?)
+          # prompt to ask for username
+          puts "PivotalTracker username? "
+          username = $stdin.gets.chomp.strip
+        end
+
+        return username
+      end
+
+      def self.password
+        password = Toolshed::Client::pivotal_tracker_password
+        if (password.nil?)
+          # prompt to ask for password
+          system "stty -echo"
+          puts "PivotalTracker password? "
+          password = $stdin.gets.chomp.strip
+          system "stty echo"
+        end
+
+        return password
+      end
+
+      #
+      # Get the pivotal tracker object based off of the project_id
+      #
+      def self.create_instance(options={})
+        unless (options.has_key?(:project_id))
+          raise 'Unable to use PivotalTracker as project id was not supplied'
+        end
+
+        pivotal_tracker = Toolshed::TicketTracking::PivotalTracker.new({ project_id: options[:project_id], username: Toolshed::TicketTracking::PivotalTracker.username, password: Toolshed::TicketTracking::PivotalTracker.password })
+      end
+
+      def self.clean(title)
+        title.gsub("'", "").gsub("\"", "")
+      end
+    end
+  end
+end

data/lib/toolshed/ticket_tracking/ticket_tracking.rb

@@ -0,0 +1,6 @@
+module Toolshed
+  module TicketTracking
+    def initialize(options={})
+    end
+  end
+end

data/lib/toolshed/time_tracking/harvest.rb

@@ -0,0 +1,68 @@
+module Toolshed
+  module TimeTracking
+    class Harvest
+      extend TimeTracking
+
+      MAX_ATTEMPTS = 10
+
+      attr_accessor :harvest_client, :project_id
+
+      def initialize(options={})
+        username = Toolshed::Client::time_tracking_username
+        password = Toolshed::Client::time_tracking_password
+        owner = Toolshed::Client.time_tracking_owner
+
+        unless (options[:username].nil?)
+          username = options[:username]
+        end
+
+        unless (options[:password].nil?)
+           password = options[:password]
+        end
+
+        unless (options[:sub_domain].nil?)
+           owner = options[:sub_domain]
+        end
+
+        self.harvest_client = ::Harvest.client('ackmanndickenson', 'jwaller@ackmanndickenson.com', 'V0AU2gRMLhs1')
+        self.project_id = self.get_project_id
+      end
+
+      def previous(days_ago=1)
+        notes = "Previous:\n\n"
+
+        time_entries = self.harvest_client.time.all((DateTime.now - days_ago), self.project_id)
+        if (time_entries.size > 0 || days_ago == Toolshed::TimeTracking::Harvest::MAX_ATTEMPTS)
+          time_entries.each do |time_entry|
+            notes = "#{notes}#{time_entry.notes}\n"
+          end
+        else
+          notes = self.previous(days_ago + 1)
+        end
+
+        notes
+      end
+
+      def today
+        notes = "Today:\n\n"
+
+        time_entries = self.harvest_client.time.all(Time.now, self.project_id)
+        time_entries.each do |time_entry|
+          notes = "#{notes}#{time_entry.notes}\n"
+        end
+
+        notes
+      end
+
+      def get_project_id
+        print "Project ID (Default: #{Toolshed::Client.time_tracking_default_project_id})? "
+        project_id = $stdin.gets.chomp.strip
+        if (project_id == '')
+          project_id = Toolshed::Client.time_tracking_default_project_id
+        end
+
+        project_id
+      end
+    end
+  end
+end

data/lib/toolshed/time_tracking/time_tracking.rb

@@ -0,0 +1,6 @@
+module Toolshed
+  module TimeTracking
+    def initialize(options={})
+    end
+  end
+end

data/lib/toolshed/version.rb

@@ -1,3 +1,3 @@
 module Toolshed
-  VERSION = "0.0.5"
+  VERSION = "0.0.6"
 end