tty2-prompt 0.23.1.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a31ec4aa1ef32dbce0b75a62191dad2c4b108e7f801ba6918862a57021339acf
+  data.tar.gz: 7fba5b2d9b0f076dca7ef7a462c6abca5373a123538e7abc95c7821855bab79c
+SHA512:
+  metadata.gz: b0b987b875d9fec6de8511467db39ea7aeff6db61561ed73490acbd7bbb69ff798ad4cc078a7bbb3af065e3702f916ff0353106e63e66615179ac790cd810b4b
+  data.tar.gz: 113405ed0aebead16dcc0739012e05eb7d5b430f923cba02c44b2d423e40dfc21273bcc7c741c2b247702af39a6a5ff1ec6ca626b0880b22047cfc80feb91074

data/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Change log
+
+## [v0.23.1.1] - 2021-12-13
+
+### Added
+
+### Changed
+* Forked TTY::Prompt and reworked to TTY2::Prompt
+* Change to make use of tty2-reader instead of tty-reader
+
+### Fix
+
+
+[v0.23.1.1]: https://github.com/zzyzwicz/tty2-prompt/compare/v0.23.1.1

data/LICENSE.txt

@@ -0,0 +1,23 @@
+Copyright for portions of project TTY2::Prompt are held by Piotr Murach, 2015 as part of project TTY::Prompt.
+All other copyright for project TTY2::Prompt are held by zzyzwicz, 2021.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,52 @@
+
+# TTY2::Prompt
+
+[![Gem Version](https://badge.fury.io/rb/tty2-prompt.svg)][gem]
+[![Build status](https://ci.appveyor.com/api/projects/status/570nk071y68idah1?svg=true)][appveyor]
+
+[gem]: http://badge.fury.io/rb/tty2-prompt
+[appveyor]: https://ci.appveyor.com/project/zzyzwicz/tty2-prompt
+
+> A tty-prompt fork with the objective of adding a customized word completion mechanism
+
+**TTY2::Prompt** intends to be an up to date clone of [TTY::Prompt](https://github.com/piotrmurach/tty-prompt), solely extending it with a customized word completion mechanism.
+This page only covers the applied modifications.
+
+## Modifications
+
+* Renamed to TTY2::Prompt
+* Make use of TTY2::Reader instead of TTY::Reader
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "tty2-prompt"
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install tty2-prompt
+
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/zzyzwicz/tty2-prompt.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the TTY2::Reader project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/piotrmurach/tty-reader/blob/master/CODE_OF_CONDUCT.md).
+
+## Copyright
+
+Copyright for portions of project TTY2::Prompt are held by Piotr Murach, 2015 as part of project TTY::Prompt.
+All other copyright for project TTY2::Prompt are held by zzyzwicz, 2021.

data/lib/tty2/prompt/answers_collector.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module TTY2
+  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.call(&block)
+          add_answer(answer)
+        end
+        self
+      end
+
+      # Change to collect all values for a key
+      #
+      # @example
+      #   key(:colors).values.ask("Color?")
+      #
+      # @api public
+      def values(&block)
+        @answers[@name] = Array(@answers[@name])
+        if block
+          answer = create_collector.call(&block)
+          add_answer(answer)
+        end
+        self
+      end
+
+      # @api public
+      def create_collector
+        self.class.new(@prompt)
+      end
+
+      # @api public
+      def add_answer(answer)
+        if @answers[@name].is_a?(Array)
+          @answers[@name] << answer
+        else
+          @answers[@name] = answer
+        end
+      end
+
+      private
+
+      # @api private
+      def method_missing(method, *args, **options, &block)
+        answer = @prompt.public_send(method, *args, **options, &block)
+        add_answer(answer)
+      end
+    end # AnswersCollector
+  end # Prompt
+end # TTY2

data/lib/tty2/prompt/block_paginator.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative "paginator"
+
+module TTY2
+  class Prompt
+    class BlockPaginator < Paginator
+      # Paginate list of choices based on current active choice.
+      # Move entire pages.
+      #
+      # @api public
+      def paginate(list, active, per_page = nil, &block)
+        default_size = (list.size <= DEFAULT_PAGE_SIZE ? list.size : DEFAULT_PAGE_SIZE)
+        @per_page = @per_page || per_page || default_size
+
+        check_page_size!
+
+        # Don't paginate short lists
+        if list.size <= @per_page
+          @start_index = 0
+          @end_index = list.size - 1
+          if block
+            return list.each_with_index(&block)
+          else
+            return list.each_with_index.to_enum
+          end
+        end
+
+        unless active.nil? # User may input index out of range
+          @last_index = active
+        end
+        page  = (@last_index / @per_page.to_f).ceil
+        pages = (list.size / @per_page.to_f).ceil
+        if page == 0
+          @start_index = 0
+          @end_index = @start_index + @per_page - 1
+        elsif page > 0 && page < pages
+          @start_index = (page - 1) * @per_page
+          @end_index = @start_index + @per_page - 1
+        elsif page == pages
+          @start_index = (page - 1) * @per_page
+          @end_index = list.size - 1
+        else
+          @end_index = list.size - 1
+          @start_index = @end_index - @per_page + 1
+        end
+
+        sliced_list = list[@start_index..@end_index]
+        page_range = (@start_index..@end_index)
+
+        return sliced_list.zip(page_range).to_enum unless block_given?
+
+        sliced_list.each_with_index do |item, index|
+          block[item, @start_index + index]
+        end
+      end
+    end # EnumPaginator
+  end # Prompt
+end # TTY2

data/lib/tty2/prompt/choice.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module TTY2
+  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)
+      #   # => <TTY2::Prompt::Choice @key=nil @name="foo" @value="foo" @disabled=false>
+      #
+      #   Choice.from([:foo, 1])
+      #   # => <TTY2::Prompt::Choice @key=nil @name="foo" @value=1 @disabled=false>
+      #
+      #   Choice.from({name: :foo, value: 1, key: "f"}
+      #   # => <TTY2::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 # TTY2

data/lib/tty2/prompt/choices.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+require_relative "choice"
+
+module TTY2
+  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 # TTY2

data/lib/tty2/prompt/confirm_question.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require_relative "question"
+require_relative "utils"
+
+module TTY2
+  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 # TTY2

data/lib/tty2/prompt/const.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module TTY2
+  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 # TTY2

data/lib/tty2/prompt/converter_dsl.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "converter_registry"
+
+module TTY2
+  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 # TTY2