haveapi-client 0.3.0 → 0.4.0

data/lib/haveapi/cli/command.rb

@@ -0,0 +1,52 @@
+module HaveAPI::CLI
+  class Command
+    class << self
+      attr_reader :resource, :action
+
+      def cmd(resource, action = nil)
+        @resource = resource.is_a?(::Array) ? resource : [resource]
+        @resource.map! { |v| v.to_s }
+        @action = action && action.to_s
+
+        Cli.register_command(self)
+      end
+
+      def args(v = nil)
+        if v
+          @args = v
+
+        else
+          @args
+        end
+      end
+
+      def desc(v = nil)
+        if v
+          @desc = v
+
+        else
+          @desc
+        end
+      end
+
+      def handle?(resource, action)
+        resource == @resource && action == @action
+      end
+    end
+
+    attr_reader :global_opts
+
+    def initialize(opts, client)
+      @global_opts = opts
+      @api = client
+    end
+
+    def options(opts)
+
+    end
+
+    def exec(args)
+      raise NotImplementedError
+    end
+  end
+end

data/lib/haveapi/cli/output_formatter.rb

@@ -0,0 +1,221 @@
+module HaveAPI::CLI
+  class OutputFormatter
+    def self.format(*args)
+      f = new(*args)
+      f.format
+    end
+
+    def self.print(*args)
+      f = new(*args)
+      f.print
+    end
+
+    def initialize(objects, cols = nil, header: true, sort: nil, layout: nil, empty: '-')
+      @objects = objects
+      @header = header
+      @sort = sort
+      @layout = layout
+      @empty = empty
+
+      if @layout.nil?
+        if many?
+          @layout = :columns
+
+        else
+          @layout = :rows
+        end
+      end
+
+      if cols
+        @cols = parse_cols(cols)
+
+      else
+        if @objects.is_a?(::Array) # A list of items
+          @cols ||= parse_cols(@objects.first.keys)
+
+        elsif @objects.is_a?(::Hash) # Single item
+          @cols ||= parse_cols(@objects.keys)
+
+        else
+          fail "unsupported type #{@objects.class}"
+        end
+      end
+    end
+
+    def format
+      @out = ''
+      generate
+      @out
+    end
+
+    def print
+      @out = nil
+      generate
+    end
+
+    protected
+    def parse_cols(cols)
+      ret = []
+
+      cols.each do |c|
+        base = {
+            align: 'left'
+        }
+
+        if c.is_a?(::String) || c.is_a?(::Symbol)
+          base.update({
+              name: c,
+              label: c.to_s.upcase,
+          })
+          ret << base
+
+        elsif c.is_a?(::Hash)
+          base.update(c)
+          ret << base
+
+        else
+          fail "unsupported column type #{c.class}"
+        end
+      end
+
+      ret
+    end
+
+    def generate
+      return if @cols.empty?
+      prepare
+      
+      case @layout
+      when :columns
+        columns
+
+      when :rows
+        rows
+
+      else
+        fail "unsupported layout '#{@layout}'"
+      end
+    end
+
+    # Each object is printed on one line, it's parameters aligned into columns.
+    def columns
+      i = 0
+
+      formatters = @cols.map do |c|
+        ret = case c[:align].to_sym
+        when :right
+          "%#{col_width(i, c)}s"
+
+        else
+          "%-#{col_width(i, c)}s"
+        end
+
+        i += 1
+        ret
+      end.join('  ')
+      
+      line sprintf(formatters, * @cols.map { |c| c[:label] }) if @header
+
+      @str_objects.each do |o|
+        line sprintf(formatters, *o)
+      end
+    end
+
+    # Each object is printed on multiple lines, one parameter per line.
+    def rows
+      w = heading_width
+
+      @str_objects.each do |o|
+        @cols.each_index do |i|
+          c = @cols[i]
+        
+          if o[i].is_a?(::String) && o[i].index("\n")
+            lines = o[i].split("\n")
+            v = ([lines.first] + lines[1..-1].map { |l| (' ' * (w+3)) + l }).join("\n")
+
+          else
+            v = o[i]
+          end
+
+          line sprintf("%#{w}s:  %s", c[:label], v)
+        end
+        
+        line
+      end
+    end
+
+    def line(str = '')
+      if @out
+        @out += str + "\n"
+
+      else
+        puts str
+      end
+    end
+
+    def prepare
+      @str_objects = []
+      
+      each_object do |o|
+        arr = []
+        
+        @cols.each do |c|
+          v = o[ c[:name] ]
+          str = (c[:display] ? c[:display].call(v) : v)
+          str = @empty if !str || (str.is_a?(::String) && str.empty?)
+
+          arr << str
+        end
+
+        @str_objects << arr
+      end
+
+      if @sort
+        col_i = @cols.index { |c| c[:name] == @sort }
+        fail "unknown column '#{@sort}'" unless col_i
+
+        @str_objects.sort! do |a, b|
+          a[col_i] <=> b[col_i]
+        end
+      end
+
+      @str_objects
+    end
+
+    def col_width(i, c)
+      w = c[:label].to_s.length
+      
+      @str_objects.each do |o|
+        len = o[i].to_s.length
+        w = len if len > w
+      end
+
+      w + 1
+    end
+
+    def heading_width
+      w = @cols.first[:label].to_s.length
+
+      @cols.each do |c|
+        len = c[:label].to_s.length
+
+        w = len if len > w
+      end
+
+      w + 1
+    end
+
+    def each_object
+      if @objects.is_a?(::Array)
+        @objects.each { |v| yield(v) }
+
+      else
+        yield(@objects)
+      end
+    end
+
+    def many?
+      @objects.is_a?(::Array) && @objects.size > 1
+    end
+  end
+end

data/lib/haveapi/client.rb

@@ -1,3 +1,8 @@
 require 'require_all'
 require 'date'
+
+module HaveAPI
+  module Client ; end
+end
+
 require_rel 'client'

data/lib/haveapi/client/action.rb

@@ -1,131 +1,135 @@
-module HaveAPI
-  module Client
-    class Action
-      attr_accessor :resource_path
+module HaveAPI::Client
+  class Action
+    attr_accessor :resource_path
 
-      def initialize(api, name, spec, args)
-        @api = api
-        @name = name
-        @spec = spec
+    def initialize(api, name, spec, args)
+      @api = api
+      @name = name
+      @spec = spec
 
-        apply_args(args)
-      end
+      apply_args(args)
+    end
 
-      def execute(*args)
-        ret = @api.call(self, *args)
-        @prepared_url = nil
-        @prepared_help = nil
-        ret
+    def execute(data, *_)
+      params = Params.new(self, data)
+      
+      unless params.valid?
+        raise ValidationError.new(self, params.errors)
       end
 
-      def name
-        @name
-      end
+      ret = @api.call(self, params.to_api)
+      @prepared_url = nil
+      @prepared_help = nil
+      ret
+    end
 
-      def auth?
-        @spec[:auth]
-      end
+    def name
+      @name
+    end
 
-      def aliases(include_name = false)
-        if include_name
-          [@name] + @spec[:aliases]
-        else
-          @spec[:aliases]
-        end
-      end
+    def auth?
+      @spec[:auth]
+    end
 
-      def description
-        @spec[:description]
+    def aliases(include_name = false)
+      if include_name
+        [@name] + @spec[:aliases]
+      else
+        @spec[:aliases]
       end
+    end
 
-      def input
-        @spec[:input]
-      end
+    def description
+      @spec[:description]
+    end
 
-      def output
-        @spec[:output]
-      end
+    def input
+      @spec[:input]
+    end
 
-      def input_layout
-        @spec[:input][:layout].to_sym
-      end
+    def output
+      @spec[:output]
+    end
 
-      def output_layout
-        @spec[:output][:layout].to_sym
-      end
+    def input_layout
+      @spec[:input][:layout].to_sym
+    end
 
-      def structure
-        @spec[:output][:format]
-      end
+    def output_layout
+      @spec[:output][:layout].to_sym
+    end
 
-      def namespace(src)
-        @spec[src][:namespace]
-      end
+    def structure
+      @spec[:output][:format]
+    end
 
-      def examples
-        @spec[:examples]
-      end
+    def namespace(src)
+      @spec[src][:namespace]
+    end
 
-      def input_params
-        @spec[:input][:parameters]
-      end
+    def examples
+      @spec[:examples]
+    end
 
-      def params
-        @spec[:output][:parameters]
-      end
+    def input_params
+      @spec[:input][:parameters]
+    end
 
-      def param_description(dir, name)
-        @spec[dir][:parameters][name]
-      end
+    def params
+      @spec[:output][:parameters]
+    end
 
-      def url
-        @spec[:url]
-      end
+    def param_description(dir, name)
+      @spec[dir][:parameters][name]
+    end
 
-      def help
-        @spec[:help]
-      end
+    def url
+      @spec[:url]
+    end
 
-      # Url with resolved parameters.
-      def prepared_url
-        @prepared_url || @spec[:url]
-      end
+    def help
+      @spec[:help]
+    end
 
-      def prepared_help
-        @prepared_help || @spec[:help]
-      end
+    # Url with resolved parameters.
+    def prepared_url
+      @prepared_url || @spec[:url]
+    end
 
-      def http_method
-        @spec[:method]
-      end
+    def prepared_help
+      @prepared_help || @spec[:help]
+    end
 
-      def unresolved_args?
-        prepared_url =~ /:[a-zA-Z\-_]+/
-      end
+    def http_method
+      @spec[:method]
+    end
 
-      def provide_args(*args)
-        apply_args(args)
-      end
+    def unresolved_args?
+      prepared_url =~ /:[a-zA-Z\-_]+/
+    end
 
-      def provide_url(url, help)
-        @prepared_url = url
-        @prepared_help = help
-      end
+    def provide_args(*args)
+      apply_args(args)
+    end
 
-      def update_description(spec)
-        @spec = spec
-      end
+    def provide_url(url, help)
+      @prepared_url = url
+      @prepared_help = help
+    end
 
-      private
-        def apply_args(args)
-          @prepared_url ||= @spec[:url].dup
-          @prepared_help ||= @spec[:help].dup
+    def update_description(spec)
+      @spec = spec
+    end
+
+    private
+    def apply_args(args)
+      @prepared_url ||= @spec[:url].dup
+      @prepared_help ||= @spec[:help].dup
 
-          args.each do |arg|
-            @prepared_url.sub!(/:[a-zA-Z\-_]+/, arg.to_s)
-            @prepared_help.sub!(/:[a-zA-Z\-_]+/, arg.to_s)
-          end
-        end
+      args.each do |arg|
+        @prepared_url.sub!(/:[a-zA-Z\-_]+/, arg.to_s)
+        @prepared_help.sub!(/:[a-zA-Z\-_]+/, arg.to_s)
+      end
     end
   end
 end