tty2-prompt 0.23.1.3

data/lib/tty2/prompt/converter_registry.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module TTY2
+  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
+      end
+
+      # Check if conversion is available
+      #
+      # @param [String] name
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def contain?(name)
+        conv_name = name.to_s.downcase.to_sym
+        @__registry.key?(conv_name)
+      end
+
+      # Register a conversion
+      #
+      # @param [Symbol] name
+      #   the converter name
+      #
+      # @api public
+      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 [](name)
+        conv_name = name.to_s.downcase.to_sym
+        @__registry.fetch(conv_name) do
+          raise UnsupportedConversion,
+                "converter #{conv_name.inspect} is not registered"
+        end
+      end
+      alias fetch []
+
+      def inspect
+        @_registry.inspect
+      end
+    end # ConverterRegistry
+  end # Prompt
+end # TTY2

data/lib/tty2/prompt/converters.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require_relative "const"
+require_relative "converter_dsl"
+
+module TTY2
+  class Prompt
+    module Converters
+      extend ConverterDSL
+
+      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
+      end
+
+      converter(:string, :str) do |input|
+        String(input).chomp
+      end
+
+      converter(:symbol, :sym) do |input|
+        input.to_sym
+      end
+
+      converter(:char) do |input|
+        String(input).chars.to_a[0]
+      end
+
+      converter(:date) do |input|
+        begin
+          require "date" unless defined?(::Date)
+          ::Date.parse(input)
+        rescue ArgumentError
+          Const::Undefined
+        end
+      end
+
+      converter(:datetime) do |input|
+        begin
+          require "date" unless defined?(::Date)
+          ::DateTime.parse(input.to_s)
+        rescue ArgumentError
+          Const::Undefined
+        end
+      end
+
+      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|
+        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|
+        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(:filepath, :file) do |input|
+        ::File.expand_path(input)
+      end
+
+      converter(:pathname, :path) do |input|
+        require "pathname" unless defined?(::Pathname)
+        ::Pathname.new(input)
+      end
+
+      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
+end # TTY2

data/lib/tty2/prompt/distance.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module TTY2
+  class Prompt
+    # A class responsible for string comparison
+    class Distance
+      # Calculate the optimal string alignment distance
+      #
+      # @api public
+      def distance(first, second)
+        distances = []
+        rows      = first.to_s.length
+        cols      = second.to_s.length
+
+        0.upto(rows) do |index|
+          distances << [index] + [0] * cols
+        end
+        distances[0] = 0.upto(cols).to_a
+
+        1.upto(rows) do |first_index|
+          1.upto(cols) do |second_index|
+            first_char  = first[first_index - 1]
+            second_char = second[second_index - 1]
+            cost        = first_char == second_char ? 0 : 1
+
+            distances[first_index][second_index] = [
+              distances[first_index - 1][second_index], # deletion
+              distances[first_index][second_index - 1],     # insertion
+              distances[first_index - 1][second_index - 1]  # substitution
+            ].min + cost
+
+            if first_index > 1 && second_index > 1
+              first_previous_char = first[first_index - 2]
+              second_previous_char = second[second_index - 2]
+              if first_char == second_previous_char && second_char == first_previous_char
+                distances[first_index][second_index] = [
+                  distances[first_index][second_index],
+                  distances[first_index - 2][second_index - 2] + 1 # transposition
+                ].min
+              end
+            end
+
+          end
+        end
+        distances[rows][cols]
+      end
+    end # Distance
+  end # Prompt
+end # TTY2