haveapi-client 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8c2c9e15337f0d495ac86049fee2e76cf545957c
-  data.tar.gz: 9eaf5f13ad4c6d128a55b7efb3795b2840dd64dd
+  metadata.gz: 6beb148ebd5b4d6314016309a7fa9eb52292b78f
+  data.tar.gz: 54ff60ff22142d49eaa75cd27140f3349528b066
 SHA512:
-  metadata.gz: 7fa14b35b737f100c15ae7c8091e2abb18f9f8b3286ac006e723484f2c967dbb9f0683606fc7cda477c6cbc7d34ed9aabbe9bba83200a01608c3a9b04c825589
-  data.tar.gz: b3ac301b6d97864c2a1ddf909a121efb23aa5ef419be24f9e7ab0a436c16085f156f23ebaff4ed394f67c12665685323c70a7e3e95e147f672a768dc589130c7
+  metadata.gz: 2c5f0dfbd4fce722a9ec0b02cf175d351581cfba4d2142c8304059fd8cea0d052a3d3467ceda55e5647c8d2834540c4b17fd4eb49edf9486645ebff55be4c87a
+  data.tar.gz: fe3dc2e629ee1505eae68a36632de3a1edd2b9b8e0daf23fc0f61540fd4165ecac69c36226c25eb6ef21f0dce5dcd4aa7c1c9bdcfd192e12388f42e75a11d552

data/CHANGELOG

@@ -0,0 +1,17 @@
+* Web Jan 20 2016 - version 0.4.0
+- API for accessing authentication token
+- Client-side input parameter validators
+- Drop table_print in favor of custom output formatter
+- CLI
+  - switches -c, --columns, -r, --rows to select output mode
+  - option -o, --output to select parameters to print
+  - option -s, --sort to sort by specific parameter (on client-side)
+  - switch --timestamp, --utc and --localtime to select how to print Datetime
+    parameters
+  - switch --check-compatibility to determine whether the client is compatible
+    with given API server
+  - switch --protocol-version to print protocl version that this clients
+    implements
+- Check protocol version
+- Fixed check of invalid action
+- ResourceInstance passes on prepared_args correctly

data/README.md

@@ -28,10 +28,22 @@ Or install it yourself as:
             --list-resources [VERSION]   List all resource in API version
             --list-actions [VERSION]     List all resources and actions in API version
             --version VERSION            Use specified API version
-        -r, --raw                        Print raw response as is
-        -s, --save                       Save credentials to config file for later use
+        -c, --columns                    Print output in columns
+        -H, --no-header                  Hide header row
+        -L, --list-parameters            List output parameters
+        -o, --output PARAMETERS          Parameters to display, separated by a comma
+        -r, --rows                       Print output in rows
+        -s, --sort PARAMETER             Sort output by parameter
+            --save                       Save credentials to config file for later use
+            --raw                        Print raw response as is
+            --timestamp                  Display Datetime parameters as timestamp
+            --utc                        Display Datetime parameters in UTC
+            --localtime                  Display Datetime parameters in local timezone
+            --date-format FORMAT         Display Datetime in custom format
         -v, --[no-]verbose               Run verbosely
             --client-version             Show client version
+            --protocol-version           Show protocol version
+            --check-compatibility        Check compatibility with API server
         -h, --help                       Show this message
   
 Using the API example from

data/haveapi-client.gemspec

@@ -6,6 +6,7 @@ require 'haveapi/client/version'
 Gem::Specification.new do |spec|
   spec.name          = 'haveapi-client'
   spec.version       = HaveAPI::Client::VERSION
+  spec.date          = '2016-01-20'
   spec.authors       = ['Jakub Skokan']
   spec.email         = ['jakub.skokan@vpsfree.cz']
   spec.summary       =
@@ -21,10 +22,9 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'bundler', '~> 1.6'
   spec.add_development_dependency 'rake'
 
-  spec.add_runtime_dependency 'activesupport', '~> 4.1.0'
-  spec.add_runtime_dependency 'require_all', '~> 1.3.0'
+  spec.add_runtime_dependency 'activesupport', '~> 4.1.14'
+  spec.add_runtime_dependency 'require_all', '~> 1.3.3'
   spec.add_runtime_dependency 'rest_client', '~> 1.7.3'
-  spec.add_runtime_dependency 'json', '~> 1.8.1'
-  spec.add_runtime_dependency 'highline', '~> 1.6.21'
-  spec.add_runtime_dependency 'table_print', '~> 1.5.3'
+  spec.add_runtime_dependency 'json', '~> 1.8.3'
+  spec.add_runtime_dependency 'highline', '~> 1.7.8'
 end

data/lib/haveapi/cli.rb

@@ -1,2 +1,7 @@
 require_relative 'client'
+
+module HaveAPI
+  module CLI ; end
+end
+
 require_rel 'cli'

data/lib/haveapi/cli/cli.rb

@@ -1,428 +1,679 @@
 require 'optparse'
 require 'pp'
 require 'highline/import'
-require 'table_print'
 require 'yaml'
+require 'time'
 
-module HaveAPI
-  module CLI
-    class Cli
-      class << self
-        attr_accessor :auth_methods
+module HaveAPI::CLI
+  class Cli
+    class << self
+      attr_accessor :auth_methods, :commands
 
-        def run
-          c = new
-        end
+      def run
+        c = new
+      end
 
-        def register_auth_method(name, klass)
-          @auth_methods ||= {}
-          @auth_methods[name] = klass
-        end
+      def register_auth_method(name, klass)
+        @auth_methods ||= {}
+        @auth_methods[name] = klass
       end
 
-      def initialize
-        @config = read_config || {}
-        args, @opts = options
+      def register_command(cmd)
+        @commands ||= []
+        @commands << cmd
+      end
+    end
 
-        @api = HaveAPI::Client::Communicator.new(api_url, @opts[:version])
-        @api.identity = $0.split('/').last
+    def initialize
+      @config = read_config || {}
+      args, @opts = options
 
-        if @action
-          method(@action.first).call( * @action[1..-1] )
-          exit
-        end
+      @api = HaveAPI::Client::Communicator.new(api_url, @opts[:version])
+      @api.identity = $0.split('/').last
 
-        if (@opts[:help] && args.empty?) || args.empty?
-          puts @global_opt.help
+      if @action
+        method(@action.first).call( * @action[1..-1] )
+        exit
+      end
+
+      if (@opts[:help] && args.empty?) || args.empty?
+        show_help do
           puts "\nAvailable resources:"
           list_resources
-          exit(true)
         end
+      end
 
-        resources = args[0].split('.')
+      resources = args[0].split('.')
 
-        if args.count == 1
-          describe_resource(resources)
-          exit(true)
+      if cmd = find_command(resources, args[1])
+        authenticate if @auth
+        c = cmd.new(@opts, HaveAPI::Client::Client.new(nil, communicator: @api))
+          
+        cmd_opt = OptionParser.new do |opts|
+          opts.banner = "\nCommand options:"
+          c.options(opts)
+
+          opts.on('-h', '--help', 'Show this message') do
+            show_help do
+              puts cmd_opt.help
+            end
+          end
+        end
+        
+        if @opts[:help]
+          show_help do
+            puts cmd_opt.help
+          end
+        end
+        
+        if sep = ARGV.index('--')
+          cmd_opt.parse!(ARGV[sep+1..-1])
         end
 
-        action = @api.get_action(resources, args[1].to_sym, args[2..-1])
-        action.update_description(@api.describe_action(action)) if authenticate(action)
+        c.exec(args[2..-1] || [])
 
-        @input_params = parameters(action)
+        exit
+      end
 
-        if action
-          unless params_valid?(action)
-            warn 'Missing required parameters'
-          end
+      if args.count == 1
+        describe_resource(resources)
+        exit(true)
+      end
 
-          ret = action.execute(@input_params, raw: @opts[:raw])
+      action = @api.get_action(resources, args[1].to_sym, args[2..-1])
 
-          if ret[:status]
-            format_output(action, ret[:response])
+      unless action
+        warn "Resource or action '#{args[0]} #{args[1]}' not found"
+        puts
+        show_help(false)
+      end
 
-          else
-            warn "Action failed: #{ret[:message]}"
+      action.update_description(@api.describe_action(action)) if authenticate(action)
 
-            if ret[:errors] && ret[:errors].any?
-              puts 'Errors:'
-              ret[:errors].each do |param, e|
-                puts "\t#{param}: #{e.join('; ')}"
-              end
-            end
+      @selected_params = @opts[:output] ? @opts[:output].split(',').uniq
+                                        : nil
 
-            print_examples(action)
-          end
+      @input_params = parameters(action)      
 
-        else
-          warn "Action #{ARGV[0]}##{ARGV[1]} not valid"
-          exit(false)
-        end
+      includes = build_includes(action) if @selected_params
+      @input_params[:meta] = { includes: includes } if includes
+
+      begin
+        ret = action.execute(@input_params, raw: @opts[:raw])
+
+      rescue HaveAPI::Client::ValidationError => e
+        format_errors(action, 'input parameters not valid', e.errors)
+        exit(false)
       end
 
-      def api_url
-        @opts[:client]
+      if ret[:status]
+        format_output(action, ret[:response])
+
+      else
+        format_errors(action, ret[:message], ret[:errors])
+        exit(false)
       end
+    end
 
-      def options
-        options = {
-            client: default_url,
-            verbose: false,
-        }
+    def api_url
+      @opts[:client]
+    end
 
-        @global_opt = OptionParser.new do |opts|
-          opts.banner = "Usage: #{$0} [options] <resource> <action> [objects ids] [-- [parameters]]"
+    def options
+      options = {
+          client: default_url,
+          verbose: false,
+      }
 
-          opts.on('-u', '--api URL', 'API URL') do |url|
-            options[:client] = url
-          end
+      @global_opt = OptionParser.new do |opts|
+        opts.banner = "Usage: #{$0} [options] <resource> <action> [objects ids] [-- [parameters]]"
 
-          opts.on('-a', '--auth METHOD', Cli.auth_methods.keys, 'Authentication method') do |m|
-            options[:auth] = m
-            @auth = Cli.auth_methods[m].new(server_config(options[:client])[:auth][m])
-            @auth.options(opts)
-          end
+        opts.on('-u', '--api URL', 'API URL') do |url|
+          options[:client] = url
+        end
 
-          opts.on('--list-versions', 'List all available API versions') do
-            @action = [:list_versions]
-          end
+        opts.on('-a', '--auth METHOD', Cli.auth_methods.keys, 'Authentication method') do |m|
+          options[:auth] = m
+          @auth = Cli.auth_methods[m].new(server_config(options[:client])[:auth][m])
+          @auth.options(opts)
+        end
 
-          opts.on('--list-auth-methods [VERSION]', 'List available authentication methods') do |v|
-            @action = [:list_auth, v && v.sub(/^v/, '')]
-          end
+        opts.on('--list-versions', 'List all available API versions') do
+          @action = [:list_versions]
+        end
 
-          opts.on('--list-resources [VERSION]', 'List all resource in API version') do |v|
-            @action = [:list_resources, v && v.sub(/^v/, '')]
-          end
+        opts.on('--list-auth-methods [VERSION]', 'List available authentication methods') do |v|
+          @action = [:list_auth, v && v.sub(/^v/, '')]
+        end
 
-          opts.on('--list-actions [VERSION]', 'List all resources and actions in API version') do |v|
-            @action = [:list_actions, v && v.sub(/^v/, '')]
-          end
+        opts.on('--list-resources [VERSION]', 'List all resource in API version') do |v|
+          @action = [:list_resources, v && v.sub(/^v/, '')]
+        end
 
-          opts.on('--version VERSION', 'Use specified API version') do |v|
-            options[:version] = v
-          end
+        opts.on('--list-actions [VERSION]', 'List all resources and actions in API version') do |v|
+          @action = [:list_actions, v && v.sub(/^v/, '')]
+        end
 
-          opts.on('-r', '--raw', 'Print raw response as is') do
-            options[:raw] = true
-          end
+        opts.on('--version VERSION', 'Use specified API version') do |v|
+          options[:version] = v
+        end
 
-          opts.on('-s', '--save', 'Save credentials to config file for later use') do
-            options[:save] = true
-          end
+        opts.on('-c', '--columns', 'Print output in columns') do
+          options[:layout] = :columns
+        end
 
-          opts.on('-v', '--[no-]verbose', 'Run verbosely') do |v|
-            options[:verbose] = v
-          end
+        opts.on('-H', '--no-header', 'Hide header row') do |h|
+          options[:header] = false
+        end
 
-          opts.on('--client-version', 'Show client version') do
-            @action = [:show_version]
-          end
+        opts.on('-L', '--list-parameters', 'List output parameters') do |l|
+          options[:list_output] = true
+        end
 
-          opts.on('-h', '--help', 'Show this message') do
-            options[:help] = true
-          end
+        opts.on('-o', '--output PARAMETERS', 'Parameters to display, separated by a comma') do |o|
+          options[:output] = o
         end
 
-        args = []
+        opts.on('-r', '--rows', 'Print output in rows') do
+          options[:layout] = :rows
+        end
+        
+        opts.on('-s', '--sort PARAMETER', 'Sort output by parameter') do |p|
+          options[:sort] = p
+        end
 
-        ARGV.each do |arg|
-          if arg == '--'
-            break
-          else
-            args << arg
-          end
+        opts.on('--save', 'Save credentials to config file for later use') do
+          options[:save] = true
+        end
+        
+        opts.on('--raw', 'Print raw response as is') do
+          options[:raw] = true
+        end
+
+        opts.on('--timestamp', 'Display Datetime parameters as timestamp') do
+          options[:datetime] = :timestamp
+        end
+
+        opts.on('--utc', 'Display Datetime parameters in UTC') do
+          options[:datetime] = :utc
+        end
+
+        opts.on('--localtime', 'Display Datetime parameters in local timezone') do
+          options[:datetime] = :local
+        end
+
+        opts.on('--date-format FORMAT', 'Display Datetime in custom format') do |f|
+          options[:date_format] = f
         end
 
-        @global_opt.parse!(args)
+        opts.on('-v', '--[no-]verbose', 'Run verbosely') do |v|
+          options[:verbose] = v
+        end
 
-        unless options[:auth]
-          cfg = server_config(options[:client])
+        opts.on('--client-version', 'Show client version') do
+          @action = [:show_version]
+        end
+        
+        opts.on('--protocol-version', 'Show protocol version') do
+          @action = [:protocol_version]
+        end
+        
+        opts.on('--check-compatibility', 'Check compatibility with API server') do
+          @action = [:check_compat]
+        end
 
-          @auth = Cli.auth_methods[cfg[:last_auth]].new(cfg[:auth][cfg[:last_auth]]) if cfg[:last_auth]
+        opts.on('-h', '--help', 'Show this message') do
+          options[:help] = true
         end
+      end
 
-        [args, options]
+      args = []
+
+      ARGV.each do |arg|
+        if arg == '--'
+          break
+        else
+          args << arg
+        end
       end
 
-      def parameters(action)
-        options = {}
-        sep = ARGV.index('--')
+      @global_opt.parse!(args)
 
-        @action_opt = OptionParser.new do |opts|
-          opts.banner = ''
+      unless options[:auth]
+        cfg = server_config(options[:client])
 
-          action.input[:parameters].each do |name, p|
-            opts.on(param_option(name, p), p[:description] || p[:label] || '') do |*args|
-              options[name] = args.first
-            end
-          end
+        @auth = Cli.auth_methods[cfg[:last_auth]].new(cfg[:auth][cfg[:last_auth]]) if cfg[:last_auth]
+      end
 
-          opts.on('-h', '--help', 'Show this message') do
-            @opts[:help] = true
+      [args, options]
+    end
+
+    def parameters(action)
+      options = {}
+      sep = ARGV.index('--')
+
+      @action_opt = OptionParser.new do |opts|
+        opts.banner = ''
+
+        action.input[:parameters].each do |name, p|
+          opts.on(param_option(name, p), p[:description] || p[:label] || '') do |*args|
+            options[name] = args.first
           end
         end
 
-        if @opts[:help]
-          puts @global_opt.help
-          puts ''
+        opts.on('-h', '--help', 'Show this message') do
+          @opts[:help] = true
+        end
+      end
+
+      if @opts[:help]
+        show_help do
           puts 'Action description:'
           puts action.description, "\n"
-          print 'Action parameters:'
+          print 'Input parameters:'
           puts @action_opt.help
+          puts
+          puts 'Output parameters:'
+
+          action.params.each do |name, param|
+            puts sprintf("    %-32s %s", name, param[:description])
+          end
+
           print_examples(action)
-          exit
         end
+      end
 
-        return {} unless sep
+      if @opts[:list_output]
+        action.params.each_key { |name| puts name }
+        exit
+      end
 
-        @action_opt.parse!(ARGV[sep+1..-1])
+      return {} unless sep
 
-        options
-      end
+      @action_opt.parse!(ARGV[sep+1..-1])
 
-      def param_option(name, p)
-        ret = '--'
-        name = name.to_s.dasherize
+      options
+    end
 
-        if p[:type] == 'Boolean'
-          ret += "[no-]#{name}"
+    def param_option(name, p)
+      ret = '--'
+      name = name.to_s.dasherize
 
-        else
-          ret += "#{name} #{name.underscore.upcase}"
-        end
+      if p[:type] == 'Boolean'
+        ret += "[no-]#{name}"
 
-        ret
+      else
+        ret += "#{name} #{name.underscore.upcase}"
       end
 
-      def list_versions
-        desc = @api.available_versions
+      ret
+    end
 
-        desc[:versions].each do |v, _|
-          next if v == :default
+    def list_versions
+      desc = @api.available_versions
 
-          v_int = v.to_s.to_i
+      desc[:versions].each do |v, _|
+        next if v == :default
 
-          puts "#{v_int == desc[:default] ? '*' : ' '} v#{v}"
-        end
+        v_int = v.to_s.to_i
+
+        puts "#{v_int == desc[:default] ? '*' : ' '} v#{v}"
       end
+    end
 
-      def list_auth(v=nil)
-        desc = @api.describe_api(v)
+    def list_auth(v=nil)
+      desc = @api.describe_api(v)
 
-        desc[:authentication].each_key do |auth|
-          puts auth if Cli.auth_methods.has_key?(auth)
-        end
+      desc[:authentication].each_key do |auth|
+        puts auth if Cli.auth_methods.has_key?(auth)
       end
+    end
 
-      def list_resources(v=nil)
-        desc = @api.describe_api(v)
+    def list_resources(v=nil)
+      desc = @api.describe_api(v)
 
-        desc[:resources].each do |resource, children|
-          nested_resource(resource, children, false)
-        end
+      desc[:resources].each do |resource, children|
+        nested_resource(resource, children, false)
       end
+    end
 
-      def list_actions(v=nil)
-        desc = @api.describe_api(v)
+    def list_actions(v=nil)
+      desc = @api.describe_api(v)
 
-        desc[:resources].each do |resource, children|
-          nested_resource(resource, children, true)
-        end
+      desc[:resources].each do |resource, children|
+        nested_resource(resource, children, true)
       end
+    end
 
-      def show_version
-        puts HaveAPI::Client::VERSION
+    def show_version
+      puts HaveAPI::Client::VERSION
+    end
+
+    def protocol_version
+      puts HaveAPI::Client::PROTOCOL_VERSION
+    end
+
+    def check_compat
+      case @api.compatible?
+      when :compatible
+        puts 'compatible'
+        exit
+
+      when :imperfect
+        puts 'imperfect'
+        exit(1)
+
+      else
+        puts 'incompatible'
+        exit(2)
       end
+    end
 
-      def describe_resource(path)
-        desc = @api.describe_resource(path)
+    def describe_resource(path)
+      desc = @api.describe_resource(path)
 
-        unless desc
-          warn "Resource #{path.join('.')} does not exist"
-          exit(false)
-        end
+      unless desc
+        warn "Resource #{path.join('.')} does not exist"
+        exit(false)
+      end
 
-        unless desc[:resources].empty?
-          puts 'Resources:'
+      unless desc[:resources].empty?
+        puts 'Resources:'
 
-          desc[:resources].each_key do |r|
-            puts "  #{r}"
-          end
+        desc[:resources].each_key do |r|
+          puts "  #{r}"
         end
+      end
 
-        puts '' if !desc[:resources].empty? && !desc[:actions].empty?
+      puts '' if !desc[:resources].empty? && !desc[:actions].empty?
 
-        unless desc[:actions].empty?
-          puts 'Actions:'
+      unless desc[:actions].empty?
+        puts 'Actions:'
 
-          desc[:actions].each_key do |a|
-            puts "  #{a}"
-          end
+        desc[:actions].each_key do |a|
+          puts "  #{a}"
         end
       end
+    end
 
-      def nested_resource(prefix, children, actions=false)
-        if actions
-          children[:actions].each do |action, _|
-            puts "#{prefix}##{action}"
-          end
-        else
-          puts prefix
+    def nested_resource(prefix, children, actions=false)
+      if actions
+        children[:actions].each do |action, _|
+          puts "#{prefix}##{action}"
         end
+      else
+        puts prefix
+      end
 
-        children[:resources].each do |resource, children|
-          nested_resource("#{prefix}.#{resource}", children, actions)
-        end
+      children[:resources].each do |resource, children|
+        nested_resource("#{prefix}.#{resource}", children, actions)
       end
+    end
 
-      def print_examples(action)
-        unless action.examples.empty?
-          puts "\nExamples:\n"
-          ExampleFormatter.format_examples(self, action)
+    def show_help(exit_code = true)
+      puts @global_opt.help
+
+      if Cli.commands
+        puts
+        puts 'Commands:'
+        Cli.commands.each do |cmd|
+          puts sprintf(
+              '%-36s %s',
+              "#{cmd.resource.join('.')} #{cmd.action} #{cmd.args}",
+              cmd.desc
+          )
         end
       end
 
-      def format_output(action, response, out = $>)
-        if @opts[:raw]
-          puts response
-          return
-        end
+      yield if block_given?
+      exit(exit_code)
+    end
 
-        return if response.empty?
+    def print_examples(action)
+      unless action.examples.empty?
+        puts "\nExamples:\n"
+        ExampleFormatter.format_examples(self, action)
+      end
+    end
 
-        tp.set :io, out
+    def format_output(action, response, out = $>)
+      if @opts[:raw]
+        puts JSON.generate(response)
+        return
+      end
 
-        namespace = action.namespace(:output).to_sym
+      return if response.empty?
 
-        case action.output_layout.to_sym
-          when :object_list, :hash_list
-            cols = []
+      namespace = action.namespace(:output).to_sym
 
-            action.params.each do |name, p|
-              if p[:type] == 'Resource'
-                cols << {
-                    name => {
-                      display_method: ->(r) {
-                       r[name] && "#{r[name][p[:value_label].to_sym]} (##{r[name][p[:value_id].to_sym]})"
-                      }
-                    }
-                }
-              else
-                cols << name
-              end
+      if action.output_layout.to_sym == :custom
+          return PP.pp(response[namespace], out)
+      end
+
+      cols = []
+      
+      (@selected_params || action.params.keys).each do |raw_name|
+        col = {}
+        name = nil
+        param = nil
+
+        # Fetching an associated attribute
+        if raw_name.to_s.index('.')
+          parts = raw_name.to_s.split('.').map! { |v| v.to_sym }
+          name = parts.first.to_sym
+
+          top = action.params
+
+          parts.each do |part|
+            fail "'#{part}' not found" unless top.has_key?(part)
+          
+            if top[part][:type] == 'Resource'
+              param = top[part]
+              top = @api.get_action(top[part][:resource], :show, []).params
+
+            else
+              param = top[part]
+              break
             end
+          end
 
-            tp response[namespace], *cols
+          col[:display] = Proc.new do |r|
+            next '' unless r
 
+            top = r
+            parts[1..-1].each do |part|
+              fail "'#{part}' not found" unless top.has_key?(part)
+              break if top[part].nil?
+              top = top[part]
+            end
+          
+            case param[:type]
+            when 'Resource'
+              "#{top[ param[:value_label].to_sym ]} (##{top[ param[:value_id].to_sym ]})"
 
-          when :object, :hash
-            response[namespace].each do |k, v|
+            when 'Datetime'
+              format_date(top)
 
-              if action.params[k][:type] == 'Resource'
-                out << "#{k}: #{v[action.params[k][:value_label].to_sym]}\n"
-              else
-                out << "#{k}: #{v}\n"
-              end
+            else
+              top
             end
+          end
 
+          col[:label] = raw_name
+          
+        else # directly accessible parameter
+          name = raw_name.to_sym
+          param = action.params[name]
+          fail "parameter '#{name}' does not exist" if param.nil?
+          
+          if param[:type] == 'Resource'
+            col[:display] = Proc.new do |r|
+              next '' unless r
+              "#{r[ param[:value_label].to_sym ]} (##{r[ param[:value_id].to_sym ]})"
+            end
 
-          when :custom
-            PP.pp(response[namespace], out)
-
+          elsif param[:type] == 'Datetime'
+            col[:display] = ->(date) { format_date(date) }
+          end
         end
+
+        col.update({
+            name: name,
+            align: %w(Integer Float).include?(param[:type]) ? 'right' : 'left',
+        })
+        
+        col[:label] ||= param[:label] && !param[:label].empty? ? param[:label] : name.upcase
+        
+        cols << col
       end
 
-      def header_for(action, param)
-        params = action.params
+      OutputFormatter.print(
+          response[namespace],
+          cols,
+          header: @opts[:header].nil?,
+          sort: @opts[:sort] && @opts[:sort].to_sym,
+          layout: @opts[:layout]
+      )
+    end
 
-        if params.has_key?(param) && params[param][:label]
-          params[param][:label]
-        else
-          param.to_s.upcase
-        end
+    def header_for(action, param)
+      params = action.params
+
+      if params.has_key?(param) && params[param][:label]
+        params[param][:label]
+      else
+        param.to_s.upcase
       end
+    end
 
-      def authenticate(action)
-        if action.auth?
-          if @auth
-            @auth.communicator = @api
-            @auth.validate
-            @auth.authenticate
+    def authenticate(action = nil)
+      return false if !action.nil? && !action.auth?
 
-            if @opts[:save]
-              cfg = server_config(api_url)
-              cfg[:auth][@opts[:auth]] = @auth.save
-              cfg[:last_auth] = @opts[:auth]
-              write_config
-            end
-
-          else
-            # FIXME: exit as auth is needed and has not been selected
-          end
+      if @auth
+        @auth.communicator = @api
+        @auth.validate
+        @auth.authenticate
 
-          return true
+        if @opts[:save]
+          cfg = server_config(api_url)
+          cfg[:auth][@opts[:auth]] = @auth.save
+          cfg[:last_auth] = @opts[:auth]
+          write_config
         end
 
-        false
+      else
+        # FIXME: exit as auth is needed and has not been selected
       end
 
-      def params_valid?(action)
-        true # FIXME
+      return true
+    end
+
+    protected
+    def default_url
+      'http://localhost:4567'
+    end
+
+    def config_path
+      "#{Dir.home}/.haveapi-client.yml"
+    end
+
+    def write_config
+      File.open(config_path, 'w') do |f|
+        f.write(YAML.dump(@config))
       end
+    end
+
+    def read_config
+      @config = YAML.load_file(config_path) if File.exists?(config_path)
+    end
 
-      protected
-      def default_url
-        'http://localhost:4567'
+    def server_config(url)
+      unless @config[:servers]
+        @config[:servers] = [{url: url, auth: {}}]
+        return @config[:servers].first
       end
 
-      def config_path
-        "#{Dir.home}/.haveapi-client.yml"
+      @config[:servers].each do |s|
+        return s if s[:url] == url
       end
 
-      def write_config
-        File.open(config_path, 'w') do |f|
-          f.write(YAML.dump(@config))
+      @config[:servers] << {url: url, auth: {}}
+      @config[:servers].last
+    end
+
+    def format_errors(action, msg, errors)
+      warn "Action failed: #{msg}"
+
+      if errors.any?
+        puts 'Errors:'
+        errors.each do |param, e|
+          puts "\t#{param}: #{e.join('; ')}"
         end
       end
 
-      def read_config
-        @config = YAML.load_file(config_path) if File.exists?(config_path)
+      print_examples(action)
+    end
+
+    def find_command(resource, action)
+      return false unless Cli.commands
+
+      Cli.commands.each do |cmd|
+        return cmd if cmd.handle?(resource, action)
       end
 
-      def server_config(url)
-        unless @config[:servers]
-          @config[:servers] = [{url: url, auth: {}}]
-          return @config[:servers].first
-        end
+      false
+    end
 
-        @config[:servers].each do |s|
-          return s if s[:url] == url
+    # Translate requested parameters into meta[includes] that is sent
+    # to the API.
+    #
+    # When using haveapi-cli vps list -o
+    #   node.location => node__location
+    #   node.location.domain => node_location
+    #   node.name => node
+    def build_includes(action)
+      ret = []
+      
+      @selected_params.each do |param|
+        next unless param.index('.')
+
+        includes = []
+        top = action.params
+
+        param.split('.').map! { |v| v.to_sym }.each do |part|
+          next unless top.has_key?(part)
+          next if top[part][:type] != 'Resource' 
+         
+          includes << part
+          top = @api.get_action(top[part][:resource], :show, []).params
         end
 
-        @config[:servers] << {url: url, auth: {}}
-        @config[:servers].last
+        ret << includes.join('__')
+      end
+
+      ret.uniq!
+      ret.empty? ? nil : ret.join(',')
+    end
+
+    def format_date(date)
+      return '' unless date
+
+      t = Time.iso8601(date)
+      ret = case @opts[:datetime]
+      when :timestamp
+        t.to_i
+
+      when :utc
+        t.utc
+
+      when :local
+        t.localtime
+
+      else
+        t.localtime
       end
+
+      @opts[:date_format] ? ret.strftime(@opts[:date_format]) : ret
     end
   end
 end