wibrfake-brk 0.0.2

data/lib/wibrfake/ty/prompt/choice.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module TTY
+  class Prompt
+    # An immutable representation of a single choice option from select menu
+    #
+    # @api public
+    class Choice
+      # Create choice from value
+      #
+      # @examples
+      #   Choice.from(:foo)
+      #   # => <TTY::Prompt::Choice @key=nil @name="foo" @value="foo" @disabled=false>
+      #
+      #   Choice.from([:foo, 1])
+      #   # => <TTY::Prompt::Choice @key=nil @name="foo" @value=1 @disabled=false>
+      #
+      #   Choice.from({name: :foo, value: 1, key: "f"}
+      #   # => <TTY::Prompt::Choice @key="f" @name="foo" @value=1 @disabled=false>
+      #
+      # @param [Object] val
+      #   the value to be converted
+      #
+      # @raise [ArgumentError]
+      #
+      # @return [Choice]
+      #
+      # @api public
+      def self.from(val)
+        case val
+        when Choice
+          val
+        when Array
+          convert_array(val)
+        when Hash
+          convert_hash(val)
+        else
+          new(val, val)
+        end
+      end
+
+      # Convert an array into choice
+      #
+      # @param [Array<Object>]
+      #
+      # @return [Choice]
+      #
+      # @api public
+      def self.convert_array(val)
+        name, value, options = *val
+        if name.is_a?(Hash)
+          convert_hash(name)
+        elsif val.size == 1
+          new(name.to_s, name.to_s)
+        else
+          new(name.to_s, value, **(options || {}))
+        end
+      end
+
+      # Convert a hash into choice
+      #
+      # @param [Hash<Symbol,Object>]
+      #
+      # @return [Choice]
+      #
+      # @api public
+      def self.convert_hash(val)
+        if val.key?(:name) && val.key?(:value)
+          new(val[:name].to_s, val[:value], **val)
+        elsif val.key?(:name)
+          new(val[:name].to_s, val[:name].to_s, **val)
+        else
+          new(val.keys.first.to_s, val.values.first)
+        end
+      end
+
+      # The label name
+      #
+      # @api public
+      attr_reader :name
+
+      # The keyboard key to activate this choice
+      #
+      # @api public
+      attr_reader :key
+
+      # The text to display for disabled choice
+      #
+      # @api public
+      attr_reader :disabled
+
+      # Create a Choice instance
+      #
+      # @api public
+      def initialize(name, value, **options)
+        @name  = name
+        @value = value
+        @key   = options[:key]
+        @disabled = options[:disabled].nil? ? false : options[:disabled]
+        freeze
+      end
+
+      # Check if this choice is disabled
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def disabled?
+        !!@disabled
+      end
+
+      # Read value and evaluate
+      #
+      # @api public
+      def value
+        case @value
+        when Proc
+          @value.call
+        else
+          @value
+        end
+      end
+
+      # Object equality comparison
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def ==(other)
+        return false unless other.is_a?(self.class)
+
+        name == other.name &&
+          value == other.value &&
+          key == other.key
+      end
+
+      # Object string representation
+      #
+      # @return [String]
+      #
+      # @api public
+      def to_s
+        name.to_s
+      end
+    end # Choice
+  end # Prompt
+end # TTY

data/lib/wibrfake/ty/prompt/choices.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+require_relative "choice"
+
+module TTY
+  class Prompt
+    # A class responsible for storing a collection of choices
+    #
+    # @api private
+    class Choices
+      include Enumerable
+      extend Forwardable
+
+      def_delegators :choices, :length, :size, :to_ary, :empty?,
+                     :values_at, :index, :==
+
+      # Convenience for creating choices
+      #
+      # @param [Array[Object]] choices
+      #   the choice objects
+      #
+      # @return [Choices]
+      #   the choices collection
+      #
+      # @api public
+      def self.[](*choices)
+        new(choices)
+      end
+
+      # Create Choices collection
+      #
+      # @param [Array[Choice]] choices
+      #   the choices to add to collection
+      #
+      # @api public
+      def initialize(choices = [])
+        @choices = choices.map do |choice|
+          Choice.from(choice)
+        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]
+      #
+      # @api public
+      def each(&block)
+        return to_enum unless block_given?
+
+        choices.each(&block)
+      end
+
+      # Add choice to collection
+      #
+      # @param [Object] choice
+      #   the choice to add
+      #
+      # @api public
+      def <<(choice)
+        choices << Choice.from(choice)
+      end
+
+      # Access choice by index
+      #
+      # @param [Integer] index
+      #
+      # @return [Choice]
+      #
+      # @api public
+      def [](index)
+        @choices[index]
+      end
+
+      # Pluck a choice by its name from collection
+      #
+      # @param [String] name
+      #   the label name for the choice
+      #
+      # @return [Choice]
+      #
+      # @api public
+      def pluck(name)
+        map { |choice| choice.public_send(name) }
+      end
+
+      # Find a matching choice
+      #
+      # @example
+      #   choices.find_by(:name, "small")
+      #
+      # @param [Symbol] attr
+      #   the attribute name
+      # @param [Object] value
+      #
+      # @return [Choice]
+      #
+      # @api public
+      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/wibrfake/ty/prompt/confirm_question.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require_relative "question"
+require_relative "utils"
+
+module TTY
+  class Prompt
+    class ConfirmQuestion < Question
+      # Create confirmation question
+      #
+      # @param [Hash] options
+      # @option options [String] :suffix
+      # @option options [String] :positive
+      # @option options [String] :negative
+      #
+      # @api public
+      def initialize(prompt, **options)
+        super
+        @suffix   = options.fetch(:suffix)   { UndefinedSetting }
+        @positive = options.fetch(:positive) { UndefinedSetting }
+        @negative = options.fetch(:negative) { UndefinedSetting }
+      end
+
+      def positive?
+        @positive != UndefinedSetting
+      end
+
+      def negative?
+        @negative != UndefinedSetting
+      end
+
+      def suffix?
+        @suffix != UndefinedSetting
+      end
+
+      # Set question suffix
+      #
+      # @api public
+      def suffix(value = (not_set = true))
+        return @negative if not_set
+
+        @suffix = value
+      end
+
+      # Set value for matching positive choice
+      #
+      # @api public
+      def positive(value = (not_set = true))
+        return @positive if not_set
+
+        @positive = value
+      end
+
+      # Set value for matching negative choice
+      #
+      # @api public
+      def negative(value = (not_set = true))
+        return @negative if not_set
+
+        @negative = value
+      end
+
+      def call(message, &block)
+        return if Utils.blank?(message)
+
+        @message = message
+        block.call(self) if block
+        setup_defaults
+        render
+      end
+
+      # Render confirmation question
+      #
+      # @return [String]
+      #
+      # @api private
+      def render_question
+        header = "#{@prefix}#{message} "
+        if !@done
+          header += @prompt.decorate("(#{@suffix})", @help_color) + " "
+        else
+          answer = conversion.call(@input)
+          label  = answer ? @positive : @negative
+          header += @prompt.decorate(label, @active_color)
+        end
+        header << "\n" if @done
+        header
+      end
+
+      protected
+
+      # Decide how to handle input from user
+      #
+      # @api private
+      def process_input(question)
+        @input = read_input(question)
+        if Utils.blank?(@input)
+          @input = default ? positive : negative
+        end
+        @evaluator.call(@input)
+      end
+
+      # @api private
+      def setup_defaults
+        infer_default
+        @convert = conversion
+        return if suffix? && positive?
+
+        if suffix? && (!positive? || !negative?)
+          parts = @suffix.split("/")
+          @positive = parts[0]
+          @negative = parts[1]
+        elsif !suffix? && positive?
+          @suffix = create_suffix
+        else
+          create_default_labels
+        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"
+        @validation = /^(y(es)?|no?)$/i
+        @messages[:valid?] = "Invalid input."
+      end
+
+      # @api private
+      def create_suffix
+        (default ? positive.capitalize : positive.downcase) + "/" +
+          (default ? negative.downcase : negative.capitalize)
+      end
+
+      # Create custom conversion
+      #
+      # @api private
+      def conversion
+        ->(input) do
+          positive_word   = Regexp.escape(positive)
+          positive_letter = Regexp.escape(positive[0])
+          pattern = Regexp.new("^(#{positive_word}|#{positive_letter})$", true)
+          !input.match(pattern).nil?
+        end
+      end
+    end # ConfirmQuestion
+  end # Prompt
+end # TTY

data/lib/wibrfake/ty/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/wibrfake/ty/prompt/converter_dsl.rb

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

data/lib/wibrfake/ty/prompt/converter_registry.rb

@@ -0,0 +1,69 @@
+# 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
+      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 # TTY