tty-prompt 0.21.0 → 0.22.0

data/lib/tty/prompt/answers_collector.rb

@@ -25,7 +25,7 @@ module TTY
       # Create answer entry
       #
       # @example
-      #   key(:name).ask('Name?')
+      #   key(:name).ask("Name?")
       #
       # @api public
       def key(name, &block)
@@ -40,7 +40,7 @@ module TTY
       # Change to collect all values for a key
       #
       # @example
-      #   key(:colors).values.ask('Color?')
+      #   key(:colors).values.ask("Color?")
       #
       # @api public
       def values(&block)

data/lib/tty/prompt/block_paginator.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'paginator'
+require_relative "paginator"
 
 module TTY
   class Prompt

data/lib/tty/prompt/choice.rb

@@ -15,7 +15,7 @@ module TTY
       #   Choice.from([:foo, 1])
       #   # => <TTY::Prompt::Choice @key=nil @name="foo" @value=1 @disabled=false>
       #
-      #   Choice.from({name: :foo, value: 1, key: 'f'}
+      #   Choice.from({name: :foo, value: 1, key: "f"}
       #   # => <TTY::Prompt::Choice @key="f" @name="foo" @value=1 @disabled=false>
       #
       # @param [Object] val

data/lib/tty/prompt/choices.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require 'forwardable'
+require "forwardable"
 
-require_relative 'choice'
+require_relative "choice"
 
 module TTY
   class Prompt
@@ -13,15 +13,8 @@ module TTY
       include Enumerable
       extend Forwardable
 
-      # The actual collection choices
-      #
-      # @return [Array[Choice]]
-      #
-      # @api public
-      attr_reader :choices
-
       def_delegators :choices, :length, :size, :to_ary, :empty?,
-                               :values_at, :index
+                     :values_at, :index, :==
 
       # Convenience for creating choices
       #
@@ -48,6 +41,20 @@ module TTY
         end
       end
 
+      # Scope of choices which are not disabled
+      #
+      # @api public
+      def enabled
+        reject(&:disabled?)
+      end
+
+      def enabled_indexes
+        each_with_index.reduce([]) do |acc, (choice, idx)|
+          acc << idx unless choice.disabled?
+          acc
+        end
+      end
+
       # Iterate over all choices in the collection
       #
       # @yield [Choice]
@@ -94,7 +101,7 @@ module TTY
       # Find a matching choice
       #
       # @exmaple
-      #   choices.find_by(:name, 'small')
+      #   choices.find_by(:name, "small")
       #
       # @param [Symbol] attr
       #   the attribute name
@@ -106,6 +113,16 @@ module TTY
       def find_by(attr, value)
         find { |choice| choice.public_send(attr) == value }
       end
+
+      protected
+
+      # The actual collection choices
+      #
+      # @return [Array[Choice]]
+      #
+      # @api private
+
+      attr_reader :choices
     end # Choices
   end # Prompt
 end # TTY

data/lib/tty/prompt/confirm_question.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative 'question'
-require_relative 'utils'
+require_relative "question"
+require_relative "utils"
 
 module TTY
   class Prompt
@@ -73,9 +73,9 @@ module TTY
       def render_question
         header = "#{@prefix}#{message} "
         if !@done
-          header += @prompt.decorate("(#{@suffix})", @help_color) + ' '
+          header += @prompt.decorate("(#{@suffix})", @help_color) + " "
         else
-          answer = convert_result(@input)
+          answer = conversion.call(@input)
           label  = answer ? @positive : @negative
           header += @prompt.decorate(label, @active_color)
         end
@@ -98,11 +98,12 @@ module TTY
 
       # @api private
       def setup_defaults
+        infer_default
         @convert = conversion
         return if suffix? && positive?
 
         if suffix? && (!positive? || !negative?)
-          parts = @suffix.split('/')
+          parts = @suffix.split("/")
           @positive = parts[0]
           @negative = parts[1]
         elsif !suffix? && positive?
@@ -112,18 +113,28 @@ module TTY
         end
       end
 
+      # @api private
+      def infer_default
+        converted = Converters.convert(:bool, default.to_s)
+        if converted == Const::Undefined
+          raise InvalidArgument, "default needs to be `true` or `false`"
+        else
+          default(converted)
+        end
+      end
+
       # @api private
       def create_default_labels
-        @suffix   = default ? 'Y/n' : 'y/N'
-        @positive = default ? 'Yes' : 'yes'
-        @negative = default ? 'no' : 'No'
+        @suffix   = default ? "Y/n" : "y/N"
+        @positive = default ? "Yes" : "yes"
+        @negative = default ? "no" : "No"
         @validation = /^(y(es)?|no?)$/i
         @messages[:valid?] = "Invalid input."
       end
 
       # @api private
       def create_suffix
-        (default ? positive.capitalize : positive.downcase) + '/' +
+        (default ? positive.capitalize : positive.downcase) + "/" +
           (default ? negative.downcase : negative.capitalize)
       end
 
@@ -131,12 +142,12 @@ module TTY
       #
       # @api private
       def conversion
-        proc { |input|
+        ->(input) do
           positive_word   = Regexp.escape(positive)
           positive_letter = Regexp.escape(positive[0])
-          pattern = Regexp.new("^#{positive_word}|#{positive_letter}$", true)
+          pattern = Regexp.new("^(#{positive_word}|#{positive_letter})$", true)
           !input.match(pattern).nil?
-        }
+        end
       end
     end # ConfirmQuestion
   end # Prompt

data/lib/tty/prompt/const.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module TTY
+  class Prompt
+    module Const
+      Undefined = Object.new.tap do |obj|
+        def obj.to_s
+          "undefined"
+        end
+
+        def obj.inspect
+          "undefined".inspect
+        end
+      end
+    end # Const
+  end # Prompt
+end # TTY

data/lib/tty/prompt/converter_dsl.rb

@@ -1,21 +1,20 @@
 # frozen_string_literal: true
 
-require_relative 'converter_registry'
+require_relative "converter_registry"
 
 module TTY
   class Prompt
     module ConverterDSL
       def converter_registry
-        @converter_registry ||= ConverterRegistry.new
+        @__converter_registry ||= ConverterRegistry.new
       end
 
-      def converter(name, &block)
-        @converter_registry = converter_registry.register(name, &block)
-        self
+      def converter(*names, &block)
+        converter_registry.register(*names, &block)
       end
 
-      def convert(name, data)
-        @converter_registry[name, data]
+      def convert(name, input)
+        converter_registry[name].call(input)
       end
     end # ConverterDSL
   end # Prompt

data/lib/tty/prompt/converter_registry.rb

@@ -1,60 +1,65 @@
 # frozen_string_literal: true
 
+require "forwardable"
+
 module TTY
   class Prompt
     # Immutable collection of converters for type transformation
     #
     # @api private
     class ConverterRegistry
+      extend Forwardable
+
+      def_delegators "@__registry", :keys
+
       # Create a registry of conversions
       #
       # @param [Hash] registry
       #
       # @api private
       def initialize(registry = {})
-        @_registry = registry.dup.freeze
-        freeze
+        @__registry = registry.dup
       end
 
-      # Register converter
+      # Check if conversion is available
       #
-      # @param [Symbol] name
-      #   the converter name
+      # @param [String] name
+      #
+      # @return [Boolean]
       #
       # @api public
-      def register(name, contents = nil, &block)
-        item = block_given? ? block : contents
-
-        if key?(name)
-          raise ArgumentError,
-                "Converter for #{name.inspect} already registered"
-        end
-        self.class.new(@_registry.merge(name => item))
+      def contain?(name)
+        conv_name = name.to_s.downcase.to_sym
+        @__registry.key?(conv_name)
       end
 
-      # Check if converter is registered
+      # Register a conversion
       #
-      # @return [Boolean]
+      # @param [Symbol] name
+      #   the converter name
       #
       # @api public
-      def key?(key)
-        @_registry.key?(key)
+      def register(*names, &block)
+        names.each do |name|
+          if contain?(name)
+            raise ConversionAlreadyDefined,
+                  "converter for #{name.inspect} is already registered"
+          end
+          @__registry[name] = block
+        end
       end
 
       # Execute converter
       #
       # @api public
-      def call(name, input)
-        if name.respond_to?(:call)
-          converter = name
-        else
-          converter = @_registry.fetch(name) do
-            raise ArgumentError, "#{name.inspect} is not registered"
-          end
+      def [](name)
+        conv_name = name.to_s.downcase.to_sym
+        @__registry.fetch(conv_name) do
+          raise UnsupportedConversion,
+                "converter #{conv_name.inspect} is not registered"
         end
-        converter[input]
       end
-      alias [] call
+      alias fetch []
 
       def inspect
         @_registry.inspect

data/lib/tty/prompt/converters.rb

@@ -1,74 +1,181 @@
 # frozen_string_literal: true
 
-require 'pathname'
-require 'necromancer'
-
-require_relative 'converter_dsl'
+require_relative "const"
+require_relative "converter_dsl"
 
 module TTY
   class Prompt
     module Converters
       extend ConverterDSL
 
-      # Delegate Necromancer errors
-      #
-      # @api private
-      def self.on_error
-        if block_given?
-          yield
-        else
-          raise ArgumentError, 'You need to provide a block argument.'
+      TRUE_VALUES = /^(t(rue)?|y(es)?|on|1)$/i.freeze
+      FALSE_VALUES = /^(f(alse)?|n(o)?|off|0)$/i.freeze
+
+      SINGLE_DIGIT_MATCHER = /^(?<digit>\-?\d+(\.\d+)?)$/.freeze
+      DIGIT_MATCHER = /^(?<open>-?\d+(\.\d+)?)
+                       \s*(?<sep>(\.\s*){2,3}|-|,)\s*
+                       (?<close>-?\d+(\.\d+)?)$
+                      /x.freeze
+      LETTER_MATCHER = /^(?<open>\w)
+                        \s*(?<sep>(\.\s*){2,3}|-|,)\s*
+                        (?<close>\w)$
+                       /x.freeze
+
+      converter(:boolean, :bool) do |input|
+        case input.to_s
+        when TRUE_VALUES then true
+        when FALSE_VALUES then false
+        else Const::Undefined
         end
-      rescue Necromancer::ConversionTypeError => e
-        raise ConversionError, e.message
-      end
-
-      converter(:bool) do |input|
-        on_error { Necromancer.convert(input).to(:boolean, strict: true) }
       end
 
-      converter(:string) do |input|
+      converter(:string, :str) do |input|
         String(input).chomp
       end
 
-      converter(:symbol) do |input|
+      converter(:symbol, :sym) do |input|
         input.to_sym
       end
 
+      converter(:char) do |input|
+        String(input).chars.to_a[0]
+      end
+
       converter(:date) do |input|
-        on_error { Necromancer.convert(input).to(:date, strict: true) }
+        begin
+          require "date" unless defined?(::Date)
+          ::Date.parse(input)
+        rescue ArgumentError
+          Const::Undefined
+        end
       end
 
       converter(:datetime) do |input|
-        on_error { Necromancer.convert(input).to(:datetime, strict: true) }
+        begin
+          require "date" unless defined?(::Date)
+          ::DateTime.parse(input.to_s)
+        rescue ArgumentError
+          Const::Undefined
+        end
       end
 
-      converter(:int) do |input|
-        on_error { Necromancer.convert(input).to(:integer, strict: true) }
+      converter(:time) do |input|
+        begin
+          require "time"
+          ::Time.parse(input.to_s)
+        rescue ArgumentError
+          Const::Undefined
+        end
+      end
+
+      converter(:integer, :int) do |input|
+        begin
+          Integer(input)
+        rescue ArgumentError
+          Const::Undefined
+        end
       end
 
       converter(:float) do |input|
-        on_error { Necromancer.convert(input).to(:float, strict: true) }
+        begin
+          Float(input)
+        rescue TypeError, ArgumentError
+          Const::Undefined
+        end
       end
 
+      # Convert string number to integer or float
+      #
+      # @return [Integer,Float,Const::Undefined]
+      #
+      # @api private
+      def cast_to_num(num)
+        ([convert(:int, num), convert(:float, num)] - [Const::Undefined]).first ||
+          Const::Undefined
+      end
+      module_function :cast_to_num
+
       converter(:range) do |input|
-        on_error { Necromancer.convert(input).to(:range, strict: true) }
+        if input.is_a?(::Range)
+          input
+        elsif match = input.to_s.match(SINGLE_DIGIT_MATCHER)
+          digit = cast_to_num(match[:digit])
+          ::Range.new(digit, digit)
+        elsif match = input.to_s.match(DIGIT_MATCHER)
+          open = cast_to_num(match[:open])
+          close = cast_to_num(match[:close])
+          ::Range.new(open, close, match[:sep].gsub(/\s*/, "") == "...")
+        elsif match = input.to_s.match(LETTER_MATCHER)
+          ::Range.new(match[:open], match[:close],
+                      match[:sep].gsub(/\s*/, "") == "...")
+        else Const::Undefined
+        end
       end
 
       converter(:regexp) do |input|
         Regexp.new(input)
       end
 
-      converter(:file) do |input|
-        ::File.open(::File.join(Dir.pwd, input))
+      converter(:filepath, :file) do |input|
+        ::File.expand_path(input)
       end
 
-      converter(:path) do |input|
-        Pathname.new(::File.join(Dir.pwd, input))
+      converter(:pathname, :path) do |input|
+        require "pathname" unless defined?(::Pathname)
+        ::Pathname.new(input)
       end
 
-      converter(:char) do |input|
-        String(input).chars.to_a[0]
+      converter(:uri) do |input|
+        require "uri" unless defined?(::URI)
+        ::URI.parse(input)
+      end
+
+      converter(:list, :array) do |val|
+        (val.respond_to?(:to_a) ? val : val.split(/(?<!\\),/))
+          .map { |v| v.strip.gsub(/\\,/, ",") }
+          .reject(&:empty?)
+      end
+
+      converter(:hash, :map) do |val|
+        values = val.respond_to?(:to_a) ? val : val.split(/[& ]/)
+        values.each_with_object({}) do |pair, pairs|
+          key, value = pair.split(/[=:]/, 2)
+          if (current = pairs[key.to_sym])
+            pairs[key.to_sym] = Array(current) << value
+          else
+            pairs[key.to_sym] = value
+          end
+          pairs
+        end
+      end
+
+      converter_registry.keys.each do |type|
+        next if type =~ /list|array|map|hash/
+
+        [:"#{type}_list", :"#{type}_array", :"#{type}s"].each do |new_type|
+          converter(new_type) do |val|
+            converter_registry[:array].(val).map do |obj|
+              converter_registry[type].(obj)
+            end
+          end
+        end
+
+        [:"#{type}_map", :"#{type}_hash"].each do |new_type|
+          converter(new_type) do |val|
+            converter_registry[:hash].(val).each_with_object({}) do |(k, v), h|
+              h[k] = converter_registry[type].(v)
+            end
+          end
+        end
+
+        [:"string_#{type}_map", :"str_#{type}_map",
+         :"string_#{type}_hash", :"str_#{type}_hash"].each do |new_type|
+          converter(new_type) do |val|
+            converter_registry[:hash].(val).each_with_object({}) do |(k, v), h|
+              h[converter_registry[:string].(k)] = converter_registry[type].(v)
+            end
+          end
+        end
       end
     end # Converters
   end # Prompt