ssh-short 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+--- 
+SHA512: 
+  data.tar.gz: 57d071b428d1f9cd7c1d4d35468d3ab0aed81826f7958a234b49f29b3a5b31ba9a996daf921846b4c137140a9c40c9d13a707036f8fa1abe7242091b6476985f
+  metadata.gz: d78446918da032b69cef111cc5fd1ad863b9998d3c7d000aea20f509a54448fbf47d9b1a95f182c2ea5220e51c43e002b887ca26ac0bb462dc4e9f4c907a16f7
+SHA1: 
+  data.tar.gz: a104fd336517f5d569c8910c44e9a9cbf9090c11
+  metadata.gz: 92180626001f2978d271f23f00d4b48abab2bd97

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org/'
+
+group :development do
+  gem 'rake'
+end
+
+group :test do
+  gem 'rspec', '~> 3.2.0'
+  gem 'mocha'#, :require => false
+end

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 TomPoulton
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 TomPoulton
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,190 @@
+# ssh-short
+
+The aim of ssh-short is reduce the amount you have to type when ssh-ing into common hosts, 
+from something like:
+```
+ssh -i /path/to/my/key.pem username@10.55.2.16
+```
+to:
+```
+sshort 16
+```
+or even an alias if you set one:
+```
+sshort fav
+```
+
+The command `sshort` was chosen because it's easy and quick to type, 
+even if it's not the most descriptive name (suggestions welcome!)
+
+### Config
+
+If you often ssh into a set of hosts that have similar IPs with a common username (such as Amazon EC2 instances),  
+then ssh-short can use a combination of config and map files to reduce the repetitive typing when ssh-ing into these hosts.
+
+You first create a config file (`~/.ssh-short/config.yml`) like the following:
+```
+---
+:keys_dir: '~/my/ssh/keys'
+:ip_mask:  10.55.2.0
+:default_user: my-user
+```
+
+##### `keys_dir`
+
+This is where ssh-short will look for your ssh keys, it assumes that they're all in here
+
+##### `ip_mask`
+
+The mask provides a way of avoiding having to type the full IP every time.
+
+If all your IPs start with `10.55.2` for example, then set the mask to `10.55.2.0`, 
+now you only have to provide the last segment and ssh-short will add what's missing 
+using the sections from the mask.
+Any sections you pass in overwrite the mask, so you can still connect to IPs that 
+are completely different from the mask
+
+Here's an example of masks, input and outputs
+
+| Mask      | Input        | Result       |
+|-----------|--------------|--------------|
+| 10.55.2.0 |  16          | 10.55.2.16   |
+| 10.55.2.0 |  2.16        | 10.55.2.16   |
+| 10.55.2.0 |  55.2.16     | 10.55.2.16   |
+| 10.55.2.0 |  10.55.2.16  | 10.55.2.16   |
+| 10.55.2.0 |  192.168.1.2 | 192.168.1.2  |
+| 10.60.0.0 |  16          | 10.60.0.16   |
+| 10.60.0.0 |  22.2        | 10.60.22.2   |
+| 10.60.0.0 |  222.22.2    | 10.222.22.2  |
+
+##### `default_user`
+
+Hopefully this is self explanatory, it's the username that will be used 
+to connect to the host if no user is provided. 
+
+You can override the user for a node, see args section below
+
+### Keys
+
+When you connect to a host for the first time with ssh-short, it will scan your `keys_dir`
+and present you with a list of numbered keys:
+
+```
+user@localhost $ sshort 16
+Select a key:
+0) Dev.pem
+1) Test.pem
+2) Admin.pem
+```
+
+Simply type the number of the key and press enter. ssh-short will connect you via `ssh`, 
+and it will also remember your choice in `~/.ssh-short/nodemap.yml` so the next time you connect 
+it will look for the key name in the nodemap file and use that automatically:
+```
+user@localhost $ sshort 16
+Connecting as my-user to 10.55.2.16 using Test.pem
+...
+```
+
+It stores the name of the file (e.g. `Test.pem`), not the number you select, or the full path to the key. 
+This way if you add keys or change your keys directory it doesn't matter, 
+as long as the file name stays the same
+
+If you chose the wrong key or need to change the key, see args section below
+
+### Args
+
+#### `-u`
+Specify a user. This will be used instead of the defualt user. The user is saved in the nodemap so you only have to set it once. If the user does change, use this command to update the nodemap:
+
+```
+user@localhost $ sshort 16
+Connecting as my-user to 10.55.2.16 using Test.pem
+...
+user@localhost $ sshort 16 -u new-user
+Connecting as new-user to 10.55.2.16 using Test.pem
+...
+user@localhost $ sshort 16
+Connecting as new-user to 10.55.2.16 using Test.pem
+...
+```
+#### `-k`
+This forces an update to the key for a node and you will be presented with the list of keys again as if connecting for the first time:
+
+```
+user@localhost $ sshort 16 -k
+Select a key:
+0) Dev.pem
+...
+```
+
+#### `-a`
+Add an alias to a node, or move an exisiting alias to a new node, see Aliases section below
+
+### Aliases
+
+If you want to connect to a host using an alias instead of an IP, you can set an alias
+```
+sshort 16 -a fred
+```
+Next time you can just use `fred`
+```
+sshort fred
+```
+
+If you set an alias that already exists it will be moved to the new host, 
+and a message will inform you:
+```
+user@localhost $ sshort 0.77 -a fred
+Moving alias fred from 10.55.2.16 to 10.55.0.77
+...
+```
+
+To list all the saved aliases, use the `--list` action:
+```
+user@localhost $ sshort --list
+fav
+fred
+```
+
+### Push and Pull
+
+ssh-short also provides a way to push/pull files using `scp`:
+```
+sshort 16 --pull /foo/bar.txt /tmp/
+```
+
+This will pull the file `/foo/bar.txt` from the host to the `/tmp` directory on your local machine. 
+The opposite is `--push`:
+```
+sshort 16 --push /tmp/bar.txt /foo/
+```
+
+Behind the scenes ssh-short uses the same key lookup process, 
+and then just passes the path arguments to `scp`:
+```
+scp -r -i /path/to/key.pem /tmp/bar.txt my-user@10.55.2.16:/foo/
+```
+
+## Installation
+
+Install the gem:
+```
+gem install ssh-short
+```
+
+Create your config file
+
+## SSH Config
+
+The SSH config file (`~/.ssh/config`) has support for a lot of this already, as well as extra stuff like `LocalForward` etc
+
+Maybe this tool can evolve to use the SSH config for persistence instead of `~/.ssh-short/nodemap.yml`
+and support all the features that SSH and it's config file offer,
+however reading and writing wouldn't be as simple as serialising a simple array to/from YAML.
+
+Plus the user might want to make changes to the SSH config outside of ssh-short, so we'd have to careful not to overwrite these "external" changes
+
+## ToDo
+- Make `ip_mask` and `default_user` optional config settings
+- IPv6??

data/bin/sshort

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'ssh_short/cli'
+
+SshShort::CLI.run ARGV

data/lib/ssh_short/cli.rb

@@ -0,0 +1,57 @@
+require 'ssh_short/parser'
+require 'ssh_short/nodemapper'
+require 'ssh_short/keyset'
+require 'ssh_short/connection'
+
+module SshShort
+
+  CONFIG_DIR = File.expand_path('~/.ssh-short')
+  CONFIG_FILE = File.join(CONFIG_DIR, 'config.yml')
+  NODEMAP_FILE = File.join(CONFIG_DIR, 'nodemap.yml')
+  Dir.mkdir(CONFIG_DIR) unless File.exists?(CONFIG_DIR)
+
+  class CLI
+
+    def self.run(argv)
+      config = SshShort::Parser.parse_config
+      args = SshShort::Parser.parse_input(config, argv)
+      key_set = SshShort::KeySet.new(config[:keys_dir])
+      node_mapper = SshShort::NodeMapper.new
+
+      if args[:action] == :list_aliases
+        node_mapper.get_aliases.each { |node_alias| puts node_alias }
+        exit
+      end
+
+      node = node_mapper.get_node args[:node]
+      node ||= {:host => args[:node]}
+
+      if node[:key].nil? or args[:force_key_prompt]
+        node[:key] = key_set.prompt_for_key
+      end
+      node = CLI.add_options_if_present(node, args, [:alias, :user])
+
+      node_mapper.update_node(node)
+      key_path = key_set.get_key node[:key]
+
+      case args[:action]
+        when :connect
+          Connection.connect node[:host], node[:user], key_path
+        when :push
+          Connection.push node[:host], node[:user], key_path, args[:source], args[:target]
+        when :pull
+          Connection.pull node[:host], node[:user], key_path, args[:source], args[:target]
+        else
+          abort 'Unknown action'
+      end
+    end
+
+    def self.add_options_if_present(node, args, options)
+      options.each { |option|
+        node[option] = args[option] if args.include?(option)
+      }
+      node
+    end
+
+  end
+end

data/lib/ssh_short/connection.rb

@@ -0,0 +1,24 @@
+module SshShort
+
+  class Connection
+
+    def self.connect(ip_address, username, key_path)
+      key_name = File.basename key_path
+      puts "Connecting as #{username} to #{ip_address} using #{key_name}"
+      system "ssh -i #{key_path} #{username}@#{ip_address}"
+    end
+
+    def self.push(ip_address, username, key_path, source, target)
+      key_name = File.basename key_path
+      puts "Pushing #{source} to #{ip_address} at #{target} as #{username} using #{key_name}"
+      system "scp -r -i #{key_path} #{source} #{username}@#{ip_address}:#{target}"
+    end
+
+    def self.pull(ip_address, username, key_path, source, target)
+      key_name = File.basename key_path
+      puts "Pulling #{source} from #{ip_address} as #{username} to #{target} using #{key_name}"
+      system "scp -r -i #{key_path} #{username}@#{ip_address}:#{source} #{target}"
+    end
+
+  end
+end

data/lib/ssh_short/keyset.rb

@@ -0,0 +1,35 @@
+require 'YAML'
+
+module SshShort
+
+  class KeySet
+
+    def initialize(keys_dir)
+      @keys_dir = keys_dir
+    end
+
+    def prompt_for_key
+      abort "Error: Cannot find keys directory at #{@keys_dir}" unless File.exist? @keys_dir
+      keys = Dir.glob("#{@keys_dir}/*").select{ |e| File.file? e }
+      abort "Error: No keys found in #{@keys_dir}" unless keys.count > 0
+
+      key_names = keys.collect { |key| File.basename key }
+
+      puts 'Select a key:'
+      key_names.each_with_index { |key_name, i| puts "#{i}) #{key_name}" }
+
+      key_selection = STDIN.gets.to_i
+      abort "#{key_selection} is not a valid key" if (key_selection >= key_names.count)
+
+      key_names[key_selection]
+    end
+
+    def get_key(key_name)
+      key = "#{@keys_dir}/#{key_name}"
+      abort "Error: Cannot find #{key}" unless File.exist? key
+      key
+    end
+
+  end
+
+end

data/lib/ssh_short/nodemapper.rb

@@ -0,0 +1,84 @@
+module SshShort
+
+  class NodeMapper
+
+    def initialize
+      @node_map_file = SshShort::NODEMAP_FILE
+      @node_map = NodeMapper.read_node_map(@node_map_file)
+    end
+
+    def is_alias?(input)
+      aliases = get_aliases
+      aliases.include? input
+    end
+
+    # returns nil if no matching node is found
+    def get_node(host_or_alias)
+      if is_alias? host_or_alias
+        get_node_by_alias host_or_alias
+      else
+        get_node_by_host host_or_alias
+      end
+    end
+
+    def update_node(node)
+      alias_changed = alias_changed? node
+      if alias_changed
+        existing_node_with_alias = get_node_by_alias(node[:alias])
+        if existing_node_with_alias
+          puts "Moving alias #{node[:alias]} from #{existing_node_with_alias[:host]} to #{node[:host]}"
+          existing_node_with_alias.delete :alias
+          upsert_node existing_node_with_alias
+        end
+      end
+
+      upsert_node node
+
+      NodeMapper.save_node_map(@node_map_file, @node_map)
+      @node_map
+    end
+
+    def get_aliases
+      @node_map.collect { |node| node[:alias] }.compact
+    end
+
+    class << self
+      def read_node_map(node_map_file)
+        File.exist?(node_map_file) ? YAML.load_file(node_map_file) : []
+      end
+
+      def save_node_map(node_map_file, node_map)
+        File.open(node_map_file, 'w') { |fo| fo.puts node_map.to_yaml }
+      end
+    end
+
+    private
+
+    def alias_changed?(node)
+      old_node = get_node_by_host node[:host]
+      old_node ? old_node[:alias] != node[:alias] : true
+    end
+
+    def upsert_node(node)
+      existing_node = get_node_by_host node[:host]
+      if existing_node
+        @node_map.delete existing_node
+      end
+      @node_map.push node
+    end
+
+    def get_node_by_alias(node_alias)
+      nodes = @node_map.find_all { |node| node[:alias] == node_alias }
+      # abort "Error: More than one Node has alias #{node_alias} in Node Map" if (nodes.count > 1)
+      nodes[0]
+    end
+
+    def get_node_by_host(host)
+      nodes = @node_map.find_all { |node| node[:host] == host }
+      # abort "Error: More than one Node has host #{host} in Node Map" if (nodes.count > 1)
+      nodes[0]
+    end
+
+  end
+
+end

data/lib/ssh_short/parser.rb

@@ -0,0 +1,92 @@
+module SshShort
+
+  class Parser
+
+    def self.parse_config
+      abort "Error: Cannot find config file #{SshShort::CONFIG_FILE}" unless config_file_exists?
+      config = YAML.load_file(SshShort::CONFIG_FILE)
+      abort 'Error: Keys directory must be specified' unless config[:keys_dir]
+      config[:keys_dir] = File.expand_path(config[:keys_dir])
+      config
+    end
+
+    def self.config_file_exists?
+      File.exist? SshShort::CONFIG_FILE
+    end
+
+    def self.parse_input(config, args)
+      options = self.key_options args, {}
+      options = self.alias_option args, options
+      options = self.action_options args, options
+      options = self.user_options args, options, config[:default_user]
+      options = self.node_options args, options, config[:ip_mask]
+      options
+    end
+
+    private
+
+    def self.key_options(args, options)
+      options[:force_key_prompt] = args.include? '-k'
+      args.delete '-k'
+      options
+    end
+
+    def self.alias_option(args, options)
+      alias_index = args.index('-a')
+      if alias_index
+        options[:alias] = args[alias_index + 1]
+        2.times { args.delete_at alias_index }
+      end
+      options
+    end
+
+    def self.user_options(args, options, default_user)
+      user_index = args.index('-u')
+      if user_index
+        options[:user] = args[user_index + 1]
+        2.times { args.delete_at user_index }
+      else
+        abort 'No user was provided and no default is set' unless default_user
+        options[:user] = default_user
+      end
+      options
+    end
+
+    def self.action_options(args, options)
+      push_pull_index = args.index('--push') || args.index('--pull')
+      if args.include? '--list'
+        options[:action] = :list_aliases
+        args.delete '--list'
+      elsif push_pull_index
+        options[:action] = args[push_pull_index].gsub('-', '').to_sym
+        options[:source] = args[push_pull_index + 1]
+        options[:target] = args[push_pull_index + 2]
+        3.times { args.delete_at push_pull_index }
+      else
+        options[:action] = :connect
+      end
+      options
+    end
+
+    def self.node_options(args, options, ip_mask)
+      input = args[0]
+      options[:node] = input_is_ip?(input) ? apply_ip_mask(input, ip_mask) : input
+      options
+    end
+
+    def self.input_is_ip?(input)
+      input ? input.match(/^[\d\.]+$/) : false
+    end
+
+    def self.apply_ip_mask(ip, ip_mask)
+      return ip unless ip.match(/^[\d\.]+$/)
+      sections = ip.split('.').count
+      if sections < 4
+        "#{ip_mask.split('.')[0..(3 - sections)].join('.')}.#{ip}"
+      else
+        ip
+      end
+    end
+
+  end
+end

data/lib/ssh_short/version.rb

@@ -0,0 +1,3 @@
+module SshShort
+  VERSION = '0.1.0'
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+# require 'rspec'
+require 'mocha/test_unit'
+
+RSpec.configure do |c|
+  c.color = true
+end

data/spec/ssh_short/nodemapper_spec.rb

@@ -0,0 +1,187 @@
+require 'spec_helper'
+require 'ssh_short/nodemapper'
+
+module SshShort
+  NODEMAP_FILE = nil
+end
+
+describe SshShort::NodeMapper do
+
+  let(:nodemapper) { SshShort::NodeMapper.new }
+  let(:nodemap) {
+    [
+        {:host => '10.0.0.1', :alias => 'alice', :key => 'key_for_alice.pem' },
+        {:host => '10.0.0.2', :alias => 'bob', :key => 'key_for_bob.pem' },
+        {:host => '10.0.0.3', :key => 'key_for_03.pem' },
+    ]
+  }
+
+  before(:each) do
+    allow(File).to receive(:exist?).and_return(true)
+    allow(YAML).to receive(:load_file).and_return(nodemap)
+  end
+
+  describe 'is_alias?' do
+
+    it 'returns true if the alias is in the nodemap' do
+      result = nodemapper.is_alias? 'alice'
+      expect(result).to eq true
+    end
+
+    it 'returns false if the alias is not in the nodemap' do
+      result = nodemapper.is_alias? 'non-ex'
+      expect(result).to eq false
+    end
+
+    it 'returns false if the alias is nil' do
+      result = nodemapper.is_alias? nil
+      expect(result).to eq false
+    end
+
+  end
+
+  describe 'get_node' do
+
+    it 'returns a hash' do
+      node = nodemapper.get_node('10.0.0.1')
+      expect(node).to be_a Hash
+    end
+
+    it 'returns the node matching the host' do
+      host = '10.0.0.1'
+      node = nodemapper.get_node(host)
+      expect(node[:alias]).to eq 'alice'
+    end
+
+    it 'returns the node matching the alias' do
+      node_alias = 'bob'
+      node = nodemapper.get_node(node_alias)
+      expect(node[:host]).to eq '10.0.0.2'
+    end
+
+    it 'returns nil when node does not exist' do
+      node = nodemapper.get_node('non-ex')
+      expect(node).to eq nil
+    end
+
+  end
+
+  describe 'update_node' do
+
+    # Keep the node map simple for these tests
+    let(:nodemap) {
+      [ {:host => '10.0.0.1', :alias => 'alice', :key => 'key_for_alice.pem'} ]
+    }
+
+    before(:each) do
+      allow(SshShort::NodeMapper).to receive(:save_node_map).and_return(nil)
+      allow(nodemapper).to receive(:puts).and_return(nil)
+    end
+
+    it 'returns the updated node map' do
+      # This is just so we can get the array for testing,
+      # although it might be useful in the future?
+      node = nodemap[0]
+      updated_nodemap = nodemapper.update_node(node)
+      expect(updated_nodemap).to eq nodemap
+    end
+
+    it 'adds a new node to the map' do
+      node = {:host => '10.0.0.2', :key => 'key_for_bob.pem'}
+      updated_nodemap = nodemapper.update_node(node)
+      expect(updated_nodemap.count).to eq 2
+      expect(updated_nodemap[1]).to eq node
+    end
+
+    it 'updates an existing node' do
+      node = {:host => '10.0.0.1', :alias => 'alice', :key => 'new_key.pem'}
+      updated_nodemap = nodemapper.update_node(node)
+      expect(updated_nodemap.count).to eq 1
+      expect(updated_nodemap[0]).to eq node
+    end
+
+    context 'when updating the user' do
+
+      let(:node) {
+        node = nodemap[0].clone
+        node[:user] = 'new-user'
+        node
+      }
+      subject(:updated_nodemap) { nodemapper.update_node(node) }
+
+      it 'updates to user' do
+        expect(updated_nodemap[0][:user]).to eq 'new-user'
+      end
+
+      it 'preserves the alias' do
+        expect(updated_nodemap[0][:alias]).to eq 'alice'
+      end
+
+    end
+
+    context 'when the alias already exists on another node' do
+
+      let(:node) { {:host => '10.0.0.6', :alias => 'alice', :key => 'key_for_6.pem'} }
+      subject(:updated_nodemap) { nodemapper.update_node(node) }
+
+      it 'adds the alias to the new node' do
+        expect(updated_nodemap[1][:alias]).to eq 'alice'
+      end
+
+      it 'removes the alias from the old node' do
+        expect(updated_nodemap[0][:alias]).to eq nil
+      end
+
+      it 'prints info message' do
+        allow(nodemapper).to receive(:puts).and_call_original
+        expect {
+          nodemapper.update_node(node)
+        }.to output(/Moving alias alice from .*1 to .*6/).to_stdout
+      end
+
+    end
+
+  end
+
+  describe 'get_aliases' do
+
+    it 'returns all aliases as array' do
+      aliases = nodemapper.get_aliases
+      expect(aliases).to eq ['alice', 'bob']
+    end
+
+    context 'when there are no aliases' do
+
+      let(:nodemap) {
+        [
+            {:host => '10.0.0.1', :key => 'key_for_alice.pem' },
+            {:host => '10.0.0.2', :key => 'key_for_bob.pem' },
+        ]
+      }
+
+      it 'returns an empty array' do
+        aliases = nodemapper.get_aliases
+        expect(aliases).to eq []
+      end
+
+    end
+
+  end
+
+  describe 'read_node_map' do
+
+    it 'loads the node array from YAML' do
+      allow(File).to receive(:exist?).and_return(true)
+      expect(YAML).to receive(:load_file).once.and_return([])
+      SshShort::NodeMapper.read_node_map(nil)
+    end
+
+    it 'returns an empty array if file does not exist' do
+      allow(File).to receive(:exist?).and_return(false)
+      result = SshShort::NodeMapper.read_node_map(nil)
+      expect(result).to eq([])
+    end
+
+  end
+
+end

data/spec/ssh_short/parser_spec.rb

@@ -0,0 +1,182 @@
+require 'spec_helper'
+require 'ssh_short/parser'
+
+describe SshShort::Parser do
+
+  describe 'parse_config' do
+
+    let(:config) {
+      {
+          :default_user => 'ec2-user',
+          :ip_mask => '10.72.0.0',
+          :keys_dir => '~/.ssh/accuity'
+      } }
+
+    before(:each) do
+      stub_const('SshShort::CONFIG_FILE', 'config')
+      allow(SshShort::Parser).to receive(:config_file_exists?).and_return(true)
+      allow(YAML).to receive(:load_file).and_return(config)
+    end
+
+    it 'returns a hash' do
+      config = SshShort::Parser.parse_config
+      expect(config).to be_a Hash
+    end
+
+    it 'parses config keys as symbols' do
+      config = SshShort::Parser.parse_config
+      config.each { |k, v|
+        expect(k).to be_a Symbol
+      }
+    end
+
+    context 'when config file does not exist' do
+
+      before(:each) do
+        allow(SshShort::Parser).to receive(:config_file_exists?).and_return(false)
+      end
+
+      it 'aborts with error message' do
+        expect {
+          expect {
+            SshShort::Parser.parse_config
+          }.to raise_error SystemExit
+        }.to output(/Cannot find config file/).to_stderr
+      end
+    end
+
+    context 'when keys_dir is null' do
+
+      before(:each) do
+        config.delete :keys_dir
+      end
+
+      it 'aborts with error message' do
+        expect {
+          expect {
+            SshShort::Parser.parse_config
+          }.to raise_error SystemExit
+        }.to output(/Keys directory must be specified/).to_stderr
+      end
+    end
+
+  end
+
+  describe 'parse_input' do
+
+    let(:standard_args) {
+      ['6']
+    }
+    let(:config) {
+      { :ip_mask => '10.0.0.0', :default_user => 'user' }
+    }
+
+    before(:each) do
+    end
+
+    it 'applies mask to ip' do
+      options = SshShort::Parser.parse_input(config, standard_args)
+      expect(options[:node]).to eq '10.0.0.6'
+    end
+
+    it 'uses all sections of input ip' do
+      options = SshShort::Parser.parse_input(config, ['1.2.3.4'])
+      expect(options[:node]).to eq '1.2.3.4'
+    end
+
+    it 'uses input as host when input is not ip' do
+      options = SshShort::Parser.parse_input(config, ['frank'])
+      expect(options[:node]).to eq 'frank'
+    end
+
+    context 'when no user is provided' do
+
+      it 'uses the default user from config' do
+        options = SshShort::Parser.parse_input(config, standard_args)
+        expect(options[:user]).to eq 'user'
+      end
+
+      context 'and when config user is null' do
+
+        let(:no_user_config) { config.delete_if{|k, v| k == :default_user} }
+
+        it 'aborts with error message' do
+          expect {
+            expect {
+              SshShort::Parser.parse_input(no_user_config, standard_args)
+            }.to raise_error SystemExit
+          }.to output(/No user was provided/).to_stderr
+        end
+      end
+    end
+
+    context 'when a user is provided' do
+
+      let(:user_args) { ['6', '-u', 'new-user'] }
+
+      it 'extracts the user' do
+        options = SshShort::Parser.parse_input(config, user_args)
+        expect(options[:user]).to eq 'new-user'
+      end
+
+      it 'removes the user args' do
+        options = SshShort::Parser.parse_input(config, user_args)
+        expect(user_args).to_not include '-u'
+        expect(user_args).to_not include 'new-user'
+      end
+    end
+
+    context 'when a new alias is provided' do
+
+      let(:alias_args) { ['6', '-a', 'fred'] }
+
+      it 'extracts the alias' do
+        options = SshShort::Parser.parse_input(config, alias_args)
+        expect(options[:alias]).to eq 'fred'
+      end
+
+      it 'removes the alias args' do
+        options = SshShort::Parser.parse_input(config, alias_args)
+        expect(alias_args).to_not include '-a'
+        expect(alias_args).to_not include 'fred'
+      end
+    end
+
+    it 'skips key prompt when -k flag is not set' do
+      options = SshShort::Parser.parse_input(config, standard_args)
+      expect(options[:force_key_prompt]).to eq false
+    end
+
+    context 'when -k flag is set' do
+
+      let(:key_args) { ['6', '-k'] }
+
+      it 'forces key prompt' do
+        options = SshShort::Parser.parse_input(config, key_args)
+        expect(options[:force_key_prompt]).to eq true
+      end
+
+      it 'removes -k flag from args' do
+        options = SshShort::Parser.parse_input(config, key_args)
+        expect(key_args).to_not include '-k'
+      end
+    end
+
+    context 'when --list flag is set' do
+
+      let(:key_args) { ['--list'] }
+
+      it 'sets the action to :list_aliases' do
+        options = SshShort::Parser.parse_input(config, key_args)
+        expect(options[:action]).to eq :list_aliases
+      end
+
+      it 'removes --list flag from args' do
+        SshShort::Parser.parse_input(config, key_args)
+        expect(key_args).to_not include '--list'
+      end
+    end
+
+  end
+
+end

data/ssh-short.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'ssh_short/version'
+
+excude = ['.gitignore', 'Rakefile']
+
+Gem::Specification.new do |gem|
+  gem.name          = 'ssh-short'
+  gem.version       = SshShort::VERSION
+  gem.description   = 'Easy ssh'
+  gem.summary       = 'Fewer keystrokes to get things done'
+  gem.author        = 'Tom Poulton'
+  gem.license       = 'MIT'
+  gem.homepage      = 'http://github.com/TomPoulton/ssh-short'
+
+  gem.files         = `git ls-files`.split($/).reject { |file| file =~ /^(#{excude.join('|')})$/ }
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+name: ssh-short
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Tom Poulton
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2015-09-23 00:00:00 Z
+dependencies: []
+
+description: Easy ssh
+email: 
+executables: 
+- sshort
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Gemfile
+- LICENSE
+- LICENSE.txt
+- README.md
+- bin/sshort
+- lib/ssh_short/cli.rb
+- lib/ssh_short/connection.rb
+- lib/ssh_short/keyset.rb
+- lib/ssh_short/nodemapper.rb
+- lib/ssh_short/parser.rb
+- lib/ssh_short/version.rb
+- spec/spec_helper.rb
+- spec/ssh_short/nodemapper_spec.rb
+- spec/ssh_short/parser_spec.rb
+- ssh-short.gemspec
+homepage: http://github.com/TomPoulton/ssh-short
+licenses: 
+- MIT
+metadata: {}
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - &id001 
+    - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - *id001
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Fewer keystrokes to get things done
+test_files: 
+- spec/spec_helper.rb
+- spec/ssh_short/nodemapper_spec.rb
+- spec/ssh_short/parser_spec.rb