tarkin 0.9.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 35f0d3f9b104422ff8e9006fdc86edc172a2bced
+  data.tar.gz: 07f422fe6aa640ce741e1db7e5c606066bdbec5b
+SHA512:
+  metadata.gz: 43ee41bc484127095e744870924552bbb11b595ff22dcffd15c9c4bf96950764298b2ee6d000e04707400f7bb945b80c1c5e41233b7a438bb765143016f94bcf
+  data.tar.gz: c83d91be2afe5deb122360ac73f0ca543b771a06749f9ab78786ad6b42f3560a9e2c9dbd2d2891a088fcc0a633de4a3c0d297a55c93e4d6b668c8cfd906b1f17

data/bin/tarkin

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+require 'tarkin'
+require 'optparse'
+require 'highline/import'
+require 'open-uri'
+include CommandLineReporter if require 'command_line_reporter'
+require 'tarkin_commands'
+require 'tarkin_sh'
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: tarkin [options] [PATH TO PASSWORD*]"
+  opts.separator "Client for Tarkin Team Password Manager: https://github.com/grych/tarkin"
+  opts.separator "Options:"
+  opts.on("-l", "--ls PATH", "Lists the directory") do |p|
+    options[:ls] = p
+  end
+  opts.on("-f", "--find TERM", "Search for items and directories, may use asterisks *") do |p|
+    options[:find] = p
+  end
+  opts.on("-x", "--long", "Long listing (like ls -l)") do |l|
+    options[:long] = l
+  end
+  opts.separator "Examples:"
+  opts.separator "tarkin /db/prod/oracle/scott"
+  opts.separator "tarkin --long --list /db/prod"
+  opts.separator "tarkin --find scott"
+end.parse!
+
+# pp options
+
+paths = ARGV
+
+client = TarkinClient.new
+commands = TarkinCommands.new(client)
+
+if options[:ls]
+  commands.ls(options[:ls], options[:long])
+elsif options[:find]
+  commands.find(options[:find])
+elsif paths.empty?
+  TarkinSh.start client, commands
+else
+  paths.each do |pwd|
+    if pwd[/^-?\d+$/]
+      pwd = pwd.to_i 
+    else
+      pwd = URI::encode(pwd)
+    end
+    begin
+      commands.cat(pwd)
+    rescue TarkinClientException => e
+      puts "Not found (#{e.message})"
+    end
+  end
+end
+

data/lib/cmd.rb

@@ -0,0 +1,568 @@
+# From: https://github.com/hamxiaoz/cmd
+# minor fixed to work with >= 1.9.3 by Tomek 'Grych' Gryszkiewicz <grych@tg.pl>
+#
+
+READLINE_SUPPORTED = (require 'readline'; true) rescue false
+require 'abbrev'
+
+# A simple framework for writing line-oriented command interpreters, based 
+# heavily on Python's {cmd.py}[http://docs.python.org/lib/module-cmd.html].
+# 
+# These are often useful for test harnesses, administrative tools, and
+# prototypes that will later be wrapped in a more sophisticated interface.
+# 
+# A Cmd instance or subclass instance is a line-oriented interpreter
+# framework.  There is no good reason to instantiate Cmd itself; rather,
+# it's useful as a superclass of an interpreter class you define yourself
+# in order to inherit Cmd's methods and encapsulate action methods.
+class Cmd
+
+  module ClassMethods
+    @@docs      = {}
+    @@shortcuts = {}
+    @@handlers  = {}
+    @@prompt    = '> '
+    @@shortcut_table = {}
+    
+    # Set documentation for a command
+    #
+    #   doc :help, 'Display this help.'
+    #   def do_help
+    #     # etc
+    #   end
+    def doc(command, docstring = nil)
+      docstring = docstring ? docstring : yield
+      @@docs[command.to_s] = docstring
+    end
+
+    def docs
+      @@docs
+    end
+    module_function :docs
+
+    # Set what to do in the event that the given exception is raised.
+    #
+    #   handle StackOverflowError, :handle_stack_overflow
+    #
+    def handle(exception, handler)
+      @@handlers[exception.to_s] = handler
+    end
+    module_function :handle
+
+    # Sets what the prompt is. Accepts a String, a block or a Symbol.
+    #
+    # == Block 
+    #
+    #   prompt_with { Time.now }
+    #
+    # == Symbol
+    #
+    #   prompt_with :set_prompt
+    #
+    # == String
+    #
+    #   prompt_with "#{self.class.name}> "
+    #
+    def prompt_with(*p, &block)
+      @@prompt = block_given? ? block : p.first
+    end
+
+    # Returns the evaluation of expression passed to prompt_with. Result has
+    # +to_s+ called on it as Readline expects a String for its prompt.
+    # XXX This could probably be more robust
+    def prompt
+      case @@prompt
+      when Symbol 
+          self.send @@prompt
+      when Proc   
+          @@prompt.call
+      else         
+          @@prompt
+      end.to_s
+    end
+    module_function :prompt
+
+    # Create a command short cut
+    #
+    #   shortcut '?', 'help'
+    #   def do_help
+    #     # etc
+    #   end
+    def shortcut(short, command)
+      (@@shortcuts[command.to_s] ||= []).push short
+      @@shortcut_table[short] = command.to_s
+    end
+
+    def shortcut_table
+      @@shortcut_table
+    end
+    module_function :shortcut_table
+
+    def shortcuts
+      @@shortcuts
+    end
+    module_function :shortcuts
+
+    def custom_exception_handlers
+      @@handlers
+    end
+    module_function :custom_exception_handlers
+
+    # Defines a method which returns all defined methods which start with the
+    # passed in prefix followed by an underscore. Used to define methods to
+    # collect things such as all defined 'complete' and 'do' methods.
+    def define_collect_method(prefix)
+      method = 'collect_' + prefix
+      unless self.respond_to?(method) 
+        define_method(method) do
+          self.methods.grep(/^#{prefix}_/).map {|meth| meth[prefix.size + 1..-1]}
+        end
+      end
+    end
+  end
+  extend  ClassMethods
+  include ClassMethods
+
+  @hide_undocumented_commands = nil
+  class << self
+    # Flag that sets whether undocumented commands are listed in the help
+    attr_accessor :hide_undocumented_commands
+
+    def run(intro = nil)
+      new.cmdloop(intro)
+    end
+  end
+
+  # STDIN stream used
+  attr_writer :stdin
+
+  # STDOUT stream used
+  attr_writer :stdout
+
+  # The current command
+  attr_writer :current_command
+
+  prompt_with :default_prompt
+
+  def initialize
+    @stdin, @stdout = STDIN, STDOUT
+    @stop = false
+    setup
+  end 
+
+  # Starts up the command loop
+  def cmdloop(intro = nil)
+    preloop
+    write intro if intro
+    begin
+      set_completion_proc(:complete)
+      begin
+        execute_command
+      # Catch ^C
+      rescue Interrupt
+        user_interrupt
+      # I don't know why ZeroDivisionError isn't caught below...
+      rescue ZeroDivisionError
+        handle_all_remaining_exceptions(ZeroDivisionError)
+      rescue => exception
+        handle_all_remaining_exceptions(exception)
+      end
+    end until @stop
+    postloop
+  end
+  alias :run :cmdloop
+
+  shortcut '?', 'help'
+  doc :help,  'This help message.' 
+  def do_help(command = nil)
+    if command
+      command = translate_shortcut(command)
+      docs.include?(command) ? print_help(command) : no_help(command)
+    else
+      documented_commands.each {|cmd| print_help cmd}
+      print_undocumented_commands if undocumented_commands?
+    end
+  end
+
+  # Called when the +command+ has no associated documentation, this could
+  # potentially mean that the command is non existant
+  def no_help(command)
+    write "No help for command '#{command}'"
+  end
+
+  doc :exit,  'Terminate the program.' 
+  def do_exit; stoploop end
+
+  # Turns off readline even if it is supported
+  def turn_off_readline
+    @readline_supported = false
+    self
+  end
+
+  protected
+
+    def execute_command
+      unless ARGV.empty?
+        stoploop
+        execute_line(ARGV * ' ')
+      else
+        execute_line(display_prompt(prompt, true))
+      end
+    end
+
+    def handle_all_remaining_exceptions(exception)
+      if exception_is_handled?(exception) 
+        run_custom_exception_handling(exception) 
+      else
+        handle_exception(exception)
+      end
+    end
+
+    def execute_line(command)
+      postcmd(run_command(precmd(command)))
+    end
+
+    def stoploop
+      @stop = true
+    end
+
+    # Indicates whether readline support is enabled
+    def readline_supported?
+      @readline_supported = READLINE_SUPPORTED if @readline_supported.nil?
+      @readline_supported
+    end
+
+    # Determines if the given exception has a custome handler.
+    def exception_is_handled?(exception)
+      custom_exception_handler(exception)
+    end
+
+    # Runs the customized exception handler for the given exception.
+    def run_custom_exception_handling(exception)
+      case handler = custom_exception_handler(exception)
+      when String
+          write handler 
+      when Symbol
+          # grych@tg.pl FIX: added exception as an argument
+          self.send(handler, exception)
+      end
+    end
+
+    # Returns the customized handler for the exception
+    def custom_exception_handler(exception)
+      # grych@tg.pl FIX, was: exception.to_s which return exception message in ruby >=(?) 1.9.3
+      custom_exception_handlers[exception.class.to_s]
+    end
+
+
+    # Called at object creation. This can be treated like 'initialize' for sub
+    # classes.
+    def setup
+    end
+
+    # Exceptions in the cmdloop are caught and passed to +handle_exception+.
+    # Custom exception classes must inherit from StandardError to be 
+    # passed to +handle_exception+.
+    def handle_exception(exception)
+      raise exception
+    end
+
+    # Displays the prompt. 
+    def display_prompt(prompt, with_history = true)
+      line = if readline_supported?
+        Readline::readline(prompt, with_history)
+      else
+        print prompt
+        @stdin.gets
+      end
+      line.respond_to?(:strip) ? line.strip : line
+    end
+
+    # The current command.
+    def current_command
+      translate_shortcut @current_command
+    end
+
+    # Called when the user hits ctrl-C or ctrl-D. Terminates execution by default.
+    def user_interrupt
+      write 'Terminating' # XXX get rid of this
+      stoploop
+    end
+
+    # XXX Not implementd yet. Called when a do_ method that takes arguments doesn't get any
+    def arguments_missing
+      write 'Invalid arguments'
+      do_help(current_command) if docs.include?(current_command)
+    end
+
+    # A bit of a hack I'm afraid. Since subclasses will be potentially
+    # overriding user_interrupt we want to ensure that it returns true so that
+    # it can be called with 'and return'
+    def interrupt
+      user_interrupt or true
+    end
+
+    # Displays the help for the passed in command.
+    def print_help(cmd)
+      offset = docs.keys.longest_string_length
+      write "#{cmd.ljust(offset)} -- #{docs[cmd]}"            + 
+      (has_shortcuts?(cmd) ? " #{display_shortcuts(cmd)}" : '')
+    end
+
+    def display_shortcuts(cmd)
+      "(aliases: #{shortcuts[cmd].join(', ')})"
+    end
+
+    # The method name that corresponds to the passed in command.
+    def command(cmd)
+      "do_#{cmd}".intern
+    end
+
+    # The method name that corresponds to the complete command for the pass in
+    # command.
+    def complete_method(cmd)
+      "complete_#{cmd}".intern
+    end
+
+    # Call back executed at the start of the cmdloop.
+    def preloop
+    end
+    
+    # Call back executed at the end of the cmdloop.
+    def postloop
+    end
+
+    # Receives line submitted at prompt and passes it along to the command
+    # being called.
+    def precmd(line)
+      line
+    end
+    
+    # Receives the returned value of the called command.
+    def postcmd(line)
+      line
+    end
+    
+    # Called when an empty line is entered in response to the prompt.
+    def empty_line
+    end
+
+    define_collect_method('do')
+    define_collect_method('complete')
+
+    # The default completor. Looks up all do_* methods.
+    def complete(command)
+      commands = completion_grep(command_list, command)
+      if commands.size == 1
+        cmd = commands.first
+        set_completion_proc(complete_method(cmd)) if collect_complete.include?(cmd)
+      end
+      commands
+    end
+
+    # Lists of commands (i.e. do_* methods minus the 'do_' part).
+    def command_list
+      collect_do - subcommand_list
+    end
+
+    # Definitive list of shortcuts and abbreviations of a command.
+    def command_lookup_table 
+      return @command_lookup_table if @command_lookup_table
+      @command_lookup_table = command_abbreviations.merge(shortcut_table)
+    end
+
+    # Returns lookup table of unambiguous identifiers for commands.
+    def command_abbreviations
+      return @command_abbreviations if @command_abbreviations
+      @command_abbreviations = Abbrev::abbrev(command_list)
+    end
+
+    # List of all subcommands.
+    def subcommand_list
+      with_underscore, without_underscore = collect_do.partition {|command| command.include?('_')}
+      with_underscore.find_all {|do_method| without_underscore.include?(do_method[/^[^_]+/])}
+    end
+
+    # Lists all subcommands of a given command.
+    def subcommands(command)
+      completion_grep(subcommand_list, translate_shortcut(command).to_s + '_')
+    end
+
+    # Indicates whether a given command has any subcommands.
+    def has_subcommands?(command)
+      !subcommands(command).empty?
+    end
+
+    # List of commands which are documented.
+    def documented_commands
+      docs.keys.sort
+    end
+
+    # Indicates whether undocummented commands will be listed by the help
+    # command (they are listed by default).
+    def undocumented_commands_hidden?
+      self.class.hide_undocumented_commands  
+    end
+
+    def print_undocumented_commands
+      return if undocumented_commands_hidden?
+      # TODO perhaps do some fancy stuff so that if the number of undocumented
+      # commands is greater than 80 cols or some such passed in number it
+      # presents them in a columnar fashion much the way readline does by default
+      write ' '
+      write 'Undocumented commands'
+      write '====================='
+      write undocumented_commands.join(' ' * 4)
+    end
+
+    # Returns list of undocumented commands.
+    def undocumented_commands
+      command_list - documented_commands
+    end
+
+    # Indicates if any commands are undocumeted.
+    def undocumented_commands?
+      !undocumented_commands.empty?
+    end
+
+    # Completor for the help command.
+    def complete_help(command)
+      completion_grep(documented_commands, command)
+    end
+
+    def completion_grep(collection, pattern)
+      collection.grep(/^#{Regexp.escape(pattern)}/)
+    end
+
+    # Writes out a message with newline.
+    def write(*strings)
+      # We want newlines at the end of every line, so don't join with "\n"
+      strings.each do |string|
+        @stdout.write string
+        @stdout.write "\n"
+      end
+    end
+    alias :puts :write
+
+    # Writes out a message without newlines appended.
+    def print(*strings)
+      strings.each {|string| @stdout.write string}
+    end
+
+    # shortcut '!', 'shell'
+    # doc :shell, 'Executes a shell.'
+    # # Executes a shell, perhaps should only be defined by subclasses.
+    # def do_shell(line)
+    #   shell = ENV['SHELL']
+    #   line ? write(%x(#{line}).strip) : system(shell)
+    # end
+
+    # Takes care of collecting the current command and its arguments if any and
+    # dispatching the appropriate command.
+    def run_command(line)
+      cmd, args = parse_line(line)
+      sanitize_readline_history(line) if line
+      unless cmd then empty_line; return end
+
+      cmd = translate_shortcut(cmd)
+      self.current_command = cmd
+      set_completion_proc(complete_method(cmd)) if collect_complete.include?(complete_method(cmd))
+      cmd_method = command(cmd)
+      if self.respond_to?(cmd_method) 
+        # Perhaps just catch exceptions here (related to arity) and call a
+        # method that reports a generic error like 'invalid arguments'
+        self.method(cmd_method).arity.zero? ? self.send(cmd_method) : self.send(cmd_method, tokenize_args(args)) 
+      else                              
+        command_missing(current_command, tokenize_args(args))
+      end
+    end
+
+    # Receives the line as it was passed from the prompt (barring modification
+    # in precmd) and splits it into a command section and an args section. The
+    # args are by default set to nil if they are boolean false or empty then
+    # joined with spaces. The tokenize method can be used to further alter the
+    # args.
+    def parse_line(line)
+      # line will be nil if ctr-D was pressed
+      user_interrupt and return if line.nil? 
+
+      cmd, *args = line.split
+      args = args.empty? ? nil : args * ' '
+      if args and has_subcommands?(cmd)
+        if cmd = find_subcommand_in_args(subcommands(cmd), line.split)
+          # XXX Completion proc should be passed array of subcommands somewhere
+          args = line.split.join('_').match(/^#{cmd}/).post_match.gsub('_', ' ').strip
+          args = nil if args.empty?
+        end
+      end
+      [cmd, args]
+    end
+
+    # Extracts a subcommand if there is one from the command line submitted. I guess this is a hack. 
+    def find_subcommand_in_args(subcommands, args)
+      (subcommands & (1..args.size).to_a.map {|num_elems| args.first(num_elems).join('_')}).max
+    end
+
+    # Looks up command shortcuts (e.g. '?' is a shortcut for 'help'). Short
+    # cuts can be added by using the shortcut class method.
+    def translate_shortcut(cmd)
+      command_lookup_table[cmd] || cmd
+    end
+
+    # Indicates if the passed in command has any registerd shortcuts.
+    def has_shortcuts?(cmd)
+      command_shortcuts(cmd)
+    end
+
+    # Returns the set of registered shortcuts for a command, or nil if none.
+    def command_shortcuts(cmd)
+      shortcuts[cmd]  
+    end
+
+    # Called on command arguments as they are passed into the command.
+    def tokenize_args(args)
+      args
+    end
+
+    # Cleans up the readline history buffer by performing tasks such as
+    # removing empty lines and piggy-backed duplicates. Only executed if
+    # running with readline support.
+    def sanitize_readline_history(line)
+      return unless readline_supported? 
+      # Strip out empty lines
+      Readline::HISTORY.pop if line.match(/^\s*$/)
+      # Remove duplicates
+      Readline::HISTORY.pop if Readline::HISTORY[-2] == line rescue IndexError
+    end
+
+    # Readline completion uses a procedure that takes the current readline
+    # buffer and returns an array of possible matches against the current
+    # buffer. This method sets the current procedure to use. Commands can
+    # specify customized completion procs by defining a method following the
+    # naming convetion complet_{command_name}.
+    def set_completion_proc(cmd)
+      return unless readline_supported?
+      Readline.completion_proc = self.method(cmd)
+    end
+
+    # Called when the line entered at the prompt does not map to any of the
+    # defined commands. By default it reports that there is no such command.
+    def command_missing(command, args)
+      write "No such command '#{command}'"
+    end
+
+    def default_prompt
+      "#{self.class.name}> "
+    end
+
+end
+
+module Enumerable #:nodoc:
+  def longest_string_length
+    inject(0) {|longest, item| longest >= item.size ? longest : item.size}
+  end
+end
+
+if __FILE__ == $0
+  Cmd.run
+end

data/lib/tarkin.rb

@@ -0,0 +1,201 @@
+require 'highline/import'
+require 'yaml'
+
+require 'arest'
+
+class TarkinClientException < StandardError; end
+
+class TarkinClient
+  SETTINGS_FILES = ["#{Dir.home}/.tarkin", ".tarkin", "/etc/tarkin"]
+  API = "_api/v1"
+
+  attr_accessor :settings
+  attr_reader :api_client
+
+  # Constructor. Needs to know the Tarkin Server parameters.
+  # They can be passed with three differen ways::
+  #
+  # * the options hash. Notice that in this case the token will not be stored in the ~/.tarkin file
+  #   >> tc = TarkinClient.new email: 'user@example.com', password: 'password0', tarkin_url: 'http://tarkin.tg.pl'
+  #   # TarkinClient <server: http://tarkin.tg.pl, authorized: true>
+  #   >> tc = TarkinClient.new tarkin_url: 'http://tarkin.tg.pl', token: 'Ahoishwqbn32ldhw......'
+  #   # TarkinClient <server: http://tarkin.tg.pl, authorized: true>
+  #
+  # * by reading the stored parameters in settings file (like ~/.tarkin)  
+  #   >> tc = TarkinClient.new
+  #   # TarkinClient <server: http://localhost:3000, authorized: true>
+  #
+  # * by asking user via command line (when file not found)
+  #   >> tc = TarkinClient.new
+  #   # Your Tarkin server URL: |http://tarkin.tg.pl| http://localhost:3000
+  #   # Your Tarkin account email: |user@example.com| grychu@gmail.com
+  #   # Password for grychu@gmail.com: ********
+  #   # TarkinClient <server: http://localhost:3000, authorized: true>
+  def initialize(**options)
+    @authorized = false  
+    @settings = {}  
+    if options[:email] && options[:password] && options[:tarkin_url]
+      @settings = options.select { |k,v| [:email, :tarkin_url].include? k }
+      @settings[:token] = get_token(@settings[:email], options[:password])
+    elsif options[:token] && options[:tarkin_url]
+      @settings[:tarkin_url] = options[:tarkin_url]
+      @settings[:token] = options[:token]
+    else
+      get_settings
+      save_settings
+    end
+    @api_client = ARest.new(api_url, token: @settings[:token])
+  end
+
+  # Returns Hash containing :id, :username and :password
+  # Gets Item.id or full path to the Item as a parameter
+  #
+  #   >> tc.password(107)
+  #   # {
+  #   #       "id" => 110,
+  #   # "username" => "sysdba",
+  #   # "password" => "secret_top"
+  #   # }
+  #
+  #   >> tc.password('/db/oracle/C84PCPY/sysdba')
+  #   # {
+  #   #       "id" => 110,
+  #   # "username" => "sysdba",
+  #   # "password" => "secret_top"
+  #   # }
+  def password(path_or_id)
+    case path_or_id
+    when String
+      # full path given
+      u = "#{path_or_id}.json"
+    when Fixnum
+      # Item ID given
+      u = "_password/#{path_or_id}.json"
+    end
+    response = @api_client.get(u)
+    if response.ok?
+      response.deserialize
+    else
+      raise TarkinClientException, "Can't get password, server returns #{response.code}: #{response.message}"
+    end
+  end
+
+  # Returns the content of given directory 
+  # Output is a hash containing:
+  # * directories => [ {:name, :id, :created_at, :updated_at, :description} ]
+  # * items =>   [ {:username, :id, :created_at, :updated_at, :description} ]
+  #
+  #   > tc.ls '/db/prod/oracle'
+  #   #> {:directories=>
+  #     [{:name=>"C84PROD", :id=>14, :created_at=>"2015-06-07T10:36:56.463Z", :updated_at=>"2015-06-07T10:36:56.463Z", :description=>"Production"}],
+  #     :items=>
+  #      [{:id=>6,
+  #       :username=>"scott",
+  #       :created_at=>"2015-06-07T10:38:27.981Z",
+  #       :updated_at=>"2015-06-07T10:38:27.981Z",
+  #       :description=>"The same user in all production databases"}]}
+  def ls(path = '/')
+    u = path.strip.chomp.sub(/(\/)+$/,'') # remove trailing slashes
+    u = if u == '' then '_dir.json' else "_dir/#{u}.json" end
+    response = @api_client.get(u)
+    if response.ok?
+      response.deserialize
+    else
+      if response.code == "404"
+        raise TarkinClientException, "No such file or directory"
+      else
+        raise TarkinClientException, "Can't list directory, server returns #{response.code}: #{response.message}"
+      end
+    end
+  end
+
+  # Search for a username or directory
+  # Input: a String to search, may contain wildcard (*)
+  # Output: array of hashes: [ { :label, :redirect_to }]
+  #
+  #   > tc.find 'sys'
+  #   #> [{:label=>"/db/prod/oracle/C84PROD/sys", :redirect_to=>"/db/prod/oracle/C84PROD#4"},
+  #       {:label=>"/db/prod/oracle/C84PROD/sysadm", :redirect_to=>"/db/prod/oracle/C84PROD#5"}]
+  def find(term)
+    response = @api_client.get("_find.json", form_data: {term: term})
+    if response.ok?
+      response.deserialize
+    else
+      raise TarkinClientException, "Can't search for '#{term}', server returns #{response.code}: #{response.message}"
+    end
+  end
+
+  # Returns string with valid token
+  #   > tc.token
+  #   #> "zvaY5...sds="
+  def token
+    @settings[:token]
+  end
+
+  # Returns true, if there is a connectivity to the server
+  # and you are authorized
+  def authorized?
+    @authorized || check_connectivity
+  end
+
+  def inspect
+    "TarkinClient <server: #{@settings[:tarkin_url]}, authorized: #{authorized?}>"
+  end
+
+  private
+  def api_url
+    "#{@settings[:tarkin_url]}/#{API}"
+  end
+
+  def get_settings
+    settings_file = SETTINGS_FILES.find {|file| File.exists? file}
+    if settings_file
+      @settings = YAML::load_file settings_file
+    else
+      new_settings
+    end
+  end
+
+  def new_settings
+    @settings = Hash.new
+    until @settings[:token]
+      @settings[:tarkin_url] = ask("Your <%= color('Tarkin', BOLD) %> server URL: ") do |q|
+        q.default = @settings[:tarkin_url] || "http://tarkin.tg.pl" 
+        q.validate = /^(http|https):\/\/.*/ix
+      end
+      @settings[:email] = ask("Your <%= color('Tarkin', BOLD) %> account email: ") do |q| 
+        q.default = @settings[:email] || "user@example.com"
+        q.validate = /\A[\w+\-.]+@[a-z\d\-]+(\.[a-z]+)*\.[a-z]+\z/i
+      end
+      password = ask("Password for #{@settings[:email]}: ") { |q| q.echo = "*" }
+      @settings[:token] = get_token(@settings[:email], password)
+    end 
+  end
+
+  def save_settings
+    File.open(SETTINGS_FILES.first, 'w') { |f| f.puts @settings.to_yaml }
+  end
+
+  def get_token(email, password)
+    begin
+      client = ARest.new(api_url, username: email, password: password)
+      response = client.get('_authorize.json')
+    rescue SocketError
+      say "<%= color('Cannot connect to server.', BOLD) %> Please retry."
+      return nil
+    end
+    unless response.ok?
+      say "<%= color('#{response.message}', BOLD) %>. Please retry."
+      nil
+    else
+      @authorized = true
+      response.deserialize[:token]
+    end
+  end
+
+  def check_connectivity
+    # @authorized = api_uri['_ping'].get.ok? unless @authorized
+    # @authorized = "#{api_url}/_ping".to_uri.get("", "Authorization" => "Token token=#{@settings[:token]}").ok? unless @authorized
+    @api_client.get("_ping").ok? unless @authorized
+  end
+end

data/lib/tarkin_commands.rb

@@ -0,0 +1,105 @@
+class String
+  # taken from rails
+  def truncate(truncate_at, options = {})
+    s = self.gsub(/\r\n/, ' ')
+    return s unless length > truncate_at
+
+    omission = options[:omission] || '...'
+    length_with_room_for_omission = truncate_at - omission.length
+    stop =        if options[:separator]
+        rindex(options[:separator], length_with_room_for_omission) || length_with_room_for_omission
+      else
+        length_with_room_for_omission
+      end
+
+    "#{s[0, stop]}#{omission}"
+  end
+end
+
+class TarkinCommands
+  def initialize(client)
+    @client = client
+  end
+
+  def cat(pwd)
+    puts @client.password(pwd)[:password]
+  end
+
+  def ls(path, long)
+    list = @client.ls(URI::encode(path))
+    if long
+      all = (list[:directories].collect{|dir| ["#{dir[:name]}/", 'blue', dir[:created_at], dir[:updated_at], dir[:description]]} +
+            list[:items].collect{|item| [item[:username], 'white', item[:created_at], item[:updated_at], item[:description]]}).sort
+      unless all.empty?
+        cols = 3
+        len = max_len(all)
+        table border: false do
+          all.each do |thing|
+            row do
+              column thing[2].to_time.strftime('%Y-%m-%d %T'), width: 22
+              column thing[3].to_time.strftime('%Y-%m-%d %T'), width: 22
+              column thing[0], width: len+2, color: thing[1]
+              chars_to_end = HighLine::SystemExtensions.terminal_size.first - 22*2 - (len+6)
+              column thing[4].truncate(chars_to_end), width: chars_to_end
+            end
+          end
+        end
+      end
+    else
+      # all contains directories and users, a list of list - item and display color: [[dir1, 'blue'], [user1, 'white']]
+      # reversed because we will be poping the table
+      all = (list[:directories].collect{|dir| ["#{dir[:name]}/", 'blue']} + list[:items].collect{|item| [item[:username], 'white']}).sort.reverse
+      unless all.empty?
+        cols = columns(all)
+        rows = all.count / cols + ( all.count % cols == 0 ? 0 : 1 )
+        len = max_len(all)
+
+        table border: false do
+          rows.times do
+            row do
+              cols.times do
+                item = all.pop
+                column(item && item.first , width: len, color: item && item.last)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def find(term)
+    list = @client.find(term).sort_by {|x| x[:label]}
+    list.each do |thing|
+      unless thing[:redirect_to].include?('#')
+        puts thing[:label].blue
+      else
+        puts thing[:label].white
+      end
+    end
+  end
+
+  # Returns items only in given directory
+  def items(dir)
+    @client.ls(URI::encode(dir))[:items]
+  end
+
+  # Returns only dirs
+  def dirs(dir)
+    @client.ls(URI::encode(dir))[:directories]
+  end
+
+  private
+  def max_len(array_or_arrays)
+    if array_or_arrays.empty?
+      nil
+    else
+      array_or_arrays.max_by{|x| x.first.length}.first.length
+    end
+  end
+
+  def columns(array_or_arrays)
+    screen_x = HighLine::SystemExtensions.terminal_size.first
+    (screen_x / (max_len(array_or_arrays) + 1.0)).floor
+  end
+end

data/lib/tarkin_sh.rb

@@ -0,0 +1,145 @@
+require 'cmd'
+
+class TarkinSh < Cmd
+  SETTINGS_FILE = "#{Dir.home}/.tarkin_sh"
+  HIST_LINES = 100 # how many history lines to save
+
+  prompt_with     :prompt_command
+
+  handle TarkinClientException, :handle_client_exception
+
+  doc :ls, 'List contants of directory
+      -l -- verbose (long) view'
+  def do_ls(args)
+    if args[:args].empty?
+      commands.ls @cd, args[:options].include?('l')
+    else
+      args[:args].each do |dir|
+        commands.ls full_dir(dir), args[:options].include?('l')
+      end
+    end
+  end
+
+  doc :pwd, 'Print working directory'
+  def do_pwd
+    write @cd
+  end
+
+  doc :cd, 'Change directory'
+  def do_cd(args)
+    if args[:args].empty? 
+      @cd = '/'
+    else
+      # TODO: warn if change to non-existing directory
+      dir = args[:args].first
+      @cd = full_dir dir
+    end
+  end
+  def complete_cd(args)
+    commands.dirs(full_dir(@cd)).collect {|x| x[:name]}.select {|x| x.start_with? args}
+  end
+
+  shortcut 'less', :cat
+  shortcut 'more', :cat
+  shortcut 'get', :cat
+  doc :cat, 'Shows password'
+  def do_cat(args)
+    args[:args].each do |item|
+      commands.cat(full_dir(item))
+    end
+  end
+  def complete_cat(args)
+    commands.items(full_dir(@cd)).collect {|x| x[:username]}.select {|x| x.start_with? args}
+  end
+  
+  shortcut 'search', :find
+  doc :find, 'Find for item or directory'
+  def do_find(args)
+    if args[:args].empty?
+      commands.ls @cd, false
+    else
+      commands.find(args[:args])
+    end
+  end
+
+  def do_help(command = nil)
+    command = command[:args].first
+    if command
+      command = translate_shortcut(command)
+      docs.include?(command) ? print_help(command) : no_help(command)
+    else
+      documented_commands.each {|cmd| print_help cmd}
+      print_undocumented_commands if undocumented_commands?
+    end
+  end
+
+  shortcut '!', 'shell'
+  doc :shell, 'Executes a shell.'
+  # Executes a shell, perhaps should only be defined by subclasses.
+  def do_shell(line)
+    line = line[:original]
+    shell = ENV['SHELL']
+    write shell
+    write "**#{line}**"
+    line.empty? ?  system(shell) : write(%x(#{line}).strip)
+  end
+
+  protected
+  def self.start(client, commands)
+    @@client = client
+    @@commands = commands
+    run
+  end
+
+  def setup
+    if File.exists? SETTINGS_FILE
+      settings = YAML::load_file SETTINGS_FILE
+      @cd = settings[:cd]
+      settings[:history].each { |h| Readline::HISTORY.push h }
+    else
+      @cd = '/'
+    end
+  end
+
+  def prompt_command
+    "#{client.settings[:tarkin_url]}#{@cd}> "
+  end
+
+  def command_missing(command, args)
+    write "tarkin: command not found: #{command}"
+  end
+
+  def handle_client_exception(exception)
+    write "tarkin: #{exception.message}"
+  end
+
+  def postloop
+    settings = { cd: @cd, history: Readline::HISTORY.to_a.last(HIST_LINES) }
+    File.open(SETTINGS_FILE, 'w') { |f| f.puts settings.to_yaml }
+  end
+
+  def tokenize_args(args)
+    a = if args then args.split else [] end
+    { args: a.select {|x| !x.start_with? '-'},
+      options: a.select {|x| x.start_with? '-'}.map {|x| x.sub(/^-/, '')}.join.split('').uniq,
+      original: args}
+  end
+
+  private
+  def commands
+    @@commands
+  end
+
+  def client
+    @@client
+  end
+
+  def full_dir(dir)
+    if dir.start_with? '/'
+      File.absolute_path(dir)
+    else
+      File.absolute_path(dir, @cd)
+    end
+  end
+
+end

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification
+name: tarkin
+version: !ruby/object:Gem::Version
+  version: 0.9.3.0
+platform: ruby
+authors:
+- Tomek Gryszkiewicz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: highline
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.7.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.7.2
+- !ruby/object:Gem::Dependency
+  name: arest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.1.1
+- !ruby/object:Gem::Dependency
+  name: command_line_reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.3.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.3.5
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+description: Tarkin Team Password Manager client, command line and shell
+email: grych@tg.pl
+executables:
+- tarkin
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/tarkin
+- lib/cmd.rb
+- lib/tarkin.rb
+- lib/tarkin_commands.rb
+- lib/tarkin_sh.rb
+homepage: https://github.com/grych/tarkin-client
+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: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Tarkin client
+test_files: []