github_cli 0.3.1 → 0.4.0

data/lib/github_cli/editor.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+module GithubCLI
+  # This class determines editor to use to open the output.
+  class Editor
+
+    def initialize(options={})
+    end
+
+    def editor
+      editors = [ ENV['GHC_EDITOR'], ENV['VISUAL'], ENV['EDITOR'], 'vi' ]
+      editor = GithubCLI.config['editor']
+      editor ||= editors.find { |e| !e.nil? && !e.empty? }
+    end
+
+    def open(name)
+      if editor
+        command = "#{editor} #{name}"
+        success = system(command)
+        GithubCLI.ui.info "Could not run '#{command}'" unless success
+      else
+        GithubCLI.info("To open output, set $EDITOR or $VISUL")
+      end
+    end
+
+  end # Editor
+end # GithubCLI

data/lib/github_cli/errors.rb

@@ -8,6 +8,10 @@ module GithubCLI
     end
   end
 
+  class ApiError < GithubCLIError
+    status_code 5
+  end
+
   # Raised when a configuration file is corrupt or missing.
   class ConfigFileNotFound < GithubCLIError
     status_code 10
@@ -30,8 +34,9 @@ module GithubCLI
     status_code 13
 
     def initialize(format)
-      super %{Unrecognized formatting options: #{format} }
+      super %{Unrecognized formatting options: #{format}}
     end
   end
 
+
 end # GithubCLI

data/lib/github_cli/formatter.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+module GithubCLI
+  # This is the main entry point for formatting output.
+  # It delegates to other objects like Formatter::Table
+  # to perform actual rendering.
+  class Formatter
+    attr_reader :response, :format
+
+    def initialize(response, options={})
+      @response = response
+      @format   = options[:format]
+    end
+
+    def render_output
+      render_status
+      Terminal.paged_output
+      determine_output_formatter
+    end
+
+    def determine_output_formatter
+      case format.to_s
+      when 'table', /table:v.*/, /table:h.*/
+        formatter = Formatters::Table.new(response,
+                      :transform => format.to_s.split(':').last
+                    )
+        formatter.format
+      when 'csv'
+        formatter = Formatters::CSV.new(response)
+        formatter.format
+      when 'json'
+        'json output'
+      else
+        raise UnknownFormatError, format
+      end
+    end
+
+    # Render status code
+    def render_status
+      if response.respond_to? :status
+        Terminal.line "Response Status: #{response.status}\n"
+        Terminal.newline
+      end
+    end
+
+  end # Formatter
+end # GithubCLi

data/lib/github_cli/formatters/csv.rb

@@ -14,24 +14,24 @@ module GithubCLI
           render_headers @response.first
           @response.each_with_index do |item, indx|
             render_line indx, item
-            $stdout.puts
+            Terminal.newline
           end
-        else
+        when Hash
           render_headers @response
           render_line 1, @response
+        else
+          Terminal.line "#{@response}\n"
         end
       end
 
       def render_headers(response)
-        output = {}
-        GithubCLI::Util.flatten_hash(response.to_hash, output)
-        puts "Index," + output.keys.join(',')
+        output = GithubCLI::Util.flatten_hash(response.to_hash)
+        Terminal.line "Index,#{output.keys.join(',')}\n"
       end
 
       def render_line(index, item)
-        output = {}
-        GithubCLI::Util.flatten_hash(item.to_hash, output)
-        printf "%d,%s", index, output.values.join(',')
+        output = GithubCLI::Util.flatten_hash(item.to_hash)
+        $stdout.printf "%d,%s", index, output.values.join(',')
       end
 
     end # CSV

data/lib/github_cli/formatters/table.rb

@@ -1,34 +1,260 @@
 # encoding: utf-8
 
+require 'ostruct'
+require 'forwardable'
+
 module GithubCLI
   module Formatters
     class Table
+      include GithubCLI::Util
+      include Enumerable
+      extend Forwardable
+
+      OPTIONS = {
+        :border => {
+          'top'          => '━',
+          'top_mid'      => '┳',
+          'top_left'     => '┏',
+          'top_right'    => '┓',
+          'bottom'       => '━',
+          'bottom_mid'   => '┻',
+          'bottom_left'  => '┗',
+          'bottom_right' => '┛',
+          'left'         => '┃',
+          'left_mid'     => '┣',
+          'mid'          => '━',
+          'mid_mid'      => '╋',
+          'right'        => '┃',
+          'right_mid'    => '┫'
+        },
+        :truncate => '…',
+        :style => {
+          :padding_left   => 1,
+          :padding_right  => 1,
+          :align          => :left,
+          :head           => ['cyan'],
+          :compact        => false
+        }
+      }
+
+      attr_reader :response, :transform, :output_array, :total_records
+
+      # Subset of safe methods that both Array and Hash implement
+      def_delegators(:@output_array, :[], :assoc, :each, :empty?, :flatten,
+        :include?, :index, :inspect, :length, :select, :size, :to_a, :values_at,
+        :pretty_print, :rassoc)
+
+      def initialize(response, options={})
+        @total_records = 1
+        @transform     = determine_layout(options[:transform])
+        @response      = response
+        @output_array  = build_output
+      end
+
+      def determine_layout(layout)
+        ( !layout.nil? && layout.index('h') ) ? :horizontal : :vertical
+      end
 
-      def initialize(response)
-        @response = response
+      def options
+        OPTIONS
+      end
+
+      def border
+        OpenStruct.new OPTIONS[:border]
+      end
+
+      def style
+        OpenStruct.new OPTIONS[:style]
+      end
+
+      # Builds output array from response hash
+      #
+      def build_output
+        case response
+        when Array
+          case transform
+          when :horizontal
+            array = [flatten_hash(response[0].to_hash).keys]
+            response.each do |item|
+              array << convert_values(flatten_hash(item.to_hash).values)
+            end
+            array
+          when :vertical
+            response.inject([]) do |array, item|
+              output = flatten_hash(item.to_hash)
+              rows = output.keys.zip(convert_values(output.values))
+              rows.each {|row| array << row }
+              @total_records = rows.size
+              array
+            end
+          end
+        when Hash
+          output = flatten_hash(response)
+          case transform
+          when :horizontal
+            array = [output.keys]
+            array << convert_values(output.values)
+          when :vertical
+            output.keys.zip(convert_values(output.values))
+          end
+        else
+          [response]
+        end
+      end
+
+      def column_widths
+        @column_widths ||= begin
+          array = case transform
+          when :horizontal
+            field_len = (
+              (Terminal.width - (output_array[0].size)).to_f / output_array[0].size.to_f
+            ).round
+            Array.new(output_array[0].size, field_len)
+          when :vertical
+            start = 0
+            maximas = []
+            colcount = output_array.max{ |a,b| a.size <=> b.size }.size
+
+            start.upto(colcount - 1) do |index|
+              maxima = output_array.map do |row|
+                row[index] ? (style.padding_left+ row[index].to_s.size + style.padding_right) : 0
+              end.max
+              maximas << maxima
+            end
+            maximas
+          end
+          array
+        end
+      end
+
+      def column_width(index)
+        width = column_widths[index] || 0
+      end
+
+      def columns
+        column_widths.size
+      end
+
+      def total_width
+        column_widths.reduce(0, :+).round + column_widths.size + border.right.length
       end
 
       def format
-        case @response
+        case response
         when Array
-          @response.each do |item|
-            render_vertical item
-            $stdout.puts
+          render_top_line
+          output_array.each_with_index do |row, indx|
+            render_row row
+            if (output_array.size - 1 != indx) && ((indx + 1) % total_records == 0)
+              render_middle_line
+            end
+          end
+          render_bottom_line
+        when Hash
+          render_top_line
+          output_array.each_with_index do |row, indx|
+            render_row row
+            if transform == :horizontal && output_array.size - 1 != indx
+              render_middle_line
+            end
           end
+          render_bottom_line
         else
-          render_vertical @response
+          Terminal.line "#{response}\n"
         end
       end
 
       def render_vertical(item)
-        output = {}
-        GithubCLI::Util.flatten_hash(item.to_hash, output)
+        output = GithubCLI::Util.flatten_hash(item.to_hash)
         GithubCLI.ui.print_table(
-          output.keys.zip(GithubCLI::Util.convert_values(output.values))
+          output.keys.zip(GithubCLI::Util.convert_values(output.values)),
+          :truncate => true
+        )
+      end
+
+      def render_horizontal(item)
+        output = GithubCLI::Util.flatten_hash(item.to_hash)
+        GithubCLI.ui.print_table(
+          [GithubCLI::Util.convert_values(output.values)],
+          :truncate => true
+        )
+      end
+
+      def render_line(line, left, right, intersection)
+        line = left + (line * (total_width - 2)) + right
+        width = 0
+
+        column_widths.each_with_index do |col_width, indx|
+          # Skip last column
+          if indx != (column_widths.size - 1)
+            width += col_width + 1
+            line = line[0...width] + intersection + line[width+1..-1]
+          else
+            width += col_width - 1
+            line = line[0...width] + right
+          end
+        end
+        Terminal.line line + "\n"
+      end
+
+      def render_top_line
+        render_line(
+          border.top,
+          border.top_left  || border.top,
+          border.top_right || border.top,
+          border.top_mid
         )
       end
 
-      def render_horizontal
+      def render_middle_line
+        render_line(
+          border.mid,
+          border.left_mid  || border.mid,
+          border.right_mid || border.mid,
+          border.mid_mid
+        )
+      end
+
+      def render_bottom_line
+        render_line(
+          border.bottom,
+          border.bottom_left  || border.bottom,
+          border.bottom_right || border.top,
+          border.bottom_mid
+        )
+      end
+
+      def render_cell(field, indx)
+        width = column_widths[indx] -
+                (style.padding_left || 0) -
+                (style.padding_right || 0)
+
+        if (indx == (column_widths.size - 1))
+          # Don't output 2 trailing spaces when printing last column
+          width = width - 2 if width > 3 # Ensure sensible width
+        end
+        field = if field.length == width
+          field
+        elsif field.length < width
+          pad(field.to_s, width, :align => style.align)
+        else
+          truncate(field.to_s, width)
+        end
+
+        string = ''
+        string << ' ' * (style.padding_left || 0)
+        string << "#{field}"
+        string << ' ' * (style.padding_right || 0)
+        string << "#{border.right}"
+        string
+      end
+
+      def render_row(fields, options={})
+        columns = []
+        fields.each_with_index do |field, indx|
+          columns << render_cell(field, indx)
+        end
+        Terminal.line border.left + columns.join + "\n"
       end
 
     end # Table

data/lib/github_cli/pager.rb

@@ -0,0 +1,66 @@
+# encoding: utf-8
+
+module GithubCLI
+  # This class provides pagining of terminal output.
+  class Pager
+    class << self
+
+      def pager_command(*cmds)
+        @pager_command = (!@pager_command.nil? && cmds.empty?) || begin
+          commands = [
+            ENV['GIT_PAGER'], `git config --get-all core.pager`.split.first,
+            ENV['PAGER'], 'less -isr', 'more', 'cat', 'pager'
+          ]
+          commands = cmds + commands
+          commands.compact.uniq.find { |cmd| System.command? cmd }
+        end
+      end
+
+      # Indicates if pager is enabled
+      def enabled?
+        @enabled && true
+      end
+
+      def enable
+        @enabled = true
+      end
+
+      def disable
+        @enabled = false
+      end
+    end
+
+    def initialize(options={})
+      @pager_command = options[:pager_command] if options[:pager_command]
+    end
+
+    # Pages output using configured pager.
+    def page
+      return if not $stdout.tty? or System.windows?
+
+      read_io, write_io = IO.pipe
+
+      if Kernel.fork
+        $stdin.reopen(read_io)
+        read_io.close
+        write_io.close
+
+        # Don't page if the input is short enough
+        ENV['LESS'] = 'FSRX'
+
+        # Wait until we have input before we start the pager
+        Kernel.select [$stdin]
+
+        pager = Pager.pager_command
+
+        Kernel.exec pager rescue Kernel.exec "/bin/sh", "-c", pager
+      else
+        # Child process
+        $stdout.reopen(write_io)
+        $stderr.reopen(write_io) if $stderr.tty?
+        write_io.close
+        read_io.close
+      end
+    end
+  end # System
+end # GithubCLI

data/lib/github_cli/subcommands.rb

@@ -24,6 +24,9 @@ module GithubCLI
     desc "event <command>", "Leverage Events API"
     subcommand "event", GithubCLI::Commands::Events
 
+    desc "follower <command>", "Leverage Followers API"
+    subcommand "follower", GithubCLI::Commands::Followers
+
     desc "fork <command>", "Leverage Forks API"
     subcommand "fork", GithubCLI::Commands::Forks
 
@@ -42,9 +45,15 @@ module GithubCLI
     desc "label <command>", "Leverage Labels API"
     subcommand "label", GithubCLI::Commands::Labels
 
+    desc "member <command>", "Leverage Members API"
+    subcommand "member", GithubCLI::Commands::Members
+
     desc "milestone <command>", "Leverage Milestones API"
     subcommand "milestone", GithubCLI::Commands::Milestones
 
+    desc "org <command>", "Leverage Organizations API"
+    subcommand "org", GithubCLI::Commands::Organizations
+
     desc "pull <command>", "Leverage Pull Requests API"
     subcommand "pull", GithubCLI::Commands::PullRequests
 
@@ -57,9 +66,15 @@ module GithubCLI
     desc "tag <command>", "Leverage Tags API"
     subcommand "tag", GithubCLI::Commands::Tags
 
+    desc "team <command>", "Leverage Teams API"
+    subcommand "team", GithubCLI::Commands::Teams
+
     desc "tree <command>", "Leverage Trees API"
     subcommand "tree", GithubCLI::Commands::Trees
 
+    desc "user <command>", "Leverage Users API"
+    subcommand "user", GithubCLI::Commands::Users
+
     desc "watch <command>", "Leverage Watching API"
     subcommand "watch", GithubCLI::Commands::Watching
 

data/lib/github_cli/system.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+module GithubCLI
+  # This class provides methods for reading system settings.
+  class System
+    class << self
+
+      # Checks if windows platform.
+      def windows?
+        require 'rbconfig'
+        RbConfig::CONFIG['host_os'] =~ /msdos|mswin|djgpp|mingw|windows/
+      end
+
+      # Finds executable in $PATH.
+      def which(command)
+        exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+        ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+          exts.each do |ext|
+            exe = "#{path}/#{command}#{ext}"
+            return exe if File.executable? exe
+          end
+        end
+        return nil
+      end
+
+      # Checks if command exists.
+      def command?(name)
+        !which(name).nil?
+      end
+
+    end
+  end # System
+end # GithubCLI

data/lib/github_cli/terminal.rb

@@ -3,38 +3,44 @@
 module GithubCLI
   # Responsible for display and size detection.
   class Terminal
-    DEFAULT_WIDTH = 120
+    DEFAULT_WIDTH  = 80
     DEFAULT_HEIGHT = 40
 
     class << self
-      attr_accessor :size
-
-      def render_output(response, options={})
-        render_status response
-        case options[:format].to_s
-        when 'table'
-          formatter = Formatters::Table.new(response)
-          formatter.format
-        when 'csv'
-          formatter = Formatters::CSV.new(response)
-          formatter.format
-        when 'json'
-          'json output'
-        else
-          raise UnknownFormatError, options[:format]
-        end
+
+      def default_width
+        DEFAULT_WIDTH
+      end
+
+      def width
+        GithubCLI.ui.terminal_width
       end
 
-      # Render status code
-      def render_status(response)
-        puts "Response Status: #{response.status}"
-        puts
+      def line(text)
+        $stdout.print text
       end
 
-      def render_header
+      def newline
+        $stdout.print "\n"
+        nil
+      end
+
+      def paged_output
+        if Pager.enabled?
+          pager.page
+          true
+        else
+          false
+        end
+      end
+
+      def pager
+        @pager ||= Pager.new
       end
 
       def print_commands(pattern=nil)
+        Terminal.line "\n" + GithubCLI.program_name + "\n"
+        Terminal.newline
         GithubCLI.ui.info "Commands:"
 
         commands = Command.all.select do |cmd|
@@ -63,23 +69,47 @@ module GithubCLI
         GithubCLI.ui.info "ghc: '#{cmd}' is not a ghc command. See 'ghc --help'."
       end
 
-      def print_program_name(print=true)
+      def print_usage(flags, command='<command>')
         GithubCLI.ui.info <<-TEXT
 
-  #{GithubCLI.program_name}
+#{GithubCLI.program_name}
+
+Usage: ghc #{format_usage(flags, command, :indent => 11)}
 
         TEXT
       end
 
-      def print_usage(print=true)
-        if print
-        GithubCLI.ui.info <<-TEXT
-
-  Usage: ghc <command> <subcommand> [<args>]
+      # Options
+      # indent - Indent the line with by indent value. Assumes that the first
+      #          the first line is already filled in with other padding.
+      # length - Line length, otherwise the default terminal width is assumed.
+      def format_usage(flags, command, options={})
+        synopsis = "#{flags} #{command} <subcommand> [<args>]"
+        indent = options[:indent] || 0
+        padding = sprintf("%#{indent}s",'')
+        length  = options[:length] || default_width
+        wrap synopsis, length, indent, padding
+      end
 
-        TEXT
+      # Wraps text at the given line length using given indent value.
+      def wrap(text, length, indent=0, padding=0)
+        if text.length > length - indent
+          paragraphs = []
+          line = ''
+          text.split(/\s+/).map(&:chomp).reject(&:empty?).each do |fragment|
+            if line.length < length - indent
+              line << fragment + ' '
+            else
+              paragraphs << line
+              line = padding + fragment + ' '
+            end
+          end
+          paragraphs << line
+          text = paragraphs.join("\n")
         end
+        text
       end
+
     end
 
   end # Terminal

data/lib/github_cli/thor_ext.rb

@@ -12,12 +12,27 @@ class Thor
       end
       list.sort!{ |a,b| a[0] <=> b[0] }
 
+      GithubCLI::Terminal.print_usage global_flags, GithubCLI::Command.command_to_show(list[0][0])
+
       shell.say "Commands:"
       shell.print_table(list, :indent => 2, :truncate => true)
       shell.say
       class_options_help(shell)
     end
 
+    # String representation of all available global flags
+    def global_flags
+      return if class_options.empty?
+
+      all_options = ''
+      class_options.each do |key, val|
+        all_options << '[' + val.switch_name
+        all_options <<  (!val.aliases.empty? ? ('|' + val.aliases.join('|')) : '')
+        all_options <<  '] '
+      end
+      all_options
+    end
+
     def subcommand_help(cmd)
       desc "help <command>", "Describe subcommands or one specific subcommand"
       class_eval <<-RUBY