austb-tty-prompt 0.13.0

data/lib/tty/prompt/answers_collector.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+module TTY
+  class Prompt
+    class AnswersCollector
+      # Initialize answer collector
+      #
+      # @api public
+      def initialize(prompt, options = {})
+        @prompt  = prompt
+        @answers = options.fetch(:answers) { {} }
+      end
+
+      # Start gathering answers
+      #
+      # @return [Hash]
+      #   the collection of all answers
+      #
+      # @api public
+      def call(&block)
+        instance_eval(&block)
+        @answers
+      end
+
+      # Create answer entry
+      #
+      # @example
+      #   key(:name).ask('Name?')
+      #
+      # @api public
+      def key(name, &block)
+        @name = name
+        if block
+          answer = create_collector.(&block)
+          add_answer(answer)
+        end
+        self
+      end
+
+      # @api public
+      def create_collector
+        self.class.new(@prompt)
+      end
+
+      # @api public
+      def add_answer(answer)
+        @answers[@name] = answer
+      end
+
+      private
+
+      # @api private
+      def method_missing(method, *args, &block)
+        answer = @prompt.public_send(method, *args, &block)
+        add_answer(answer)
+      end
+    end # AnswersCollector
+  end # Prompt
+end # TTY

data/lib/tty/prompt/choice.rb

@@ -0,0 +1,90 @@
+# encoding: utf-8
+
+module TTY
+  class Prompt
+    # A single choice option
+    #
+    # @api public
+    class Choice
+      # The label name
+      #
+      # @api public
+      attr_reader :name
+
+      attr_reader :key
+
+      # Create a Choice instance
+      #
+      # @api public
+      def initialize(name, value, key = nil)
+        @name  = name
+        @value = value
+        @key   = key
+      end
+
+      # Create choice from value
+      #
+      # @example
+      #   Choice.from(:option_1)
+      #   Choice.from([:option_1, 1])
+      #
+      # @param [Object] val
+      #   the value to be converted
+      #
+      # @raise [ArgumentError]
+      #
+      # @return [Choice]
+      #
+      # @api public
+      def self.from(val)
+        case val
+        when Choice
+          val
+        when String, Symbol
+          new(val, val)
+        when Array
+          new("#{val.first}", val.last)
+        when Hash
+          if val.key?(:name)
+            new("#{val[:name]}", val[:value], val[:key])
+          else
+            new("#{val.keys.first}", val.values.first)
+          end
+        else
+          raise ArgumentError, "#{val} cannot be coerced into Choice"
+        end
+      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
+      end
+
+      # Object string representation
+      #
+      # @return [String]
+      #
+      # @api public
+      def to_s
+        "#{name}"
+      end
+    end # Choice
+  end # Prompt
+end # TTY

data/lib/tty/prompt/choices.rb

@@ -0,0 +1,110 @@
+# encoding: utf-8
+
+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
+
+      # The actual collection choices
+      #
+      # @return [Array[Choice]]
+      #
+      # @api public
+      attr_reader :choices
+
+      def_delegators :choices, :length, :size, :to_ary, :empty?, :values_at
+
+      # 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
+
+      # 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
+      #
+      # @exmaple
+      #   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
+    end # Choices
+  end # Prompt
+end # TTY

data/lib/tty/prompt/confirm_question.rb

@@ -0,0 +1,129 @@
+# encoding: utf-8
+
+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 = convert_result(@input)
+          label  = answer ? @positive : @negative
+          header += @prompt.decorate(label, @active_color)
+        end
+        header << "\n" if @done
+        header
+      end
+
+      protected
+
+      # @api private
+      def setup_defaults
+        return if suffix? && positive?
+
+        if suffix? && (!positive? || !negative?)
+          parts = @suffix.split('/')
+          @positive = parts[0]
+          @negative = parts[1]
+          @convert = conversion
+        elsif !suffix? && positive?
+          @suffix = create_suffix
+          @convert = conversion
+        else
+          create_default_labels
+          @convert = :bool
+        end
+      end
+
+      # @api private
+      def create_default_labels
+        @suffix   = default ? 'Y/n' : 'y/N'
+        @positive = default ? 'Yes' : 'yes'
+        @negative = default ? 'no' : 'No'
+      end
+
+      # @api private
+      def create_suffix
+        result = ''
+        result << "#{default ? positive.capitalize : positive.downcase}"
+        result << '/'
+        result << "#{default ? negative.downcase : negative.capitalize}"
+      end
+
+      # Create custom conversion
+      #
+      # @api private
+      def conversion
+        proc { |input| !input.match(/^#{positive}|#{positive[0]}$/i).nil? }
+      end
+    end # ConfirmQuestion
+  end # Prompt
+end # TTY

data/lib/tty/prompt/converter_dsl.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require_relative 'converter_registry'
+
+module TTY
+  class Prompt
+    module ConverterDSL
+      def converter_registry
+        @converter_registry ||= ConverterRegistry.new
+      end
+
+      def converter(name, &block)
+        @converter_registry = converter_registry.register(name, &block)
+        self
+      end
+
+      def convert(name, data)
+        @converter_registry[name, data]
+      end
+    end # ConverterDSL
+  end # Prompt
+end # TTY

data/lib/tty/prompt/converter_registry.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+module TTY
+  class Prompt
+    # Immutable collection of converters for type transformation
+    #
+    # @api private
+    class ConverterRegistry
+      # Create a registry of conversions
+      #
+      # @param [Hash] registry
+      #
+      # @api private
+      def initialize(registry = {})
+        @_registry = registry.dup.freeze
+        freeze
+      end
+
+      # Register converter
+      #
+      # @param [Symbol] name
+      #   the converter name
+      #
+      # @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))
+      end
+
+      # Check if converter is registered
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def key?(key)
+        @_registry.key?(key)
+      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
+        end
+        converter[input]
+      end
+      alias [] call
+
+      def inspect
+        @_registry.inspect
+      end
+    end # ConverterRegistry
+  end # Prompt
+end # TTY