net-ssh-cli 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a2574b34a1dfb8f75b642937c966a385195fdcd7c193ee420221a89edc55d7ff
+  data.tar.gz: 78ca3a2820d14e8c6b491aa1bf2dafe6ba9cde2666068b07213343b2d7a0cb95
+SHA512:
+  metadata.gz: fd586eee90f7ffc3e44e5d3ea634cef5f9c5748f388d9e12b51f0198a19009031cac6e366c0e48d61abdd38d8bc14ddf4c1225f234efa5977584fdaa09d18591
+  data.tar.gz: 3b60e1eedfc77a445f0d4c5063031bc2db41a29f76d30fb6c738f4e28a7407b2d93c4df84961f8162198f933296b7c63bcdb6edb8e99405646193997c9564ff7

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+*.swp
+coverage
+/*.gem
+/Gemfile.lock

data/.gitlab-ci.yml

@@ -0,0 +1,20 @@
+image: nni-hub.artifactory.safe-mgmt.swisscom.com/ruby-swisscom-certificates:2.6.0
+
+variables:
+  http_proxy: "http://serverproxy.corproot.net:8080"
+  https_proxy: "http://serverproxy.corproot.net:8080"
+  HTTP_PROXY: "http://serverproxy.corproot.net:8080"
+  HTTPS_PROXY: "http://serverproxy.corproot.net:8080"
+  no_proxy: ".swissptt.ch"
+
+stages:
+  - test
+
+test:
+  stage: test
+  script:
+    - bundle install
+    - bundle exec rspec
+#    - bundle exec rubocop
+  tags:
+    - docker

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,9 @@
+inherit_from: .rubocop_todo.yml
+AllCops:
+  Exclude:
+    - 'bin/localhost'
+Metrics/LineLength:
+  Max: 160
+Metrics/BlockLength:
+  Max: 160
+

data/.ruby-version

@@ -0,0 +1 @@
+2.6

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.5.0
+before_install: gem install bundler -v 1.17.1

data/Gemfile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+gem 'foreman'
+gem 'guard-rspec', require: false
+gem 'rubocop', require: false
+gem 'simplecov', require: false
+
+# git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in net-ssh-cli.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec features) \
+#  .select{|d| Dir.exist?(d) ? d : UI.warning("Directory #{d} does not exist")}
+
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * spring: 'bin/rspec' (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: 'zeus rspec' (requires the server to be started separately)
+#  * 'just' rspec: 'rspec'
+
+guard :rspec, cmd: 'bundle exec rspec' do
+  require 'guard/rspec/dsl'
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # Feel free to open issues for suggestions and improvements
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+
+  # Rails files
+  rails = dsl.rails(view_extensions: %w[erb haml slim])
+  dsl.watch_spec_files_for(rails.app_files)
+  dsl.watch_spec_files_for(rails.views)
+
+  watch(rails.controllers) do |m|
+    [
+      rspec.spec.call("routing/#{m[1]}_routing"),
+      rspec.spec.call("controllers/#{m[1]}_controller"),
+      rspec.spec.call("acceptance/#{m[1]}")
+    ]
+  end
+
+  # Rails config changes
+  watch(rails.spec_helper)     { rspec.spec_dir }
+  watch(rails.routes)          { "#{rspec.spec_dir}/routing" }
+  watch(rails.app_controller)  { "#{rspec.spec_dir}/controllers" }
+
+  # Capybara features specs
+  watch(rails.view_dirs)     { |m| rspec.spec.call("features/#{m[1]}") }
+  watch(rails.layouts)       { |m| rspec.spec.call("features/#{m[1]}") }
+
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$}) do |m|
+    Dir[File.join("**/#{m[1]}.feature")][0] || 'spec/acceptance'
+  end
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Fabian Stillhart
+
+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/Procfile

@@ -0,0 +1 @@
+guard: bundle exec guard

data/README.md

@@ -0,0 +1,91 @@
+# Net::SSH::CLI
+
+Adds another layer on top of Net::SSH for a proper handling of CLI sessions which last longer than one command. This is especially usefull for enterprise Switches and Routers.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'net-ssh-cli'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install net-ssh-cli
+
+## Features
+
+ - provides an abstraction on top of the text-stream of a long living CLI sessions
+ - tries to be highly configurable
+ - has methods like #cmd and #dialog for common usecases
+ - offers waiting operations like #read_till
+
+## Usage
+
+```ruby
+Net::SSH.start('host', 'user', password: "password") do |ssh|
+  cli = ssh.open_cli_channel(default_prompt: /(\nuser@host):/m)
+  cli.cmd ""
+  # => "Last login: \nuser@host:"
+
+  cli.cmd "echo 'bananas'"
+  # => "echo 'bananas'\nbananas\nuser@host:"
+end
+```
+
+```ruby
+  net_ssh = Net::SSH.start('host', 'user', password: "password")
+  cli = Net::SSH::CLI::Channel.new(net_ssh: net_ssh)
+  cli.cmd ""
+```
+
+```ruby
+  cli = Net::SSH::CLI::Channel.new(net_ssh_options: {host: 'host', user: 'user', password: 'password'})
+  cli.cmd ""
+```
+
+### #cmd
+```ruby
+  cli = ssh.open_cli_channel(default_prompt: /(\nuser@host):/m)
+  cli.cmd "echo 'bananas'"
+  # => "echo 'bananas'\nbananas\nuser@host:"
+  cli.cmd "echo 'bananas'", rm_command: true
+  # => "bananas\nuser@host:"
+  cli.cmd "echo 'bananas'", rm_prompt: true
+  # => "echo 'bananas'\nbananas"
+  cli.cmd "echo 'bananas'", rm_command: true, rm_prompt: true
+  # => "bananas"
+```
+
+Remove the command and the prompt for #cmd & #dialog by default
+```ruby
+  cli = ssh.open_cli_channel(default_prompt: /(\nuser@host):/m, cmd_rm_command: true, cmd_rm_prompt: true)
+  cli.cmd "echo 'bananas'"
+  # => "bananas"
+```
+
+### #dialog
+```ruby
+  cli.dialog "echo 'are you sure?' && read -p 'yes|no>'", /\nyes|no>/
+  # => "echo 'are you sure?' && read -p 'yes|no>'\nyes|no>"
+  cli.cmd "yes"
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/swisscom/net-ssh-cli.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'net/ssh/cli'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/localhost

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'net/ssh/cli'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+
+def reload!
+  load __FILE__
+end
+
+$CLI = nil
+begin
+  $CLI = Net::SSH::CLI::Channel.new(host: 'localhost', user: ENV['USER'], default_prompt: '@')
+  $CLI.open_channel
+  puts "\nPUTS #{$CLI.read}"
+  sleep 0.3
+  puts "\nPUTS #{$CLI.read}"
+  puts "\nPUTS #{$CLI.write "\n"}"
+  puts "\nPUTS TILL #{$CLI.read_till}"
+  puts "try $CLI.cmd"
+  puts File.read(__FILE__)
+rescue StandardError => error
+  puts error.class
+  puts error.message
+  puts error.backtrace
+ensure
+  IRB.start(__FILE__)
+end

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/net/ssh/cli.rb

@@ -0,0 +1,357 @@
+# frozen_string_literal: true
+
+require 'net/ssh/cli/version'
+require 'net/ssh'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/object/blank'
+require 'timeout'
+require 'logger'
+
+module Net
+  module SSH
+    module CLI
+      class Error < StandardError
+        class Pty < Error; end
+        class RequestShell < Error; end
+        class UndefinedMatch < Error; end
+        class OpenChannelTimeout < Error; end
+        class ReadTillTimeout < Error; end
+      end
+
+      def initialize(**opts)
+        options.merge!(opts)
+        self.net_ssh = options.delete(:net_ssh)
+        self.logger = options.delete(:logger) || Logger.new(STDOUT, level: Logger::WARN)
+        open_channel unless lazy
+        @with_prompt = []
+      end
+
+      attr_accessor :channel, :stdout, :stderr, :net_ssh, :logger
+
+      ## make everthing configurable!
+      #
+
+      DEFAULT = ActiveSupport::HashWithIndifferentAccess.new(
+        default_prompt: /^(\S+@\S+\s*)/,
+        process_time: 0.00001,
+        read_till_timeout: nil,
+        read_till_rm_prompt: false,
+        cmd_rm_prompt: false,
+        cmd_rm_command: false,
+        lazy: true
+      )
+
+      def default
+        @default ||= DEFAULT.clone
+      end
+
+      def default!(**defaults)
+        default.merge!(**defaults)
+      end
+
+      # don't even think about nesting hashes here
+      def options
+        @options ||= default
+      end
+
+      # don't even think about nesting hashes here
+      def options!(**opts)
+        options.merge!(opts)
+      end
+
+      # don't even think about nesting hashes here
+      def options=(opts)
+        @options = ActiveSupport::HashWithIndifferentAccess.new(opts)
+      end
+
+      %i[default_prompt process_time read_till_timeout cmd_rm_command cmd_rm_prompt read_till_rm_prompt lazy].each do |name|
+        define_method name do
+          options[name]
+        end
+        define_method "#{name}=" do |value|
+          options[name] = value
+        end
+      end
+
+      %i[process_stdout_procs process_stderr_procs named_prompts net_ssh_options open_channel_options].each do |name|
+        define_method name do
+          options[name] ||= ActiveSupport::HashWithIndifferentAccess.new
+        end
+        define_method "#{name}!" do |**opts|
+          send(name).merge!(**opts)
+        end
+        define_method "#{name}=" do |value|
+          options[name] = ActiveSupport::HashWithIndifferentAccess.new(value)
+        end
+      end
+
+      ## Net::SSH instance
+      #
+
+      def net_ssh
+        return @net_ssh if @net_ssh
+
+        logger.debug { 'Net:SSH #start' }
+        self.net_ssh = Net::SSH.start(net_ssh_options[:ip] || net_ssh_options[:host], net_ssh_options[:user] || ENV['USER'], net_ssh_options)
+      rescue StandardError => error
+        self.net_ssh = nil
+        raise
+      end
+      alias proxy net_ssh
+
+      def host
+        net_ssh_options[:host] || net_ssh_options[:hostname] || net_ssh_options[:ip] || @net_ssh&.host
+      end
+      alias to_s host
+      alias hostname host
+
+      def ip
+        net_ssh_options[:ip]
+      end
+
+      ## channel & stderr|stdout stream handling
+      #
+
+      def stdout
+        @stdout ||= String.new
+      end
+
+      def stdout!
+        var = stdout
+        self.stdout = String.new
+        var
+      end
+
+      def stderr
+        @stderr ||= String.new
+      end
+
+      def stderr!
+        var = stderr
+        self.stderr = String.new
+        var
+      end
+
+      def open_channel # cli_channel
+        ::Timeout.timeout(open_channel_options[:timeout], Error::OpenChannelTimeout) do
+          net_ssh.open_channel do |channel_|
+            logger.debug 'channel is open'
+            self.channel = channel_
+            channel_.request_pty do |_ch, success|
+              raise Error::Pty, "#{host || ip} Failed to open ssh pty" unless success
+            end
+            channel_.send_channel_request('shell') do |_ch, success|
+              raise Error::RequestShell, 'Failed to open ssh shell' unless success
+            end
+            channel_.on_data do |_ch, data|
+              process_stdout(data)
+            end
+            channel_.on_extended_data do |_ch, type, data|
+              process_stderr(data, type)
+            end
+            channel_.on_close do
+              close
+            end
+          end
+          until channel do process end
+        end
+        logger.debug 'channel is ready, running callbacks now'
+        read_till if open_channel_options[:after_read_till_prompt]
+        open_channel_options[:after_proc]&.call
+        process
+      rescue StandardError => error
+        close
+        raise
+      end
+
+      def process_stdout(data)
+        stdout << data
+        process # if we receive data, we probably receive more - improves performance
+        process_stdout_procs.each { |_name, a_proc| a_proc.call }
+        stdout
+      end
+
+      def process_stderr(data, _type)
+        stderr << data
+        process # if we receive data, we probably receive more - improves performance
+        process_stderr_procs.each { |_name, a_proc| a_proc.call }
+        stderr
+      end
+
+      def write(content = String.new)
+        raise Error, 'channel is not stablished or gone' unless channel
+
+        logger.debug { "#write #{content.inspect}" }
+        channel.send_data content
+        process
+        content
+      end
+
+      def write_n(content = String.new)
+        write content + "\n"
+      end
+
+      # returns the stdout buffer and empties it
+      def read
+        process
+        var = stdout!
+        logger.debug("#read: \n#{var}")
+        var
+      end
+
+      ## fancy prompt|prompt handling methods
+      #
+
+      def current_prompt
+        @with_prompt[-1] || default_prompt
+      end
+
+      def with_named_prompt(name)
+        raise Error::UndefinedMatch, "unknown named_prompt #{name}" unless named_prompts[name]
+
+        with_prompt(named_prompts[name]) do
+          yield
+        end
+      end
+
+      def detect_prompt(seconds: 5)
+        process(seconds)
+        self.default_prompt = read[/\n.*\n?\z/]
+      end
+
+      # prove a block where the default prompt changes
+      def with_prompt(prompt)
+        logger.debug { "#with_prompt: #{current_prompt.inspect} => #{prompt.inspect}" }
+        @with_prompt << prompt
+        yield
+        prompt
+      ensure
+        @with_prompt.delete_at(-1)
+        logger.debug { "#with_prompt: => #{current_prompt.inspect}" }
+      end
+
+      def read_till(prompt: current_prompt, timeout: read_till_timeout, **_opts)
+        raise Error::UndefinedMatch, 'no prompt given or default_prompt defined' unless prompt
+
+        ::Timeout.timeout(timeout, Error::ReadTillTimeout.new("output did not prompt #{prompt.inspect} within #{timeout}")) do
+          with_prompt(prompt) do
+            process until stdout[current_prompt]
+          end
+        end
+        read
+      end
+
+      def read_for(seconds:)
+        process
+        sleep seconds
+        process
+        read
+      end
+
+      def dialog(command, prompt, **opts)
+        pre_read = read
+        logger.debug { "#dialog ignores the following pre-output #{pre_read.inspect}" } if pre_read.present?
+        write command
+        output = read_till(prompt: prompt, **opts)
+        rm_prompt!(output, prompt: prompt, **opts)
+        rm_command!(output, command, prompt: prompt, **opts)
+        output
+      end
+
+      # 'read' first on purpuse as a feature. once you cmd you ignore what happend before. otherwise use read|write directly.
+      # this should avoid many horrible state issues where the prompt is not the last prompt
+      def cmd(command, **opts)
+        pre_read = read
+        logger.debug { "#cmd ignoring pre-read: #{pre_read.inspect}" } if pre_read.present?
+        write_n command
+        output = read_till(**opts)
+        rm_prompt!(output, **opts)
+        rm_command!(output, command, **opts)
+        output
+      end
+      alias command cmd
+
+      def cmds(commands, **opts)
+        commands.map { |command| [command, cmd(command, **opts)] }
+      end
+      alias commands cmds
+
+      def rm_command?(**opts)
+        opts[:rm_cmd].nil? ? cmd_rm_command : opts[:rm_cmd]
+      end
+
+      def rm_command!(output, command, **opts)
+        output[command + "\n"] = '' if rm_command?(opts) && output[command + "\n"]
+      end
+
+      def rm_prompt?(**opts)
+        opts[:rm_prompt].nil? ? cmd_rm_prompt : opts[:rm_prompt]
+      end
+
+      def rm_prompt!(output, **opts)
+        if rm_prompt?(opts)
+          prompt = opts[:prompt] || current_prompt
+          if output[prompt]
+            prompt.is_a?(Regexp) ? output[prompt, 1] = '' : output[prompt] = ''
+          end
+        end
+      end
+
+      ## NET::SSH
+      #
+
+      def process(time = process_time)
+        net_ssh.process(time)
+      rescue IOError => error
+        raise Error, error.message
+      end
+
+      def close
+        return unless net_ssh
+
+        net_ssh.cleanup_channel(channel) if channel
+        self.channel = nil
+        # ssh.close if ssh.channels.none? # should the connection be closed if the last channel gets closed?
+      end
+
+      def connect
+        open_channel unless channel
+      end
+
+      def reconnect
+        disconnect
+        connect
+      end
+
+      # feels wrong
+
+      def disconnect
+        close
+        net_ssh&.close
+        self.net_ssh = nil
+      end
+
+      def shutdown!
+        net_ssh&.shutdown!
+      end
+
+      private
+
+    end
+  end
+end
+
+class Net::SSH::CLI::Channel
+  include Net::SSH::CLI
+  def initialize(**options)
+    super
+    # open_channel
+  end
+end
+
+class Net::SSH::Connection::Session
+  attr_accessor :cli_channels
+  def open_cli_channel(**opts)
+    Net::SSH::CLI::Channel.new({ net_ssh: self, lazy: false }.merge(opts))
+  end
+end

data/lib/net/ssh/cli/version.rb

@@ -0,0 +1,7 @@
+module Net
+  module SSH
+    module CLI
+      VERSION = "0.1.0"
+    end
+  end
+end

data/net-ssh-cli.gemspec

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'net/ssh/cli/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'net-ssh-cli'
+  spec.version       = Net::SSH::CLI::VERSION
+  spec.authors       = ['Fabian Stillhart']
+  spec.email         = ['fabian.stillhart1@swisscom.com']
+
+  spec.summary       = 'Net::SSH::CLI: A library to handle CLI Sessions'
+  spec.description   = 'Net::SSH::CLI: A library to handle CLI Sessions. It allows you to write programs that invoke and interact with (long-running) CLI Sessions via NET::SSH.'
+  spec.homepage      = 'https://github.com/swisscom/net-ssh-cli'
+  spec.license       = 'MIT'
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  # if spec.respond_to?(:metadata)
+  #  spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+
+  #  spec.metadata["homepage_uri"] = spec.homepage
+  #  spec.metadata["source_code_uri"] = "TODO: Put your gem's public repo URL here."
+  #  spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+  # else
+  #  raise "RubyGems 2.0 or newer is required to protect against " \
+  #    "public gem pushes."
+  # end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.17'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_dependency 'activesupport', '>= 4.0'
+  spec.add_dependency 'net-ssh', '>= 4.0'
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: net-ssh-cli
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Fabian Stillhart
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-02-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: net-ssh
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+description: 'Net::SSH::CLI: A library to handle CLI Sessions. It allows you to write
+  programs that invoke and interact with (long-running) CLI Sessions via NET::SSH.'
+email:
+- fabian.stillhart1@swisscom.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".gitlab-ci.yml"
+- ".rspec"
+- ".rubocop.yml"
+- ".rubocop_todo.yml"
+- ".ruby-version"
+- ".travis.yml"
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- Procfile
+- README.md
+- Rakefile
+- bin/console
+- bin/localhost
+- bin/setup
+- lib/net/ssh/cli.rb
+- lib/net/ssh/cli/version.rb
+- net-ssh-cli.gemspec
+homepage: https://github.com/swisscom/net-ssh-cli
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.2
+signing_key: 
+specification_version: 4
+summary: 'Net::SSH::CLI: A library to handle CLI Sessions'
+test_files: []