toolshed 1.0.2 → 1.0.3

data/lib/toolshed/git/branch.rb

@@ -0,0 +1,224 @@
+require 'toolshed/git'
+
+module Toolshed
+  class Git
+    class Branch < Toolshed::Git
+      def initialize(options = {})
+        super(options)
+      end
+
+      # class methods
+
+      class << self
+        def ask_which_branch(branch_names)
+          selected_branch_name = ''
+          choose do |menu|
+            menu.prompt = "Multiple branches matched input branch name. Which branch are you looking for?  "
+
+            branch_names.each do |branch_name|
+              menu.choice(branch_name.to_sym, branch_name) do |branch_name|
+                selected_branch_name = branch_name
+              end
+            end
+          end
+          selected_branch_name.to_s
+        end
+
+        def from
+          `git rev-parse --abbrev-ref --symbolic-full-name @{u}`.split('/')[-1].strip
+        end
+
+        def checkout(checkout_branch_name)
+          Toolshed.logger.info ''
+          Toolshed.logger.info "Looking for branch #{checkout_branch_name}"
+          actual_branch_name = Toolshed::Git::Branch.name_from_substring(checkout_branch_name)
+          Toolshed.logger.info "Switching to branch #{actual_branch_name}"
+          result = Toolshed::Base.wait_for_command("git checkout #{actual_branch_name} #{Toolshed::Client.instance.git_quiet}")
+          if /.*Your local changes to the following files would be overwritten by checkout.*/.match(result[:stderr][0])
+            Toolshed.logger.fatal "Unable to checkout branch due to the following error(s) #{result[:all].join(', ')}"
+            Toolshed.die
+          end
+          Toolshed::Base.wait_for_command(Toolshed::Git.git_submodule_command) unless Toolshed::Git.git_submodule_command.empty?
+          Toolshed.logger.info "Switched to branch #{actual_branch_name}"
+          actual_branch_name
+        end
+
+        def name
+          branch = Toolshed::Git::Branch.new
+          branch.name
+        end
+
+        def name_from_substring(substring)
+          branches = Toolshed::Base.wait_for_command("git branch | grep \"#{substring}\"")
+          branch_names = branches[:all].map { |branch_name| branch_name.gsub('*', '').strip }
+
+          return substring if branch_names.length == 0
+          return branch_names.first if branch_names.length == 1
+          Toolshed::Git::Branch.ask_which_branch(branch_names)
+        end
+      end
+
+      # instance methods
+
+      def create
+        validator.validate!(self)
+        Toolshed.logger.info ''
+
+        new_branch_name = Toolshed::Git.clean_branch_name(to_remote_branch_name)
+        Toolshed.logger.info "Creating branch #{new_branch_name} from #{from_remote_name}/#{from_remote_branch_name}"
+
+        remote_update
+        results = Toolshed::Base.wait_for_command("git checkout -b #{new_branch_name} #{from_remote_name}/#{from_remote_branch_name} #{Toolshed::Client.instance.git_quiet}")
+        results[:all].each do |out|
+          if out.match(/.*fatal.*/)
+            Toolshed.logger.fatal out
+            Toolshed.die
+          else
+           Toolshed.logger.info out
+          end
+        end
+        Toolshed::Base.wait_for_command(Toolshed::Git.git_submodule_command) unless Toolshed::Git.git_submodule_command.empty?
+
+        Toolshed.logger.info ''
+        Toolshed.logger.info "Pushing branch #{new_branch_name} to #{from_remote_name}/#{from_remote_branch_name}."
+        self.passed_branch_name = new_branch_name
+        push
+
+        Toolshed.logger.info ''
+        Toolshed.logger.info "Branch #{new_branch_name} has been created from #{from_remote_name}/#{from_remote_branch_name}."
+      end
+
+      def delete(delete_branch_name)
+        actual_branch_name = Toolshed::Git::Branch.name_from_substring(delete_branch_name)
+        Toolshed.logger.info ''
+        Toolshed.logger.info "Deleting branch '#{actual_branch_name}'"
+        if actual_branch_name == name
+          Toolshed.logger.info 'Checking out master branch'
+          Toolshed.logger.info ''
+          Toolshed::Git::Branch.checkout('master')
+        end
+
+        delete_local(actual_branch_name)
+        delete_remote(actual_branch_name)
+        Toolshed.logger.info ''
+        Toolshed.logger.info "Deleted branch #{actual_branch_name}"
+      end
+
+      def delete_local(local_branch_name)
+        unless local.map { |local_branch| local_branch[:branch_name] }.include?(local_branch_name)
+          Toolshed.logger.warn "Unable to delete '#{local_branch_name}' from local as it does not exist skipping"
+          return
+        end
+
+        results = Toolshed::Base.wait_for_command("git branch -D #{local_branch_name}")
+        results[:all].each do |result|
+          Toolshed.logger.info result.rstrip
+        end
+      end
+
+      def delete_remote(remote_branch_name)
+        unless remote.include?(remote_branch_name)
+          Toolshed.logger.warn "Unable to delete '#{remote_branch_name}' from remote as it does not exist skipping"
+          return
+        end
+
+        Toolshed.logger.info "Deleting #{remote_branch_name} from remote"
+        results = Toolshed::Base.wait_for_command("git push #{Toolshed::Client.instance.push_to_remote_name} --delete #{remote_branch_name}")
+        results[:all].each do |result|
+          Toolshed.logger.info result.rstrip
+        end
+      end
+
+      def list
+        remote_update
+        list_local
+        list_remote
+      end
+
+      def list_local
+        Toolshed.logger.info ''
+        Toolshed.logger.info 'Local Branches'
+        Toolshed.logger.info ''
+        current_branch_name = name
+        local.each do |local_branch|
+          Toolshed.logger.info "#{local_branch[:branch_name]} #{local_branch[:branch_info]}"
+        end
+      end
+
+      def list_remote
+        Toolshed.logger.info ''
+        Toolshed.logger.info 'Remote Branches'
+        Toolshed.logger.info ''
+        remote.each do |remote_branch|
+          Toolshed.logger.info remote_branch
+        end
+      end
+
+      def local
+        @local ||= begin
+          local_branches = []
+          results = Toolshed::Base.wait_for_command('git branch -avv')
+          results[:stdout].each do |stdout|
+            next if /remotes.*/.match(stdout) || /HEAD.*/.match(stdout)
+            branch_name = /.*\s{3,}/.match(stdout)[0]
+            branch_name = branch_name.gsub('*', '')
+            branch_info_match = /\[[a-z].*\]/.match(stdout)
+            branch_info = ''
+            branch_info = branch_info_match[0] unless branch_info_match.nil?
+            local_branches << { branch_name: branch_name.lstrip.rstrip, branch_info: branch_info.lstrip.rstrip }
+          end
+          local_branches
+        end
+      end
+
+      def name
+        (passed_branch_name.nil? || passed_branch_name.empty?) ? `git rev-parse --abbrev-ref HEAD`.strip : Toolshed::Git::Branch.name_from_substring(passed_branch_name) # rubocop:disable Metrics/LineLength
+      end
+
+      def push
+        Toolshed.logger.info "Pushing #{name}"
+        if (name.nil? || name.empty?) && (!passed_branch_name.nil? && !passed_branch_name.empty?)
+          Toolshed.logger.fatal "Branch #{passed_branch_name} was not found. Unable to push branch."
+          Toolshed.die
+        end
+        result = Toolshed::Base.wait_for_command("git push #{to_remote_name} #{name} #{force} #{Toolshed::Client.instance.git_quiet}")
+        result[:all].each do |stdout|
+          Toolshed.logger.info stdout
+        end
+        Toolshed.logger.info 'Everything up-to-date' if result[:stdout].empty? && result[:stderr].empty?
+        Toolshed.logger.info "#{name} has been pushed"
+      end
+
+      def remote
+        remote_branches = []
+        results = Toolshed::Base.wait_for_command('git branch -avv')
+        results[:stdout].each do |stdout|
+          next unless /remotes\/#{from_remote_name}.*/.match(stdout)
+          next if  /.*HEAD.*/.match(stdout)
+          matches = /([^\s]+)/.match(stdout)
+          remote_branches << matches[0].gsub("remotes/#{from_remote_name}/", '')
+        end
+        remote_branches
+      end
+
+      def rename(new_branch_name)
+        current_branch_name = passed_branch_name
+        results = Toolshed::Base.wait_for_command("git branch -m #{passed_branch_name} #{new_branch_name}")
+        results[:all].each do |out|
+          matches = /(error.*|fatal.*)/.match(out)
+          if matches.length > 0
+            Toolshed.logger.fatal out
+            Toolshed.die("Unable to proceed supplied branch '#{current_branch_name}' does not exist in local repository.")
+          else
+            Toolshed.logger.info out
+          end
+        end
+        self.passed_branch_name = new_branch_name
+        push
+        delete_remote(current_branch_name)
+        Toolshed.logger.info ''
+        Toolshed.logger.info "Deleted branch #{current_branch_name}"
+      end
+    end
+  end
+end

data/lib/toolshed/git/github.rb

@@ -1,98 +1,86 @@
+require 'toolshed/git/branch'
+require 'toolshed/git'
+
 module Toolshed
-  module Git
-    class Github < Base
-      extend Toolshed::Git
+  class Git
+    # Class created to handle specific git tasks related to github
+    class Github < Toolshed::Git
       include HTTParty
 
       attr_accessor :default_options
 
-      def initialize(options={})
+      def initialize(options = {}) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         super(options)
 
-        username  = Toolshed::Client::github_username
-        password  = Toolshed::Client::github_password
-        token     = Toolshed::Client::github_token
-
-        unless (options[:username].nil?)
-          username = options[:username]
-        end
+        username  = Toolshed::Client.instance.github_username
+        password  = Toolshed::Client.instance.github_password
+        token     = Toolshed::Client.instance.github_token
 
-        unless (options[:password].nil?)
-           password = options[:password]
-        end
-
-        unless (token.nil?)
+        username = options[:username] unless options[:username].nil?
+        password = options[:password] unless options[:password].nil?
+        unless token.nil?
           username = token
           password = nil
         end
 
-        unless (options[:token].nil?)
+        unless options[:token].nil?
           username = options[:token]
           password = nil
         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",
+          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' # rubocop:disable Metrics/LineLength
           },
-          basic_auth: @auth,
+          basic_auth: @auth
         }
       end
 
-      def create_pull_request(title, body, options={})
-        options.merge!(self.default_options)
-        options.merge!({
-          body: {
+      def create_pull_request(title, body, options = {}) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/LineLength
+        options.merge!(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
+            body: body,
+            head: "#{Toolshed::Client.instance.github_username}:#{Toolshed::Git::Branch.name}", # rubocop:disable Metrics/LineLength
+            base: Toolshed::Git::Branch.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
+        )
+        display_options = Marshal.load(Marshal.dump(options))
+        display_options[:basic_auth][:password] = '********'
+        Toolshed.logger.info "Creating pull request with the following options: #{display_options.inspect}" # rubocop:disable Metrics/LineLength
+        response = HTTParty.post("#{Toolshed::Client::GITHUB_BASE_API_URL}repos/#{Toolshed::Client.instance.pull_from_repository_user}/#{Toolshed::Client.instance.pull_from_repository_name}/pulls", options).response # rubocop:disable Metrics/LineLength
         response = JSON.parse(response.body)
-        if (response["errors"].nil?)
+        if response['errors'].nil?
           response
         else
-          raise "validation errors #{response.inspect}"
+          fail "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
+        username = Toolshed::Client.instance.github_username
+        return username unless username.nil?
 
-        return username
+        puts 'Github username? '
+        $stdin.gets.chomp.strip
       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
+        password = Toolshed::Client.instance.github_password
+        return password unless password.nil?
+
+        system 'stty -echo'
+        puts 'Github password? '
+        password = $stdin.gets.chomp.strip
+        system 'stty echo'
+        password
       end
 
       def self.create_instance
-        Toolshed::Git::Github.new({ username: Toolshed::Git::Github.username, password: Toolshed::Git::Github.password })
+        Toolshed::Git::Github.new(username: Toolshed::Git::Github.username, password: Toolshed::Git::Github.password) # rubocop:disable Metrics/LineLength
       end
     end
   end

data/lib/toolshed/git/validator.rb

@@ -0,0 +1,14 @@
+require 'veto'
+
+module Toolshed
+  class Git
+    class Validator
+      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
+  end
+end

data/lib/toolshed/logger.rb

@@ -0,0 +1,46 @@
+require 'singleton'
+require 'term/ansicolor'
+require 'logger'
+
+class Toolshed::Logger
+  include Singleton
+  include Term::ANSIColor
+
+  attr_accessor :loggers
+
+  def self.create(options = {})
+    instance.loggers = []
+    log_sources = options[:log_sources] || [STDOUT]
+    log_sources.each do |log_source|
+      instance.loggers << Logger.new(log_source)
+    end
+  end
+
+  def add_log_source(source)
+    loggers << Logger.new(source)
+  end
+
+  def debug(message)
+    loggers.each do |logger|
+      logger.debug(message)
+    end
+  end
+
+  def fatal(message)
+    loggers.each do |logger|
+      logger.info(red(message))
+    end
+  end
+
+  def info(message)
+    loggers.each do |logger|
+      logger.info(green(message))
+    end
+  end
+
+  def warn(message)
+    loggers.each do |logger|
+      logger.warn(yellow(message))
+    end
+  end
+end

data/lib/toolshed/password.rb

@@ -8,7 +8,8 @@ module Toolshed
     end
 
     def read_user_input_password(type, prompt_message='Password:')
-      unless self.send(type).blank?
+      value = self.send(type)
+      unless value.nil? || value.empty?
         read_password_from_configuration(type)
       else
         prompt_user_to_input_password(prompt_message)
@@ -31,11 +32,15 @@ module Toolshed
       end
 
       def read_password_from_configuration(type)
-        credentials = Toolshed::Client.read_credenials
-        if credentials[self.send(type)]
-          credentials[self.send(type)]
-        else
-          self.send(type)
+        begin
+          credentials = Toolshed::Client.read_credenials
+          if credentials[self.send(type)]
+            credentials[self.send(type)]
+          else
+            self.send(type)
+          end
+        rescue => e
+          puts e.inspect
         end
       end
   end