tty 0.0.6 → 0.0.7

data/lib/tty/shell/reader.rb

@@ -0,0 +1,92 @@
+# -*- encoding: utf-8 -*-
+
+module TTY
+  class Shell
+
+    # A class responsible for reading character input from STDIN
+    class Reader
+
+      # @api private
+      attr_reader :shell
+      private :shell
+
+      # Key input constants for decimal codes
+      CARRIAGE_RETURN = 13.freeze
+      NEWLINE         = 10.freeze
+      BACKSPACE       = 127.freeze
+      DELETE          = 8.freeze
+
+      # Initialize a Reader
+      #
+      # @api public
+      def initialize(shell=nil)
+        @shell = shell || Shell.new
+      end
+
+      # Get input in unbuffered mode.
+      #
+      #
+      # @api bublic
+      def buffer(&block)
+        bufferring = shell.output.sync
+        # Immediately flush output
+        shell.output.sync = true
+
+        value = block.call if block_given?
+
+        shell.output.sync = bufferring
+        value
+      end
+
+      # Get a value from STDIN one key at a time. Each key press is echoed back
+      # to the shell masked with character(if given). The input finishes when
+      # enter key is pressed.
+      #
+      # @param [String] mask
+      #   the character to use as mask
+      #
+      # @return [String]
+      #
+      # @api public
+      def getc(mask=(not_set=true))
+        value = ""
+
+        buffer do
+          begin
+            while (char = shell.input.getbyte) and
+                !(char == CARRIAGE_RETURN || char == NEWLINE)
+
+              if (char == BACKSPACE || char == DELETE)
+                value.slice!(-1, 1) unless value.empty?
+              else
+                print_char char, not_set, mask
+                value << char
+              end
+            end
+          ensure
+            TTY.terminal.echo_on
+          end
+        end
+
+        value
+      end
+
+      # Get a value from STDIN using line input.
+      #
+      # @api public
+      def gets
+        shell.input.gets
+      end
+
+      private
+
+      # Print out character back to shell STDOUT
+      #
+      # @api private
+      def print_char(char, not_set, mask)
+        shell.output.putc((not_set || !mask) ? char : mask)
+      end
+
+    end # Reader
+  end # Shell
+end # TTY

data/lib/tty/shell/response.rb

@@ -0,0 +1,219 @@
+# -*- encoding: utf-8 -*-
+
+require 'date'
+
+module TTY
+  # A class responsible for shell prompt interactions.
+  class Shell
+
+    # A class representing a question.
+    class Response
+
+      VALID_TYPES = [:boolean, :string, :symbol, :integer, :float, :date, :datetime]
+      attr_reader :reader
+      private :reader
+
+      attr_reader :shell
+      private :shell
+
+      attr_reader :question
+      private :question
+
+      # Initialize a Response
+      #
+      # @api public
+      def initialize(question, shell=nil)
+        @question = question
+        @shell    = shell || Shell.new
+        @reader   = Reader.new(shell)
+      end
+
+      # Read input from STDIN either character or line
+      #
+      # @param [Symbol] type
+      #
+      # @return [undefined]
+      #
+      # @api public
+      def read(type=nil)
+        question.evaluate_response read_input
+      end
+
+      # @api private
+      def read_input
+        reader = Reader.new(shell)
+
+        if question.mask? && question.echo?
+          reader.getc(question.mask)
+        else
+          TTY.terminal.echo(question.echo) {
+            question.character? ? reader.getc(question.mask) : reader.gets
+          }
+        end
+      end
+
+      # Read answer and cast to String type
+      #
+      # @param [String] error
+      #   error to display on failed conversion to string type
+      #
+      # @api public
+      def read_string(error=nil)
+        question.evaluate_response String(read_input)
+      end
+
+      # Read answer's first character
+      #
+      # @api public
+      def read_char
+        question.character true
+        question.evaluate_response String(read_input).chars.to_a[0]
+      end
+
+      # Read multiple line answer and cast to String type
+      #
+      # @api public
+      def read_text
+        question.evaluate_response String(read_input)
+      end
+
+      # Read ansewr and cast to Symbol type
+      #
+      # @api public
+      def read_symbol(error=nil)
+       question.evaluate_response read_input.to_sym
+      end
+
+      # Read answer from predifined choicse
+      #
+      # @api public
+      def read_choice(type=nil)
+        question.argument(:required) unless question.default?
+        question.evaluate_response read_input
+      end
+
+      # Read integer value
+      #
+      # @api public
+      def read_int(error=nil)
+        question.evaluate_response TTY::Coercer::Integer.coerce(read_input)
+      end
+
+      # Read float value
+      #
+      # @api public
+      def read_float(error=nil)
+        question.evaluate_response TTY::Coercer::Float.coerce(read_input)
+      end
+
+      # Read regular expression
+      #
+      # @api public
+      def read_regex(error=nil)
+        question.evaluate_response Kernel.send(:Regex, read_input)
+      end
+
+      # Read range expression
+      #
+      # @api public
+      def read_range
+        question.evaluate_response TTY::Coercer::Range.coerce(read_input)
+      end
+
+      # Read date
+      #
+      # @api public
+      def read_date
+        question.evaluate_response Date.parse(read_input)
+      end
+
+      # Read datetime
+      #
+      # @api public
+      def read_datetime
+        question.evaluate_response DateTime.parse(read_input)
+      end
+
+      # Read boolean
+      #
+      # @api public
+      def read_bool(error=nil)
+        question.evaluate_response TTY::Coercer::Boolean.coerce read_input
+      end
+
+      # Read file contents
+      #
+      # @api public
+      def read_file(error=nil)
+        question.evaluate_response File.open(File.join(directory, read_input))
+      end
+
+      # Read string answer and validate against email regex
+      #
+      # @return [String]
+      #
+      # @api public
+      def read_email
+        question.validate(/^[a-z0-9._%+-]+@([a-z0-9-]+\.)+[a-z]{2,6}$/i)
+        if question.error
+          question.prompt question.statement
+        end
+        with_exception { read_string }
+      end
+
+      # Read answer provided on multiple lines
+      #
+      # @api public
+      def read_multiple
+        response = ""
+        loop do
+          value = question.evaluate_response read_input
+          break if !value || value == ""
+          next  if value !~ /\S/
+          response << value
+        end
+        response
+      end
+
+      # Read password
+      #
+      # @api public
+      def read_password
+        question.echo false
+        question.evaluate_response read_input
+      end
+
+      private
+
+      # Ignore exception
+      #
+      # @api private
+      def with_exception(&block)
+        yield
+      rescue
+        question.error? ? block.call : raise
+      end
+
+      # @param [Symbol] type
+      #   :boolean, :string, :numeric, :array
+      #
+      # @api private
+      def read_type(class_or_name)
+        raise TypeError, "Type #{type} is not valid" if type && !valid_type?(type)
+        case type
+        when :string, ::String
+          read_string
+        when :symbol, ::Symbol
+          read_symbol
+        when :float, ::Float
+          read_float
+        end
+      end
+
+      def valid_type?(type)
+        self.class::VALID_TYPES.include? type.to_sym
+      end
+
+    end # Response
+  end # Shell
+end # TTY

data/lib/tty/shell/response_delegation.rb

@@ -0,0 +1,53 @@
+# -*- encoding: utf-8 -*-
+
+module TTY
+  class Shell
+    module ResponseDelegation
+      extend TTY::Delegatable
+
+      delegatable_method :dispatch, :read
+
+      delegatable_method :dispatch, :read_string
+
+      delegatable_method :dispatch, :read_char
+
+      delegatable_method :dispatch, :read_text
+
+      delegatable_method :dispatch, :read_symbol
+
+      delegatable_method :dispatch, :read_choice
+
+      delegatable_method :dispatch, :read_int
+
+      delegatable_method :dispatch, :read_float
+
+      delegatable_method :dispatch, :read_regex
+
+      delegatable_method :dispatch, :read_range
+
+      delegatable_method :dispatch, :read_date
+
+      delegatable_method :dispatch, :read_datetime
+
+      delegatable_method :dispatch, :read_bool
+
+      delegatable_method :dispatch, :read_file
+
+      delegatable_method :dispatch, :read_email
+
+      delegatable_method :dispatch, :read_multiple
+
+      delegatable_method :dispatch, :read_password
+
+      # Create response instance when question readed is invoked
+      #
+      # @param [TTY::Shell::Response] response
+      #
+      # @api private
+      def dispatch(response = Response.new(self, shell))
+        @response ||= response
+      end
+
+    end # ResponseDelegation
+  end # Shell
+end # TTY

data/lib/tty/table.rb

@@ -40,16 +40,22 @@ module TTY
     # @api private
     attr_reader :alignments
 
+    # The table border class
+    #
+    # @api private
+    attr_reader :border_class
+
+    # The table orientation out of :horizontal and :vertical
+    #
+    # @reutnr [TTY::Table::Orientation]
+    #
+    # @api public
+    attr_reader :orientation
+
     # Subset of safe methods that both Array and Hash implement
     def_delegators(:@rows, :[], :assoc, :flatten, :include?, :index,
                    :length, :select, :to_a, :values_at, :pretty_print, :rassoc)
 
-    # The table orientation
-    #
-    def direction
-      # TODO implement table orientation
-    end
-
     # Create a new Table where each argument is a row
     #
     # @example
@@ -74,20 +80,36 @@ module TTY
     #   rows  = [ ['a1', 'a2'], ['b1', 'b2'] ]
     #   table = Table.new :header => ['Header 1', 'Header 2'], :rows => rows
     #
+    # @example of parameters passed as hash
+    #   Table.new [ {'Header1' => ['a1','a2'], 'Header2' => ['b1', 'b2'] }] }
+    #
     # @param [Array[Symbol], Hash] *args
     #
     # @api public
     def self.new(*args, &block)
       options = Utils.extract_options!(args)
       if args.size.nonzero?
-        rows = args.pop
-        header = args.size.zero? ? nil : args.first
-        super({:header => header, :rows => rows}.merge(options), &block)
+        super(extract_tuples(args).merge(options), &block)
       else
         super(options, &block)
       end
     end
 
+    # Extract header and row tuples from arguments
+    #
+    # @param [Array] args
+    #
+    # @api private
+    def self.extract_tuples(args)
+      rows   = args.pop
+      header = args.size.zero? ? nil : args.first
+      if rows.first.is_a?(Hash)
+        header = rows.map(&:keys).flatten.uniq
+        rows   = rows.inject([]) { |arr, el| arr + el.values }
+      end
+      { :header => header, :rows => rows }
+    end
+
     # Initialize a Table
     #
     # @param [Hash] options
@@ -107,26 +129,78 @@ module TTY
     #
     # @api private
     def initialize(options={}, &block)
-      @header        = options.fetch :header, nil
-      @rows          = coerce(options.fetch :rows, [])
+      validate_options! options
+
+      @header        = options.fetch(:header) { nil }
+      @rows          = coerce options.fetch(:rows) { [] }
       @renderer      = pick_renderer options[:renderer]
+      @orientation   = Orientation.coerce options.fetch(:orientation) { :horizontal }
       # TODO: assert that row_size is the same as column widths & aligns
-      # TODO: this is where column extraction should happen!
-      @column_widths = options.fetch :column_widths, []
-      @alignments    = Operation::AlignmentSet.new options[:column_aligns] || []
+      @column_widths = Array(options.delete(:column_widths)).map(&:to_i)
+      @alignments    = Operation::AlignmentSet.new Array(options.delete(:column_aligns)).map(&:to_sym)
 
       assert_row_sizes @rows
+      @orientation.transform(self)
       yield_or_eval &block if block_given?
     end
 
+    # Sets table orientation
+    #
+    # @param [String,Symbol] value
+    #
+    # @api public
+    def orientation=(value)
+      @orientation = Orientation.coerce value
+    end
+
+    # Marks this table as rotated
+    #
+    # @api public
+    def rotated?
+      @rotated
+    end
+
+    # Rotate the table between vertical and horizontal orientation
+    #
+    # @return [self]
+    #
+    # @api private
+    def rotate
+      orientation.transform(self)
+      self
+    end
+
+    # Rotate the table vertically
+    #
+    # @api private
+    def rotate_vertical
+      @rows    = ([header].compact + rows).transpose
+      @header  = [] if header
+      @rotated = true
+    end
+
+    # Rotate the table horizontally
+    #
+    # @api private
+    def rotate_horizontal
+      transposed = rows.transpose
+      if header && header.empty?
+        @rows = transposed[1..-1]
+        @header = transposed[0]
+      elsif rotated?
+        @rows = transposed
+      end
+    end
+
     # Lookup element of the table given a row(i) and column(j)
     #
     # @api public
-    def [](i, j)
+    def [](i, j=false)
+      return row(i) unless j
       if i >= 0 && j >= 0
         rows.fetch(i){return nil}[j]
       else
-        raise IndexError.new("element at(#{i},#{j}) not found")
+        raise TTY::Table::TupleMissing.new(i,j)
       end
     end
     alias at        []