toolshed 1.0.3 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8a8dfde43412cec6304d3bc7b42485ea14d225c5
-  data.tar.gz: 52bbbc59f4384c7ead365df2a4aed53d3f486521
+  metadata.gz: f2284363dbacddbe04adfd021331c5a27870e279
+  data.tar.gz: 739d370c284895290ae0a7213a75123c5d23c9e7
 SHA512:
-  metadata.gz: 6ddf6b5dcce569a0bc312f8a266b70cbc5d79be95ea318d7fadded6036b99143d394fcab632fc7d8c7c156cf324677d28de154fa56edab22308f91ddf79efbbc
-  data.tar.gz: 50c8a2c080727e008ab404f5b03d34481c9cc9cf892cd5cf89f24f42e608f9f772f2393af4f0c315e8182e34b76923a6641b9e5aa4801a229d02e75c66255d44
+  metadata.gz: 8a50e84f7789f7443e01de39d64708970dbe948e8ed441c9b2a166b7a51ffb4e4c3559d73a9705aa08f1b5ea238afd5b3b019a08cf5dd6180a4ecfedb1317f84
+  data.tar.gz: 595834a2bbf3cdae26a088a28dfa32dceef915a754e0c9432fe0f8c64112acfc3f186be061ee72771331c079712297b14dc903a9516492eff7c1346f325940cd

data/lib/toolshed/cli.rb

@@ -7,42 +7,23 @@ module Toolshed
 
   # CLI is responsible for executing the initial command
   class CLI
-    def execute(command_name, args, options = {})
-      load_config(command_name)
-      command = send(command_name)
-      if command
-        begin
-          command.new.execute(args, options)
-        rescue Toolshed::Error => e
-          Toolshed.logger.fatal "An error occurred: #{e.message}"
-        rescue RuntimeError => e
-          Toolshed.logger.fatal "An error occurred: #{e.message}"
-        end
-      else
-        fail CommandNotFound, "Unknown command: #{command_name}"
+    def execute(command_class, args, options = {})
+      load_config(command_class)
+      begin
+        command_class.new.execute(args, options)
+      rescue Toolshed::Error => e
+        Toolshed.logger.fatal "An error occurred: #{e.message}"
+      rescue RuntimeError => e
+        Toolshed.logger.fatal "An error occurred: #{e.message}"
       end
     end
 
-    def load_config(command_name)
+    def load_config(command_class)
       Toolshed::Client.load_credentials
-      Toolshed.add_file_log_source(command_name)
+      Toolshed.add_file_log_source(command_class.class.name)
       Toolshed.logger.info "Credentials loaded from #{File.absolute_path(Toolshed::Client.instance.credentials_loaded_from)}" # rubocop:disable Metrics/LineLength
     rescue => e
       Toolshed.logger.fatal "Error loading your credentials: #{e.message}"
     end
-
-    def method_missing(method_name)
-      require "toolshed/commands/#{method_name}"
-      "Toolshed::Commands::#{translate_method_name(method_name)}".split('::').inject(Object) { |o, c| o.const_get c } # rubocop:disable Metrics/LineLength
-    rescue NameError => e
-      Toolshed.logger.fatal e.message
-      Toolshed.die
-    end
-
-    def translate_method_name(name)
-      name = name.to_s
-      name.upcase! if %w(ssh).include?(name.downcase)
-      name.camel_case
-    end
   end
 end

data/lib/toolshed/commands/base.rb

@@ -5,10 +5,10 @@ module Toolshed
   module Commands
     # Base class for all commands responsible for common methods
     class Base
-      def initialize(_options = {})
+      def initialize(options = {})
       end
 
-      def self.parse(command, cli_options = {}) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/LineLength, Metrics/CyclomaticComplexity
+      def self.parse(command_class, cli_options = {}) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/LineLength, Metrics/CyclomaticComplexity
         options = {}
         options_parser = OptionParser.new do |opts|
           opts.banner = cli_options[:banner] if cli_options[:banner]
@@ -25,7 +25,7 @@ module Toolshed
         options_parser.order! if options_parser
         begin
           cli = Toolshed::CLI.new
-          cli.execute(command, ARGV, options)
+          cli.execute(command_class, ARGV, options)
         rescue Toolshed::CommandNotFound => e
           Toolshed.logger.fatal e.message
           Toolshed.die
@@ -34,7 +34,8 @@ module Toolshed
 
       def read_user_input(message, options = {})
         return options[:default] if Toolshed::Client.instance.use_defaults
-        required = options[:required] || false
+        required = options[:required].is_a?(TrueClass)
+
         value = ''
         if required
           value = prompt_user_input(message, options) while value.empty?
@@ -44,6 +45,15 @@ module Toolshed
         value
       end
 
+      def read_user_input_password(password, prompt_message='Password:')
+        return password unless password.nil? || password.empty?
+        system "stty -echo"
+        puts prompt_message
+        value = $stdin.gets.chomp.strip
+        system "stty echo"
+        value
+      end
+
       def read_user_input_title(message, options = {})
         return options[:title] if options.key?(:title)
         read_user_input(message, options)

data/lib/toolshed/commands/scp/download.rb

@@ -0,0 +1,43 @@
+require 'toolshed/commands/scp_base'
+
+module Toolshed
+  module Commands
+    module SCP
+      # Responsible for handing downloading of files
+      class Download < Toolshed::Commands::SCPBase
+        def self.cli_options # rubocop:disable MethodLength
+          {
+            banner: 'Usage: scp download [options]',
+            options: {
+              remote_host: {
+                short_on: '-r'
+              },
+              remote_path: {
+                short_on: '-d'
+              },
+              local_path: {
+                short_on: '-s'
+              },
+              username: {
+                short_on: '-u'
+              },
+              password: {
+                short_on: '-p'
+              },
+              verbose_output: {
+                short_on: '-v'
+              }
+            }
+          }
+        end
+
+        def execute(_args, options = nil)
+          options ||= nil
+          Toolshed.logger.info ''
+          Toolshed::ServerAdministration::SCP.new(scp_options(options)).download
+          Toolshed.die
+        end
+      end
+    end
+  end
+end

data/lib/toolshed/commands/scp/upload.rb

@@ -0,0 +1,43 @@
+require 'toolshed/commands/scp_base'
+
+module Toolshed
+  module Commands
+    module SCP
+      # Responsible for handing uploading of files
+      class Upload < Toolshed::Commands::SCPBase
+        def self.cli_options # rubocop:disable MethodLength
+          {
+            banner: 'Usage: scp upload [options]',
+            options: {
+              remote_host: {
+                short_on: '-r'
+              },
+              remote_path: {
+                short_on: '-d'
+              },
+              local_path: {
+                short_on: '-s'
+              },
+              username: {
+                short_on: '-u'
+              },
+              password: {
+                short_on: '-p'
+              },
+              verbose_output: {
+                short_on: '-v'
+              }
+            }
+          }
+        end
+
+        def execute(_args, options = nil)
+          options ||= nil
+          Toolshed.logger.info ''
+          Toolshed::ServerAdministration::SCP.new(scp_options(options)).upload
+          Toolshed.die
+        end
+      end
+    end
+  end
+end

data/lib/toolshed/commands/scp_base.rb

@@ -0,0 +1,21 @@
+require 'toolshed/commands/base'
+require 'toolshed/server_administration/scp'
+
+module Toolshed
+  module Commands
+    # Shared code between scp classes
+    class SCPBase < Toolshed::Commands::Base
+      private
+
+      def scp_options(options = nil) # rubocop:disable AbcSize
+        options ||= {}
+        options[:remote_host] = read_user_input('Remote Host?', required: true) if options[:remote_host].nil? # rubocop:disable LineLength
+        options[:remote_path] = read_user_input('Remote Path?', required: true) if options[:remote_path].nil? # rubocop:disable LineLength
+        options[:local_path] = read_user_input('Local Path?', required: true) if options[:local_path].nil? # rubocop:disable LineLength
+        options[:username] = read_user_input('Username?', required: true) if options[:username].nil? # rubocop:disable LineLength
+        options[:password] = read_user_input_password(options[:password])
+        options
+      end
+    end
+  end
+end

data/lib/toolshed/entry_point.rb

@@ -44,46 +44,77 @@ class EntryPoint
       end
 
       global.order!
-      command = ARGV.shift
-      if command.nil?
+      if command_parts.length == 0
         usage
-      elsif command == 'version'
+      elsif command_parts[0] == 'version'
         Toolshed::Version.banner
         Toolshed.die
       else
-        command_class = nil
-        command_class_name = command.camel_case
+        command_class = default_command_class_string
+        attempts = 0
         begin
-          require "toolshed/commands/#{command.to_s}"
-          command_class = "Toolshed::Commands::#{command_class_name}".split('::').inject(Object) { |o,c| o.const_get c }
-        rescue NameError
-          command_class = "Toolshed::Commands::#{command_class_name.upcase}".split('::').inject(Object) { |o,c| o.const_get c }
+          require "toolshed/commands/#{command_parts.join('/')}"
+          command_class = command_class.split('::').inject(Object) { |o,c| o.const_get c }
+        rescue NameError => e
+          name_error_name = e.message.sub('wrong constant name ', '')
+          name_error_name = e.message.sub('uninitialized constant ', '')
+          command_class = command_class.sub(name_error_name, name_error_name.upcase)
+          attempts += 1
+          retry unless attempts > command_parts.length
         end
-        Toolshed::Commands::Base.parse(command, command_class.cli_options)
+        Toolshed::Commands::Base.parse(command_class, command_class.cli_options)
       end
     end
   end
 
+  def command_parts
+    @command_parts ||= begin
+      command_parts = []
+      arguments_left = true
+      until !arguments_left
+        if ARGV.first.nil? || ARGV.first.start_with?('--') || ARGV.first.start_with?('-')
+          arguments_left = false
+        else
+          command_parts << ARGV.shift
+        end
+      end
+      command_parts
+    end
+  end
+
+  def default_command_class_string
+    command_class = "Toolshed::Commands"
+    command_parts.each do |command_part|
+      if command_part.include?('_')
+        command_class = "#{command_class}::#{command_part.split('_').map(&:capitalize).join('')}"
+      else
+        command_class = "#{command_class}::#{command_part.capitalize}"
+      end
+    end
+    command_class
+  end
+
   def usage
     $stdout.puts <<EOF
 Please see toolshedrc.sample to create your toolshedrc settings file.
 
 Available Commands:
 
-  checkout_branch
-  create_branch
-  create_pivotal_tracker_note
-  create_pull_request
-  create_ticket_comment
-  delete_branch
-  get_daily_time_update
-  list_branches
-  push_branch
-  rename_branch
-  ssh
-  ticket_information
-  update_pivotal_tracker_story_status
-  update_ticket_status
+  toolshed checkout_branch
+  toolshed create_branch
+  toolshed create_pivotal_tracker_note
+  toolshed create_pull_request
+  toolshed create_ticket_comment
+  toolshed delete_branch
+  toolshed get_daily_time_update
+  toolshed list_branches
+  toolshed push_branch
+  toolshed rename_branch
+  toolshed scp download
+  toolshed ssh
+  toolshed ticket_information
+  toolshed update_pivotal_tracker_story_status
+  toolshed update_ticket_status
 EOF
   end
 end

data/lib/toolshed/exceptions.rb

@@ -0,0 +1 @@
+class RequiredOptionException < StandardError;

data/lib/toolshed/git/branch.rb

@@ -160,7 +160,8 @@ module Toolshed
           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]
+            matches = /([^\s]+)/.match(stdout)
+            branch_name = matches[0]
             branch_name = branch_name.gsub('*', '')
             branch_info_match = /\[[a-z].*\]/.match(stdout)
             branch_info = ''

data/lib/toolshed/password.rb

@@ -1,47 +1,23 @@
-module Toolshed
-  class Password
-    attr_accessor :password, :sudo_password
-
-    def initialize(options={})
-      self.password = options[:password] ||= ''
-      self.sudo_password = options[:sudo_password] ||= ''
-    end
-
-    def read_user_input_password(type, prompt_message='Password:')
-      value = self.send(type)
-      unless value.nil? || value.empty?
-        read_password_from_configuration(type)
-      else
-        prompt_user_to_input_password(prompt_message)
-      end
-    end
-
-    protected
+require 'toolshed/client'
 
-      def prompt_user_to_input_password(message)
-        system "stty -echo"
-        puts message
-        value = get_password_input
-        system "stty echo"
-
-        value
-      end
-
-      def get_password_input
-        $stdin.gets.chomp.strip
-      end
+module Toolshed
+  module Password
+    def password_from_config(password)
+      return '' if password.nil? || password.empty?
 
-      def read_password_from_configuration(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
+      begin
+        credentials = Toolshed::Client.read_credenials
+        password_parts = password.split(':')
+        password_parts.each do |password_part|
+          return password if credentials[password_part].nil?
+          credentials = credentials[password_part]
         end
+      rescue => e
+        Toolshed::Logger.instance.fatal e.message
+        Toolshed::Logger.instance.fatal e.inspect
+        return password
       end
+      credentials
+    end
   end
 end

data/lib/toolshed/server_administration/scp.rb

@@ -0,0 +1,46 @@
+require 'toolshed/server_administration/ssh'
+require 'toolshed/password'
+
+require 'net/scp'
+require 'ruby-progressbar'
+
+module Toolshed
+  module ServerAdministration
+    # Handles SCP file from one place to another
+    class SCP
+      include Toolshed::Password
+
+      attr_reader :local_path, :password, :remote_host, :remote_path, :username, :verbose_output # rubocop:disable LineLength
+
+      def initialize(options = nil)
+        options ||= {}
+
+        @password = options[:password]
+        @remote_host = options[:remote_host]
+        @remote_path = options[:remote_path]
+        @local_path = options[:local_path]
+        @username = options[:username]
+        @verbose_output = options[:verbose_output]
+      end
+
+      def download
+        Toolshed.logger.info "Attempting to SCP from #{username}@#{remote_host}:#{remote_path} to #{local_path}." # rubocop:disable LineLength
+        Net::SCP.download!(remote_host, username, remote_path, local_path, ssh: { password: password_from_config(password) }, recursive: true) # rubocop:disable LineLength
+        on_complete
+      end
+
+      def upload
+        Toolshed.logger.info "Attempting to SCP from #{local_path} to #{username}@#{remote_host}:#{remote_path}." # rubocop:disable LineLength
+        Net::SCP.upload!(remote_host, username, local_path, remote_path, ssh: { password: password_from_config(password) }, recursive: true) # rubocop:disable LineLength
+        on_complete
+      end
+
+      private
+
+      def on_complete
+        Toolshed.logger.info ''
+        Toolshed.logger.info 'SCP file transfer has completed.'
+      end
+    end
+  end
+end

data/lib/toolshed/server_administration/ssh.rb

@@ -4,24 +4,31 @@ require 'net/ssh'
 
 module Toolshed
   module ServerAdministration
+    # SSH class that can ssh to a host and perform commands
     class SSH
-      attr_accessor :keys, :password, :sudo_password, :host, :user, :ssh_options, :channel, :commands, :password
-
-      def initialize(options={})
-        self.password = options[:password] ||= ''
-        self.sudo_password = options[:sudo_password] ||= ''
-        self.keys = options[:keys] ||= ''
-        self.host = options[:host] ||= ''
-        self.user = options[:user] ||= ''
-        self.ssh_options = options[:ssh_options] ||= {}
-        self.commands = options[:commands] ||= ''
-        self.password = Toolshed::Password.new(options)
+      include Toolshed::Password
+
+      attr_accessor :channel, :commands, :data, :host, :keys, :password, :ssh_options, :sudo_password, :user # rubocop:disable LineLength
+      attr_reader :silent
+
+      def initialize(options = nil) # rubocop:disable AbcSize, CyclomaticComplexity, PerceivedComplexity, LineLength
+        options ||= {}
+        @password = options[:password] || ''
+        @sudo_password = options[:sudo_password] || ''
+        @keys = options[:keys] || ''
+        @host = options[:host] || ''
+        @user = options[:user] || ''
+        @ssh_options = options[:ssh_options] || {}
+        @commands = options[:commands] || ''
+        @password = options[:password] || ''
+        @data = []
+        @silent = options[:silent] || false
 
         set_ssh_options
       end
 
       def execute
-        Net::SSH.start(self.host, self.user, self.ssh_options) do |ssh|
+        Net::SSH.start(host, user, ssh_options) do |ssh|
           ssh.open_channel do |channel|
             self.channel = channel
             request_pty
@@ -29,14 +36,16 @@ module Toolshed
           end
           ssh.loop
         end
+        data
       end
 
       protected
 
         def run_commands
-          # @TODO fix this so it does not just pass in the commands option but converts to a string i.e. command1;command2
-          self.channel.exec(self.commands) do |ch, success|
-            abort "Could not execute commands!" unless success
+          # @TODO fix this so it does not just pass in the commands option
+          # Converts to string like command1;command2
+          channel.exec(commands) do |_ch, success|
+            abort 'Could not execute commands!' unless success
 
             on_data
             on_extended_data
@@ -45,46 +54,55 @@ module Toolshed
         end
 
         def request_pty
-          self.channel.request_pty do |ch, success|
-            puts (success) ? "Successfully obtained pty" : "Could not obtain pty"
+          channel.request_pty do |_ch, success|
+            unless silent
+              message = (success) ? 'Successfully obtained pty' : 'Could not obtain pty'
+              puts message
+            end
           end
         end
 
         def on_close
-          self.channel.on_close do |ch|
-            puts "Channel is closing!"
+          channel.on_close do |_ch|
+            puts 'Channel is closing!' unless silent
           end
         end
 
         def on_extended_data
-          self.channel.on_extended_data do |ch, type, data|
-            puts "stderr: #{data}"
+          channel.on_extended_data do |_ch, _type, data|
+            puts "stderr: #{data}" unless silent
           end
         end
 
         def on_data
-          self.channel.on_data do |ch, data|
-            puts "#{data}"
+          channel.on_data do |_ch, data|
+            puts "#{data}" unless silent
+            self.data << data
             send_data(data)
           end
         end
 
         def send_data(data)
           send_password_data if data =~ /password/
-          send_yes_no_data if data =~ /Do you want to continue \[Y\/n\]?/
+          # send_yes_no_data if data =~ /Do you want to continue \[Y\/n\]?/
+          send_yes_no_data if data =~ %r{Do you want to continue [Y/n]?}
         end
 
         def send_password_data
-          self.channel.send_data "#{@password.read_user_input_password('sudo_password')}\n"
+          channel.send_data "#{password_from_config(sudo_password)}\n"
         end
 
         def send_yes_no_data
-          self.channel.send_data "Y\n"
+          channel.send_data "Y\n"
         end
 
-        def set_ssh_options
-          self.ssh_options.merge!({ keys: [self.keys] }) unless keys.nil? || keys.empty?
-          self.ssh_options.merge!({ password: self.password.read_user_input_password('password') }) if keys.nil? || keys.empty?
+        def set_ssh_options # rubocop:disable AbcSize
+          if keys.nil? || keys.empty?
+            final_password = password_from_config(password)
+            ssh_options.merge!(password: final_password)
+          else
+            ssh_options.merge!(keys: [keys]) unless keys.nil? || keys.empty?
+          end
         end
     end
   end

data/lib/toolshed/version.rb

@@ -2,7 +2,7 @@
 
 # Module for toolshed
 module Toolshed
-  VERSION = '1.0.3'
+  VERSION = '1.0.4'
 
   # Display the version information with the toolshed banner
   class Version

data/test/commands/scp/download_test.rb

@@ -0,0 +1,34 @@
+require 'commands/commands_helper'
+require 'toolshed/commands/scp/download'
+require 'net/scp'
+
+module Test
+  module Commands
+    module SCP
+      class DownloadTest < Test::Unit::TestCase
+        def setup
+          Toolshed::Logger.instance.instance_variable_set(:@logs, { debug: [], fatal: [], info: [], warn: [] })
+          Toolshed.expects(:die).at_least(0).returns('Exiting')
+        end
+
+        def teardown
+          Toolshed::Logger.instance.instance_variable_set(:@logs, { debug: [], fatal: [], info: [], warn: [] })
+        end
+
+        def test_scp_upload
+          Net::SCP.expects(:download!).returns('downloaded')
+
+          scp_download_command = Toolshed::Commands::SCP::Download.new
+          scp_download_command.execute({}, password: 'test1234', username: 'test', remote_host: 'localhost', remote_path: '/tmp', local_path: '/tmp')
+
+          assert Toolshed::Logger.instance.logs[:info].include?('SCP file transfer has completed.')
+          assert Toolshed::Logger.instance.logs[:info].include?('Attempting to SCP from test@localhost:/tmp to /tmp.')
+        end
+
+        def test_cli_options
+          assert 'Usage: scp download [options]', Toolshed::Commands::SCP::Download.cli_options[:banner]
+        end
+      end
+    end
+  end
+end

data/test/commands/scp/upload_test.rb

@@ -0,0 +1,34 @@
+require 'commands/commands_helper'
+require 'toolshed/commands/scp/upload'
+require 'net/scp'
+
+module Test
+  module Commands
+    module SCP
+      class UploadTest < Test::Unit::TestCase
+        def setup
+          Toolshed::Logger.instance.instance_variable_set(:@logs, { debug: [], fatal: [], info: [], warn: [] })
+          Toolshed.expects(:die).at_least(0).returns('Exiting')
+        end
+
+        def teardown
+          Toolshed::Logger.instance.instance_variable_set(:@logs, { debug: [], fatal: [], info: [], warn: [] })
+        end
+
+        def test_scp_upload
+          Net::SCP.expects(:upload!).returns('uploaded')
+
+          scp_upload_command = Toolshed::Commands::SCP::Upload.new
+          scp_upload_command.execute({}, password: 'test1234', username: 'test', remote_host: 'localhost', remote_path: '/tmp', local_path: '/tmp')
+
+          assert Toolshed::Logger.instance.logs[:info].include?('SCP file transfer has completed.')
+          assert Toolshed::Logger.instance.logs[:info].include?('Attempting to SCP from /tmp to test@localhost:/tmp.')
+        end
+
+        def test_cli_options
+          assert 'Usage: scp upload [options]', Toolshed::Commands::SCP::Upload.cli_options[:banner]
+        end
+      end
+    end
+  end
+end

data/test/helper.rb

@@ -18,6 +18,7 @@ require 'fileutils'
 require 'json'
 
 require 'toolshed'
+require 'toolshed/logger'
 
 Test::Unit.at_start do
   Toolshed::Client.instance.use_git_submodules = false
@@ -100,3 +101,27 @@ def capture_stdout(&block)
   end
   fake.string
 end
+
+class Toolshed::Logger
+  attr_reader :logs
+
+  def initialize
+    @logs = { debug: [], fatal: [], info: [], warn: [] }
+  end
+
+  def debug(message)
+    logs[:debug] << message
+  end
+
+  def fatal(message)
+    logs[:fatal] << message
+  end
+
+  def info(message)
+    logs[:info] << message
+  end
+
+  def warn(message)
+    logs[:warn] << message
+  end
+end

data/test/password_test.rb

@@ -1,24 +1,10 @@
 require 'helper'
+require 'toolshed/server_administration/scp'
 
 class PasswordTest < Test::Unit::TestCase
-  def test_read_user_input_password
-    password = Toolshed::Password.new({ password: 'test1234' })
-    assert_equal password.read_user_input_password('password'), 'test1234'
-  end
-
-  def test_read_user_input_password_sudo
-    password = Toolshed::Password.new({ sudo_password: 'test12345' })
-    assert_equal password.read_user_input_password('sudo_password'), 'test12345'
-  end
-
-  def test_read_user_input_password_prompt
-    password = Toolshed::Password.new({})
-    password.expects(:get_password_input).returns('readin1234')
-    assert_equal password.read_user_input_password('password'), 'readin1234'
-  end
-
-  def test_read_user_input_from_toolshedrc
-    password = Toolshed::Password.new({ password: 'server_password' })
-    assert_equal password.read_user_input_password('password'), 'tester1234'
+  def test_password_from_config
+    expected_password = 'tester1234'
+    actual_password = Toolshed::ServerAdministration::SCP.new({}).password_from_config('server_password')
+    assert_equal expected_password, actual_password
   end
 end

data/test/server_administration/scp_test.rb

@@ -0,0 +1,37 @@
+require 'commands/commands_helper'
+require 'toolshed/commands/scp/download'
+require 'net/scp'
+
+module Test
+  module ServerAdministration
+    class SCPTest < Test::Unit::TestCase
+      def setup
+        Toolshed::Logger.instance.instance_variable_set(:@logs, { debug: [], fatal: [], info: [], warn: [] })
+      end
+
+      def teardown
+        Toolshed::Logger.instance.instance_variable_set(:@logs, { debug: [], fatal: [], info: [], warn: [] })
+      end
+
+      def test_scp_download
+        Net::SCP.expects(:download!).returns('downloaded')
+
+        scp = Toolshed::ServerAdministration::SCP.new(password: 'test1234', username: 'test', remote_host: 'localhost', remote_path: '/tmp', local_path: '/tmp')
+        scp.download
+
+        assert Toolshed::Logger.instance.logs[:info].include?('SCP file transfer has completed.')
+        assert Toolshed::Logger.instance.logs[:info].include?('Attempting to SCP from test@localhost:/tmp to /tmp.')
+      end
+
+      def test_scp_upload
+        Net::SCP.expects(:upload!).returns('uploaded')
+
+        scp = Toolshed::ServerAdministration::SCP.new(password: 'test1234', username: 'test', remote_host: 'localhost', remote_path: '/tmp', local_path: '/tmp')
+        scp.upload
+
+        assert Toolshed::Logger.instance.logs[:info].include?('SCP file transfer has completed.')
+        assert Toolshed::Logger.instance.logs[:info].include?('Attempting to SCP from /tmp to test@localhost:/tmp.')
+      end
+    end
+  end
+end

data/toolshed.gemspec

@@ -29,6 +29,8 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'net-ssh', '2.9.2'
   spec.add_dependency 'term-ansicolor', '1.3.0'
   spec.add_dependency 'highline', '1.7.2'
+  spec.add_dependency 'net-scp', '1.2.1'
+  spec.add_dependency 'ruby-progressbar', '1.7.5'
 
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: toolshed
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.4
 platform: ruby
 authors:
 - Jake Waller
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-20 00:00:00.000000000 Z
+date: 2015-09-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -150,6 +150,34 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 1.7.2
+- !ruby/object:Gem::Dependency
+  name: net-scp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+- !ruby/object:Gem::Dependency
+  name: ruby-progressbar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.7.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.7.5
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -337,18 +365,23 @@ files:
 - lib/toolshed/commands/list_branches.rb
 - lib/toolshed/commands/push_branch.rb
 - lib/toolshed/commands/rename_branch.rb
+- lib/toolshed/commands/scp/download.rb
+- lib/toolshed/commands/scp/upload.rb
+- lib/toolshed/commands/scp_base.rb
 - lib/toolshed/commands/ssh.rb
 - lib/toolshed/commands/ticket_information.rb
 - lib/toolshed/commands/update_pivotal_tracker_story_status.rb
 - lib/toolshed/commands/update_ticket_status.rb
 - lib/toolshed/entry_point.rb
 - lib/toolshed/error.rb
+- lib/toolshed/exceptions.rb
 - lib/toolshed/git.rb
 - lib/toolshed/git/branch.rb
 - lib/toolshed/git/github.rb
 - lib/toolshed/git/validator.rb
 - lib/toolshed/logger.rb
 - lib/toolshed/password.rb
+- lib/toolshed/server_administration/scp.rb
 - lib/toolshed/server_administration/ssh.rb
 - lib/toolshed/ticket_tracking/jira.rb
 - lib/toolshed/ticket_tracking/pivotal_tracker.rb
@@ -365,12 +398,15 @@ files:
 - test/commands/get_daily_time_update_test.rb
 - test/commands/push_branch_test.rb
 - test/commands/rename_branch_test.rb
+- test/commands/scp/download_test.rb
+- test/commands/scp/upload_test.rb
 - test/config.rb
 - test/git/git_helper.rb
 - test/git/git_test.rb
 - test/git/github_test.rb
 - test/helper.rb
 - test/password_test.rb
+- test/server_administration/scp_test.rb
 - test/server_administration/ssh_test.rb
 - test/ticket_tracking/jira_test.rb
 - test/time_tracking/harvest_test.rb
@@ -395,7 +431,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Create a Github pull request with minimal work. Will automatically read ticket
@@ -410,12 +446,15 @@ test_files:
 - test/commands/get_daily_time_update_test.rb
 - test/commands/push_branch_test.rb
 - test/commands/rename_branch_test.rb
+- test/commands/scp/download_test.rb
+- test/commands/scp/upload_test.rb
 - test/config.rb
 - test/git/git_helper.rb
 - test/git/git_test.rb
 - test/git/github_test.rb
 - test/helper.rb
 - test/password_test.rb
+- test/server_administration/scp_test.rb
 - test/server_administration/ssh_test.rb
 - test/ticket_tracking/jira_test.rb
 - test/time_tracking/harvest_test.rb