tty-prompt 0.1.0

data/lib/tty/prompt/response_delegation.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+require 'forwardable'
+
+module TTY
+  class Prompt
+    module ResponseDelegation
+      extend Forwardable
+
+      def_delegators :dispatch, :read,
+                                :read_bool,
+                                :read_char,
+                                :read_choice,
+                                :read_date,
+                                :read_datetime,
+                                :read_email,
+                                :read_file,
+                                :read_float,
+                                :read_input,
+                                :read_int,
+                                :read_keypress,
+                                :read_multiple,
+                                :read_password,
+                                :read_range,
+                                :read_regex,
+                                :read_string,
+                                :read_symbol,
+                                :read_text
+
+      # Create response instance when question readed is invoked
+      #
+      # @param [Response] response
+      #
+      # @api private
+      def dispatch(response = Response.new(self, shell))
+        @response ||= response
+      end
+
+    end # ResponseDelegation
+  end # Prompt
+end # TTY

data/lib/tty/prompt/statement.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+module TTY
+  # A class responsible for shell prompt interactions.
+  class Prompt
+    # A class representing a statement output to shell.
+    class Statement
+      # @api private
+      attr_reader :shell
+      private :shell
+
+      # Flag to display newline
+      #
+      # @api public
+      attr_reader :newline
+
+      # Color used to display statement
+      #
+      # @api public
+      attr_reader :color
+
+      # Initialize a Statement
+      #
+      # @param [TTY::Shell] shell
+      #
+      # @param [Hash] options
+      #
+      # @option options [Symbol] :newline
+      #   force a newline break after the message
+      #
+      # @option options [Symbol] :color
+      #   change the message display to color
+      #
+      # @api public
+      def initialize(shell = Prompt.new, options = {})
+        @shell   = shell
+        @pastel  = Pastel.new
+        @newline = options.fetch(:newline, true)
+        @color   = options.fetch(:color, false)
+      end
+
+      # Output the message to the shell
+      #
+      # @param [String] message
+      #   the message to be printed to stdout
+      #
+      # @api public
+      def declare(message)
+        message = @pastel.decorate message, *color if color
+
+        if newline && /( |\t)(\e\[\d+(;\d+)*m)?\Z/ !~ message
+          shell.output.puts message
+        else
+          shell.output.print message
+          shell.output.flush
+        end
+      end
+    end # Statement
+  end # Prompt
+end # TTY

data/lib/tty/prompt/suggestion.rb

@@ -0,0 +1,113 @@
+# encoding: utf-8
+
+require 'tty/prompt/distance'
+
+module TTY
+  # A class responsible for shell prompt interactions.
+  class Prompt
+    # A class representing a suggestion
+    class Suggestion
+      DEFAULT_INDENT = 8
+
+      SINGLE_TEXT    = 'Did you mean this?'
+
+      PLURAL_TEXT    = 'Did you mean one of these?'
+
+      # Number of spaces
+      #
+      # @api public
+      attr_reader :indent
+
+      # Text for a single suggestion
+      #
+      # @api public
+      attr_reader :single_text
+
+      # Text for multiple suggestions
+      #
+      # @api public
+      attr_reader :plural_text
+
+      # Initialize a Suggestion
+      #
+      # @api public
+      def initialize(options = {})
+        @indent      = options.fetch(:indent) { DEFAULT_INDENT }
+        @single_text = options.fetch(:single_text) { SINGLE_TEXT }
+        @plural_text = options.fetch(:plural_text) { PLURAL_TEXT }
+        @suggestions = []
+        @comparator  = Distance.new
+      end
+
+      # Suggest matches out of possibile strings
+      #
+      # @param [String] message
+      #
+      # @param [Array[String]] possibilities
+      #
+      # @api public
+      def suggest(message, possibilities)
+        distances        = measure_distances(message, possibilities)
+        minimum_distance = distances.keys.min
+        max_distance     = distances.keys.max
+
+        if minimum_distance < max_distance
+          @suggestions = distances[minimum_distance].sort
+        end
+        evaluate
+      end
+
+      private
+
+      # Measure distances between messag and possibilities
+      #
+      # @param [String] message
+      #
+      # @param [Array[String]] possibilities
+      #
+      # @return [Hash]
+      #
+      # @api private
+      def measure_distances(message, possibilities)
+        distances = Hash.new { |hash, key| hash[key] = [] }
+
+        possibilities.each do |possibility|
+          distances[@comparator.distance(message, possibility)] << possibility
+        end
+        distances
+      end
+
+      # Build up a suggestion string
+      #
+      # @param [Array[String]] suggestions
+      #
+      # @return [String]
+      #
+      # @api private
+      def evaluate
+        return @suggestions if @suggestions.empty?
+        if @suggestions.one?
+          build_single_suggestion
+        else
+          build_multiple_suggestions
+        end
+      end
+
+      # @api private
+      def build_single_suggestion
+        suggestion = ''
+        suggestion << single_text + "\n"
+        suggestion << (' ' * indent + @suggestions.first)
+      end
+
+      # @api private
+      def build_multiple_suggestions
+        suggestion = ''
+        suggestion << plural_text + "\n"
+        suggestion << @suggestions.map do |sugest|
+          ' ' * indent + sugest
+        end.join("\n")
+      end
+    end # Suggestion
+  end # Prompt
+end # TTY

data/lib/tty/prompt/utils.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+module TTY
+  module Utils
+    extend self
+
+    def extract_options!(args)
+      args.last.respond_to?(:to_hash) ? args.pop : {}
+    end
+
+    def extract_options(args)
+      options = args.last
+      options.respond_to?(:to_hash) ? options.to_hash.dup : {}
+    end
+  end # Utils
+end # TTY

data/lib/tty/prompt/version.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+module TTY
+  class Prompt
+    VERSION = "0.1.0"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+if RUBY_VERSION > '1.9' and (ENV['COVERAGE'] || ENV['TRAVIS'])
+  require 'simplecov'
+  require 'coveralls'
+
+  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+    SimpleCov::Formatter::HTMLFormatter,
+    Coveralls::SimpleCov::Formatter
+  ]
+
+  SimpleCov.start do
+    command_name 'spec'
+    add_filter 'spec'
+  end
+end
+
+require 'tty-prompt'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  # Limits the available syntax to the non-monkey patched syntax that is recommended.
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  if config.files_to_run.one?
+    config.default_formatter = 'doc'
+  end
+
+  config.profile_examples = 2
+
+  config.order = :random
+
+  Kernel.srand config.seed
+end

data/spec/unit/ask_spec.rb

@@ -0,0 +1,77 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Prompt, '#ask' do
+  let(:input)  { StringIO.new }
+  let(:output) { StringIO.new }
+  let(:prefix) { '' }
+  let(:options) { { prefix: prefix } }
+
+  subject(:prompt) { TTY::Prompt.new(input, output, options) }
+
+  it 'prints message' do
+    prompt.ask "What is your name?"
+    expect(output.string).to eql "What is your name?\n"
+  end
+
+  it 'prints an empty message ' do
+    prompt.ask ""
+    expect(output.string).to eql ""
+  end
+
+  it 'prints an empty message and returns nil if EOF is sent to stdin' do
+    input << nil
+    input.rewind
+    q = prompt.ask ""
+    expect(q.read).to eql nil
+  end
+
+  context 'with a prompt prefix' do
+    let(:prefix) { ' > ' }
+
+    it "asks a question with '>'" do
+      input << ''
+      input.rewind
+      prompt.ask "Are you Polish?"
+      expect(output.string).to eql " > Are you Polish?\n"
+    end
+  end
+
+  it 'asks a question with block' do
+    input << ''
+    input.rewind
+    q = prompt.ask "What is your name?" do
+      default 'Piotr'
+    end
+    expect(q.read).to eql "Piotr"
+  end
+
+  context 'yes?' do
+    it 'agrees' do
+      input << 'yes'
+      input.rewind
+      expect(prompt.yes?("Are you a human?")).to eq(true)
+    end
+
+    it 'disagrees' do
+      input << 'no'
+      input.rewind
+      expect(prompt.yes?("Are you a human?")).to eq(false)
+    end
+  end
+
+  context 'no?' do
+    it 'agrees' do
+      input << 'no'
+      input.rewind
+      expect(prompt.no?("Are you a human?")).to eq(true)
+    end
+
+    it 'disagrees' do
+      input << 'yes'
+      input.rewind
+      expect(prompt.no?("Are you a human?")).to eq(false)
+    end
+  end
+end

data/spec/unit/distance/distance_spec.rb

@@ -0,0 +1,75 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Prompt::Distance, '.distance' do
+  let(:object) { described_class.new }
+
+  subject(:distance) { object.distance(*strings) }
+
+  context 'when nil' do
+    let(:strings) { [nil, nil] }
+
+    it { is_expected.to eql(0) }
+  end
+
+  context 'when empty' do
+    let(:strings) { ['', ''] }
+
+    it { is_expected.to eql(0) }
+  end
+
+  context 'with one non empty' do
+    let(:strings) { ['abc', ''] }
+
+    it { is_expected.to eql(3) }
+  end
+
+  context 'when single char' do
+    let(:strings) { ['a', 'abc'] }
+
+    it { is_expected.to eql(2) }
+  end
+
+  context 'when similar' do
+    let(:strings) { ['abc', 'abc'] }
+
+    it { is_expected.to eql(0) }
+  end
+
+  context 'when similar' do
+    let(:strings) { ['abc', 'acb'] }
+
+    it { is_expected.to eql(1) }
+  end
+
+  context 'when end similar' do
+    let(:strings) { ['saturday', 'sunday'] }
+
+    it { is_expected.to eql(3) }
+  end
+
+  context 'when contain similar' do
+    let(:strings) { ['which', 'witch'] }
+
+    it { is_expected.to eql(2) }
+  end
+
+  context 'when prefix' do
+    let(:strings) { ['sta', 'status'] }
+
+    it { is_expected.to eql(3) }
+  end
+
+  context 'when similar' do
+    let(:strings) { ['smellyfish','jellyfish'] }
+
+    it { is_expected.to eql(2) }
+  end
+
+  context 'when unicode' do
+    let(:strings) { ['マラソン五輪代表', 'ララソン五輪代表'] }
+
+    it { is_expected.to eql(1) }
+  end
+end

data/spec/unit/error_spec.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Prompt, '.error' do
+  let(:input)  { StringIO.new }
+  let(:output) { StringIO.new }
+  let(:color)  { Pastel.new(enabled: true) }
+
+  subject(:prompt) { described_class.new(input, output) }
+
+  before { allow(Pastel).to receive(:new).and_return(color) }
+
+  after { output.rewind }
+
+  it 'displays one message' do
+    prompt.error "Nothing is fine!"
+    expect(output.string).to eql "\e[31mNothing is fine!\e[0m\n"
+  end
+
+  it 'displays many messages' do
+    prompt.error "Nothing is fine!", "All is broken!"
+    expect(output.string).to eql "\e[31mNothing is fine!\e[0m\n\e[31mAll is broken!\e[0m\n"
+  end
+
+  it 'displays message with option' do
+    prompt.error "Nothing is fine!", newline: false
+    expect(output.string).to eql "\e[31mNothing is fine!\e[0m"
+  end
+end