tty-prompt 0.1.0

data/lib/tty/prompt/question/modifier.rb

@@ -0,0 +1,93 @@
+# encoding: utf-8
+
+module TTY
+  class Prompt
+    class Question
+      # A class representing String modifications.
+      class Modifier
+        attr_reader :modifiers
+        private :modifiers
+
+        # Initialize a Modifier
+        #
+        # @api public
+        def initialize(*modifiers)
+          @modifiers = Array(modifiers)
+        end
+
+        # Change supplied value according to the given string transformation.
+        # Valid settings are:
+        #
+        # @param [String] value
+        #   the string to be modified
+        #
+        # @return [String]
+        #
+        # @api private
+        def apply_to(value)
+          modifiers.reduce(value) do |result, mod|
+            result = Modifier.letter_case mod, result
+            Modifier.whitespace mod, result
+          end
+        end
+
+        # Changes letter casing in a string according to valid modifications.
+        # For invalid modification option the string is preserved.
+        #
+        # @param [Symbol] mod
+        #  the modification to change the string
+        #
+        # @option mod [Symbol] :up        change to upper case
+        # @option mod [Symbol] :upcase    change to upper case
+        # @option mod [Symbol] :uppercase change to upper case
+        # @option mod [Symbol] :down      change to lower case
+        # @option mod [Symbol] :downcase  change to lower case
+        # @option mod [Symbol] :capitalize change all words to start
+        #                                  with uppercase case letter
+        #
+        # @return [String]
+        #
+        # @api public
+        def self.letter_case(mod, value)
+          case mod
+          when :up, :upcase, :uppercase
+            value.upcase
+          when :down, :downcase, :lowercase
+            value.downcase
+          when :capitalize
+            value.capitalize
+          else
+            value
+          end
+        end
+
+        # Changes whitespace in a string according to valid modifications.
+        #
+        # @param [Symbol] mod
+        #   the modification to change the string
+        #
+        # @option mod [String] :trim, :strip
+        #   remove whitespace for the start and end
+        # @option mod [String] :chomp     remove record separator from the end
+        # @option mod [String] :collapse  remove any duplicate whitespace
+        # @option mod [String] :remove    remove all whitespace
+        #
+        # @api public
+        def self.whitespace(mod, value)
+          case mod
+          when :trim, :strip
+            value.strip
+          when :chomp
+            value.chomp
+          when :collapse
+            value.gsub(/\s+/, ' ')
+          when :remove
+            value.gsub(/\s+/, '')
+          else
+            value
+          end
+        end
+      end # Modifier
+    end # Question
+  end # Prompt
+end # TTY

data/lib/tty/prompt/question/validation.rb

@@ -0,0 +1,92 @@
+# encoding: utf-8
+
+module TTY
+  class Prompt
+    class Question
+      # A class representing question validation.
+      class Validation
+        # @api private
+        attr_reader :validation
+        private :validation
+
+        # Initialize a Validation
+        #
+        # @param [Object] validation
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def initialize(validation = nil)
+          @validation = validation ? coerce(validation) : validation
+        end
+
+        # Convert validation into known type.
+        #
+        # @param [Object] validation
+        #
+        # @raise [TTY::ValidationCoercion] failed to convert validation
+        #
+        # @api private
+        def coerce(validation)
+          case validation
+          when Proc
+            validation
+          when Regexp, String
+            Regexp.new(validation.to_s)
+          else
+            fail ValidationCoercion, "Wrong type, got #{validation.class}"
+          end
+        end
+
+        # Check if validation is required
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        def validate?
+          !!validation
+        end
+
+        # Test if the value matches the validation
+        #
+        # @example
+        #   validation.valid_value?(value) # => true or false
+        #
+        # @param [Object] value
+        #  the value to validate
+        #
+        # @return [undefined]
+        #
+        # @api public
+        def valid_value?(value)
+          check_validation(value)
+        end
+
+        private
+
+        # Check if provided value passes validation
+        #
+        # @param [String] value
+        #
+        # @raise [TTY::InvalidArgument] unkown type of argument
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def check_validation(value)
+          if validate? && value
+            value = value.to_s
+            if validation.is_a?(Regexp) && validation =~ value
+            elsif validation.is_a?(Proc) && validation.call(value)
+            else
+              fail InvalidArgument, "Invalid input for #{value}"
+            end
+            true
+          else
+            false
+          end
+        end
+      end # Validation
+    end # Question
+  end # Prompt
+end # TTY

data/lib/tty/prompt/reader.rb

@@ -0,0 +1,113 @@
+# encoding: utf-8
+
+module TTY
+  # A class responsible for shell prompt interactions.
+  class Prompt
+    # A class responsible for reading character input from STDIN
+    class Reader
+      # @api private
+      attr_reader :shell
+      private :shell
+
+      attr_reader :mode
+
+      # 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 = Prompt.new)
+        @shell = shell
+        @mode  = Mode.new
+      end
+
+      # Get input in unbuffered mode.
+      #
+      # @example
+      #   buffer do
+      #     ...
+      #   end
+      #
+      # @return [String]
+      #
+      # @api public
+      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) &&
+                !(char == CARRIAGE_RETURN || char == NEWLINE)
+              value = handle_char value, char, not_set, mask
+            end
+          ensure
+            mode.echo_on
+          end
+        end
+        value
+      end
+
+      # Get a value from STDIN using line input.
+      #
+      # @api public
+      def gets
+        shell.input.gets
+      end
+
+      # Reads at maximum +maxlen+ characters.
+      #
+      # @param [Integer] maxlen
+      #
+      # @api public
+      def readpartial(maxlen)
+        shell.input.readpartial(maxlen)
+      end
+
+      private
+
+      # Handle single character by appending to or removing from output
+      #
+      # @api private
+      def handle_char(value, char, not_set, mask)
+        if char == BACKSPACE || char == DELETE
+          value.slice!(-1, 1) unless value.empty?
+        else
+          print_char char, not_set, mask
+          value << char
+        end
+        value
+      end
+
+      # 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 # Prompt
+end # TTY

data/lib/tty/prompt/response.rb

@@ -0,0 +1,252 @@
+# encoding: utf-8
+
+module TTY
+  # A class responsible for shell prompt interactions
+  class Prompt
+    # A class representing a shell response
+    class Response
+      VALID_TYPES = [
+        :boolean,
+        :string,
+        :symbol,
+        :integer,
+        :float,
+        :date,
+        :datetime
+      ]
+
+      attr_reader :reader
+      private :reader
+
+      attr_reader :question
+      private :question
+
+      # Initialize a Response
+      #
+      # @api public
+      def initialize(question, shell = Shell.new)
+        @question  = question
+        @shell     = shell
+        @converter = Necromancer.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
+        if question.mask? && question.echo?
+          reader.getc(question.mask)
+        else
+          reader.mode.echo(question.echo) do
+            reader.mode.raw(question.raw) do
+              if question.raw?
+                reader.readpartial(10)
+              elsif question.character?
+                reader.getc(question.mask)
+              else
+                reader.gets
+              end
+            end
+          end
+        end
+      end
+
+      def no_input?(input)
+        !input || input == "\n" || input.empty?
+      end
+
+      # @api private
+      def evaluate_response
+        input = read_input
+        input = if no_input?(input)
+                  nil
+                elsif block_given?
+                  yield(input)
+                else input
+                end
+        question.evaluate_response(input)
+      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)
+        evaluate_response { |input| String(input).strip }
+      end
+
+      # Read answer's first character
+      #
+      # @api public
+      def read_char
+        question.char(true)
+        evaluate_response { |input| String(input).chars.to_a[0] }
+      end
+
+      # Read multiple line answer and cast to String type
+      #
+      # @api public
+      def read_text
+        evaluate_response { |input| String(input) }
+      end
+
+      # Read ansewr and cast to Symbol type
+      #
+      # @api public
+      def read_symbol(error = nil)
+        evaluate_response { |input| input.to_sym }
+      end
+
+      # Read answer from predifined choicse
+      #
+      # @api public
+      def read_choice(type = nil)
+        question.argument(:required) unless question.default?
+        evaluate_response
+      end
+
+      # Read integer value
+      #
+      # @api public
+      def read_int(error = nil)
+        evaluate_response { |input| @converter.convert(input).to(:integer) }
+      end
+
+      # Read float value
+      #
+      # @api public
+      def read_float(error = nil)
+        evaluate_response { |input| @converter.convert(input).to(:float) }
+      end
+
+      # Read regular expression
+      #
+      # @api public
+      def read_regex(error = nil)
+        evaluate_response { |input| Kernel.send(:Regex, input) }
+      end
+
+      # Read range expression
+      #
+      # @api public
+      def read_range
+        evaluate_response { |input| @converter.convert(input).to(:range, strict: true) }
+      end
+
+      # Read date
+      #
+      # @api public
+      def read_date
+        evaluate_response { |input| @converter.convert(input).to(:date) }
+      end
+
+      # Read datetime
+      #
+      # @api public
+      def read_datetime
+        evaluate_response { |input| @converter.convert(input).to(:datetime) }
+      end
+
+      # Read boolean
+      #
+      # @api public
+      def read_bool(error = nil)
+        evaluate_response { |input| @converter.convert(input).to(:boolean, strict: true) }
+      end
+
+      # Read file contents
+      #
+      # @api public
+      def read_file(error = nil)
+        evaluate_response { |input| File.open(File.join(directory, 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)
+        question.prompt(question.statement) if question.error
+        with_exception { read_string }
+      end
+
+      # Read answer provided on multiple lines
+      #
+      # @api public
+      def read_multiple
+        response = ''
+        loop do
+          value = evaluate_response
+          break if !value || value == ''
+          next  if value !~ /\S/
+          response << value
+        end
+        response
+      end
+
+      # Read password
+      #
+      # @api public
+      def read_password
+        question.echo false
+        evaluate_response
+      end
+
+      # Read a single keypress
+      #
+      # @api public
+      def read_keypress
+        question.echo false
+        question.raw true
+        question.evaluate_response(read_input).tap do |key|
+          raise Interrupt if key == "\x03" # Ctrl-C
+        end
+      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 # Prompt
+end # TTY