tty 0.0.9 → 0.0.10

data/lib/tty/plugins.rb

@@ -0,0 +1,75 @@
+# -*- encoding: utf-8 -*-
+
+module TTY
+
+  # A class responsible for managing plugins installation
+  class Plugins
+
+    PLUGIN_PREFIX = 'tty'
+
+    attr_accessor :plugins
+    private :plugins
+
+    # Initialize the Plugins
+    #
+    # @api public
+    def initialize
+      @plugins = []
+    end
+
+    # Load all plugins that are not enabled
+    #
+    # @api public
+    def load
+      plugins.each do |plugin|
+        plugin.load! unless plugin.enabled?
+      end
+    end
+
+    # Register plugin with name in internal array
+    #
+    # @param [String] name
+    #
+    # @param [TTY::Plugin] plugin
+    #
+    # @api public
+    def register(name, plugin=false)
+      if plugin && !loaded?(name)
+        plugins << plugin
+      end
+    end
+
+    # Find all installed TTY plugins and store them
+    #
+    # @api private
+    def find
+      Gem.refresh
+      Gem::Specification.each do |gem|
+        next unless gem.name =~ /^#{PLUGIN_PREFIX}/
+        plugin_name = gem.name[/^#{PLUGIN_PREFIX}-(.*)/, 1]
+        register(plugin_name, Plugin.new(plugin_name, gem))
+      end
+      plugins
+    end
+
+    # Return a list of all plugin names as strings
+    #
+    # @api public
+    def names
+      plugins.inject(Hash.new) do |hash, plugin|
+        hash[plugin.name] = plugin
+        hash
+      end
+    end
+
+    private
+
+    # Check if plugin is already loaded
+    #
+    # @api private
+    def loaded?(name)
+      plugins.any? { |plugin| plugin.gem_name == name }
+    end
+
+  end # PluginManager
+end # TTY

data/lib/tty/shell/suggestion.rb

@@ -0,0 +1,102 @@
+# -*- encoding: utf-8 -*-
+
+module TTY
+  # A class responsible for shell prompt interactions.
+  class Shell
+
+    # A class representing a suggestion
+    class Suggestion
+
+      # @api private
+      attr_reader :shell
+      private :shell
+
+      # Number of spaces
+      #
+      # @api public
+      attr_reader :indent
+
+      # Text for a single suggestion
+      #
+      # @api public
+      attr_reader :single_text
+
+      # Text for multiple suggestions
+      #
+      # @api public
+      attr_reader :plural_text
+
+      DEFAULT_INDENT = 8
+
+      SINGLE_TEXT    = 'Did you mean this?'
+
+      PLURAL_TEXT    = 'Did you mean one of these?'
+
+      # Initialize a Suggestion
+      #
+      # @api public
+      def initialize(options={})
+        @indent      = options.fetch(:indent) { DEFAULT_INDENT }
+        @single_text = options.fetch(:single_text) { SINGLE_TEXT }
+        @plural_text = options.fetch(:plural_text) { PLURAL_TEXT }
+      end
+
+      # Suggest matches out of possibile strings
+      #
+      # @param [String] message
+      #
+      # @param [Array[String]] possibilities
+      #
+      # @api public
+      def suggest(message, possibilities)
+        distances        = measure_distances(message, possibilities)
+        minimum_distance = distances.keys.min
+        max_distance     = distances.keys.max
+
+        if minimum_distance < max_distance
+          suggestions = distances[minimum_distance].sort
+          evaluate(suggestions)
+        else
+          nil
+        end
+      end
+
+      # Measure distances between messag and possibilities
+      #
+      # @param [String] message
+      #
+      # @param [Array[String]] possibilities
+      #
+      # @return [Hash]
+      #
+      # @api private
+      def measure_distances(message, possibilities)
+        distances = Hash.new { |hash, key| hash[key] = [] }
+
+        possibilities.each do |possibility|
+          distances[Text.distance(message, possibility)] << possibility
+        end
+        distances
+      end
+
+      # Build up a suggestion string
+      #
+      # @param [Array[String]] suggestions
+      #
+      # @return [String]
+      #
+      # @api private
+      def evaluate(suggestions)
+        suggestion = ""
+        if suggestions.one?
+          suggestion << single_text + "\n"
+          suggestion << (" " * indent + suggestions.first)
+        else
+          suggestion << plural_text + "\n"
+          suggestion << suggestions.map { |suggestion| " " * indent + suggestion }.join("\n")
+        end
+      end
+
+    end # Suggestion
+  end # Shell
+end # TTY

data/lib/tty/shell.rb

@@ -135,30 +135,57 @@ module TTY
       args.each { |message| say message, options.merge(:color => :red) }
     end
 
-    def suggest(message, possibilities)
-      distances = Hash.new { |hash, key| hash[key] = [] }
-
-      possibilities.each do |possibility|
-        distances[Text.distance(message, possibility)] << possibility
-      end
-
-      minimum_distance = distances.keys.min
-      if minimum_distance < 4
-      else
-      end
+    # Takes the string provided by the user and compare it with other possible
+    # matches to suggest an unambigous string
+    #
+    # @example
+    #   shell.suggest('sta', ['status', 'stage', 'commit', 'branch'])
+    #   # => "status, stage"
+    #
+    # @param [String] message
+    #
+    # @param [Array] possibilities
+    #
+    # @param [Hash] options
+    # @option options [String] :indent
+    #   The number of spaces for indentation
+    # @option options [String] :single_text
+    #   The text for a single suggestion
+    # @option options [String] :plural_text
+    #   The text for multiple suggestions
+    #
+    # @return [String]
+    #
+    # @api public
+    def suggest(message, possibilities, options={})
+      suggestion = Suggestion.new(options)
+      say(suggestion.suggest(message, possibilities))
     end
 
     # Print a table to shell.
     #
+    # @example of a table with rows rendered with ascii border
+    #   rows = [[1], [2], [3]]
+    #   TTY.shell.print_table rows, renderer: :ascii
+    #
     # @return [undefined]
     #
     # @api public
     def print_table(*args, &block)
-      table = TTY::Table.new *args, &block
-      say table.to_s
+      options  = Utils.extract_options!(args)
+      renderer = options.fetch(:renderer) { :basic }
+      table    = TTY::Table.new(*args, &block)
+      say table.render(renderer, options)
     end
 
-    protected
+    # Check if outputing to shell
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def tty?
+      stdout.tty?
+    end
 
     def stdin
       $stdin

data/lib/tty/system/editor.rb

@@ -0,0 +1,111 @@
+# -*- encoding: utf-8 -*-
+
+require 'shellwords'
+
+module TTY
+  class System
+
+    # A class responsible for launching an editor
+    class Editor
+
+      attr_reader :file
+
+      # Initialize an Editor
+      #
+      # @param [String] file
+      #
+      # @api public
+      def initialize(file)
+        @file = file
+      end
+
+      # List possible executable for editor command
+      #
+      # @return [Array[String]]
+      #
+      # @api private
+      def self.executables
+        [ ENV['VISUAL'], ENV['EDITOR'], 'vi', 'emacs' ]
+      end
+
+      # Find available command
+      #
+      # @param [Array[String]] commands
+      #
+      # @return [String]
+      #
+      # @api public
+      def self.available(*commands)
+        commands = commands.empty? ? self.executables : commands
+        commands.compact.uniq.find { |cmd| System.exists?(cmd) }
+      end
+
+      # Finds command using a configured command(s) or detected shell commands.
+      #
+      # @param [Array[String]] commands
+      #
+      # @return [String]
+      #
+      # @api public
+      def self.command(*commands)
+        @command = if (@command && commands.empty?)
+          @command
+        else
+          available(*commands)
+        end
+      end
+
+      # Open file in system editor
+      #
+      # @param [String] file
+      #   the name of the file
+      #
+      # @raise [TTY::CommandInvocationError]
+      #
+      # @return [Object]
+      #
+      # @api public
+      def self.open(file)
+        unless self.command
+          raise CommandInvocationError, "Please export $VISUAL or $EDITOR"
+          exit 1
+        end
+
+        new(file).invoke
+      end
+
+      # Build invocation command for editor
+      #
+      # @return [String]
+      #
+      # @api private
+      def build
+        escaped_file = if System.unix?
+          # Escape file string so it can be safely used in a Bourne shell
+          Shellwords.shellescape(file)
+        elsif System.windows?
+          file.gsub(/\//, '\\')
+        else
+          file
+        end
+        "#{Editor.command} #{escaped_file}"
+      end
+
+      # Inovke editor command in a shell
+      #
+      # @raise [TTY::CommandInvocationError]
+      #
+      # @api private
+      def invoke
+        command_invocation = build
+        status = system(*Shellwords.split(command_invocation))
+
+        unless status
+          raise CommandInvocationError, "`#{command_invocation}` failed with status: #{$? ? $?.exitstatus : nil}"
+          exit status
+        end
+      end
+
+    end # Editor
+  end # System
+end # TTY

data/lib/tty/system/which.rb

@@ -6,6 +6,18 @@ module TTY
     # A class responsible for finding an executable in the PATH
     class Which
 
+      attr_reader :command
+
+      # Initialize a Which
+      #
+      # @param [String] command
+      #   the command to find
+      #
+      # @api public
+      def initialize(command)
+        @command = command
+      end
+
       # Find an executable in the PATH
       #
       # @param [String] command
@@ -18,7 +30,7 @@ module TTY
       #   the full path to executable if found, `nil` otherwise
       #
       # @api public
-      def which(command)
+      def which
         exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
         default_system_path.each do |path|
           exts.each do |ext|

data/lib/tty/system.rb

@@ -5,34 +5,50 @@ require 'rbconfig'
 module TTY
   class System
 
-    class << self
-
-      # Check if windows platform.
-      #
-      # @return [Boolean]
-      #
-      # @api public
-      def windows?
-        RbConfig::CONFIG['host_os'] =~ /msdos|mswin|djgpp|mingw|windows/
-      end
-
-      # Check if unix platform
-      #
-      # @return [Boolean]
-      #
-      # @api public
-      def unix?
-        RbConfig::CONFIG['host_os'] =~ /(aix|darwin|linux|(net|free|open)bsd|cygwin|solaris|irix|hpux)/i
-      end
-
-      # Find an executable in the PATH
-      #
-      # @see TTY::System::Which
-      #
-      # @api public
-      def which(command)
-        Which.new(command)
-      end
+    # Check if windows platform.
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def self.windows?
+      RbConfig::CONFIG['host_os'] =~ /msdos|mswin|djgpp|mingw|windows/
+    end
+
+    # Check if unix platform
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def self.unix?
+      RbConfig::CONFIG['host_os'] =~ /(aix|darwin|linux|(net|free|open)bsd|cygwin|solaris|irix|hpux)/i
+    end
+
+    # Find an executable in the PATH
+    #
+    # @see TTY::System::Which
+    #
+    # @api public
+    def self.which(command)
+      Which.new(command).which
+    end
+
+    # Check if command is available
+    #
+    # @param [String] name
+    #   the command name
+    #
+    # @api public
+    def self.exists?(name)
+      !!self.which(name)
+    end
+
+    # Proxy to editor object
+    #
+    # @return [TTY::System::Editor]
+    #
+    # @api public
+    def self.editor
+      TTY::System::Editor
     end
 
   end # System

data/lib/tty/table/border/null.rb

@@ -26,15 +26,6 @@ module TTY
           border ? super : nil
         end
 
-        # A line spanning all columns delemited by space character.
-        #
-        # @return [String]
-        #
-        # @api private
-        def row_line
-          (border && !border.characters.empty?) ? super : row.join(SPACE_CHAR)
-        end
-
         # A stub bottom line
         #
         # @api private

data/lib/tty/table/border/row_line.rb

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+
+module TTY
+  class Table
+    class Border
+
+      # A class for a table row line chars manipulation
+      class RowLine < Struct.new(:left, :center, :right)
+
+        # Colorize characters with a given style
+        #
+        # @api public
+        def colorize(style)
+          colorized_chars = Border.set_color(style, right, center, left)
+          self.right, self.center, self.left = colorized_chars
+        end
+
+      end # RowLine
+    end # Border
+  end # Table
+end # TTY

data/lib/tty/table/border.rb

@@ -15,18 +15,12 @@ module TTY
       # Represent a separtor on each row
       EACH_ROW = :each_row
 
-      # The row cell widths
+      # The row field widths
       #
       # @api private
       attr_reader :widths
       private :widths
 
-      # The table row
-      #
-      # @api private
-      attr_reader :row
-      private :row
-
       # The table custom border characters
       attr_reader :border
 
@@ -39,19 +33,19 @@ module TTY
 
       # Instantiate a new object
       #
-      # @param [Array] row
+      # @param [Array] column_widths
+      #   the table column widths
       #
       # @param [BorderOptions] options
       #
       # @return [Object]
       #
       # @api private
-      def initialize(row, options=nil)
+      def initialize(column_widths, options = nil)
         if self.class == Border
           raise NotImplementedError, "#{self} is an abstract class"
         else
-          @row = row
-          @widths = row.map { |cell| cell.chars.to_a.size }
+          @widths = column_widths
           @border = TTY::Table::BorderOptions.from options
         end
       end
@@ -65,7 +59,7 @@ module TTY
       #
       # @api public
       def self.def_border(characters=(not_set=true), &block)
-        return self.characters = characters if !not_set
+        return self.characters = characters unless not_set
 
         dsl = TTY::Table::BorderDSL.new(&block)
         self.characters = dsl.characters
@@ -116,6 +110,15 @@ module TTY
         (result = render(:top)).empty? ? nil : result
       end
 
+      # A line spannig all columns marking bottom of a table.
+      #
+      # @return [String]
+      #
+      # @api private
+      def bottom_line
+        (result = render(:bottom)).empty? ? nil : result
+      end
+
       # A line spanning all columns delemeting rows in a table.
       #
       # @return [String]
@@ -125,35 +128,61 @@ module TTY
         (result = render(:mid)).empty? ? nil : result
       end
 
-      # A line spanning all columns delemeting cells in a row.
+      # A line spanning all columns delemeting fields in a row.
+      #
+      # @param [TTY::Table::Row] row
+      #   the table row
       #
       # @return [String]
       #
-      # @api private
-      def row_line
-        right_char  = self['right']
-        left_char   = self['left']
-        center_char = self['center']
+      # @api public
+      def row_line(row)
+        line = RowLine.new(self['left'], self['center'], self['right'])
+        line.colorize(border.style) if color?
 
-        if color?
-          right_char, center_char, left_char = Border.set_color(border.style, right_char, center_char, left_char)
-        end
+        result = row_heights(row, line)
+        result.empty? ? EMPTY_CHAR : result
+      end
 
-        result = left_char + row.join(center_char) + right_char
-        result.empty? ? nil : result
+      protected
+
+      # Separate multiline string into individual rows with border.
+      #
+      # @param [TTY::Table::Row] row
+      #   the table row
+      #
+      # @param [TTY::Table::Border::RowLine] line
+      #
+      # @api private
+      def row_heights(row, line)
+        if row.size > 0
+          row.height.times.map do |line_index|
+            row_height_line(row, line_index, line)
+          end.join("\n")
+        else
+          line.left + line.right
+        end
       end
 
-      # A line spannig all columns marking bottom of a table.
+      # Generate border for a given multiline row
+      #
+      # @param [TTY::Table::Row] row
+      #   the table row
+      #
+      # @param [Integer] line
+      #  the index for current line inside multiline
+      #
+      # @param [TTY::Table::Border::RowLine] line
       #
       # @return [String]
       #
       # @api private
-      def bottom_line
-        (result = render(:bottom)).empty? ? nil : result
+      def row_height_line(row, line_index, line)
+        line.left + row.fields.each_with_index.map do |field, index|
+          (field.lines[line_index] || EMPTY_CHAR).ljust(widths[index])
+        end.join(line.center) + line.right
       end
 
-      protected
-
       # Generate particular border type
       #
       # @param [String] type
@@ -164,11 +193,13 @@ module TTY
         type = type.to_s
         border_char = self[type]
         line = render_line(border_char,
-          self["#{type}_left"]  || border_char,
-          self["#{type}_right"] || border_char,
-          self["#{type}_mid"])
+                           self["#{type}_left"]  || border_char,
+                           self["#{type}_right"] || border_char,
+                           self["#{type}_mid"])
 
-        line = Border.set_color(border.style, line) if color?
+        if color? && !line.empty?
+          line = Border.set_color(border.style, line)
+        end
         line
       end
 

data/lib/tty/table/border_dsl.rb

@@ -22,7 +22,7 @@ module TTY
       def initialize(characters=nil, &block)
         @options = TTY::Table::BorderOptions.new
         @options.characters = characters if characters
-        yield_or_eval &block if block_given?
+        yield_or_eval(&block) if block_given?
       end
 
       # Apply style color to the border