input_reader 0.0.1 → 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d098ae0ddf4e3d2f9db106f0be0bf882bf94e2a4
+  data.tar.gz: b4de31045b953ed310ac4a536bd493de042296db
+SHA512:
+  metadata.gz: 2672ce79bb63b0c0f0205ee1fb5248ea5fd3d4b454caca26490dea17d2ead7befbd139a43da732dea4630a152e103e5e555d39a0f333ea80d88946868276e2f1
+  data.tar.gz: 1eb8bda20b4c47fb2a3e5bf63e2ddebd83c6352b96ad5397b1ead08bec3551de27adec6edb366586330054ac3bbbc3b89fe35a71b3a72f6c058756f91d59af19

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.travis.yml

@@ -0,0 +1,12 @@
+language: ruby
+rvm:
+  - 2.2
+  - 2.3.0
+script: "bundle exec rake spec"
+notifications:
+  email:
+    - support@travellink.com.au
+  flowdock:
+    secure: PGMmGX4ppcqe1JlyJH4A51zAPX23okFNqu5KKcpYYTrZQ5KsCctzmGshiXX0PUOqFRPXiOc9+qhR0A6UmW7Hd5toocm9XjysODE6aho1FJMh/VNLK5sK8JSGlideoP8RYadgfJjZjDaLwcgj4da46kfLugA9VqdsfAM1LroWA+E=
+sudo: false
+cache: bundler

data/Guardfile

@@ -0,0 +1,23 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  # Rails example
+  watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^app/(.*)(\.erb|\.haml)$})                 { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
+  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+  watch('config/routes.rb')                           { "spec/routing" }
+  watch('app/controllers/application_controller.rb')  { "spec/controllers" }
+  
+  # Capybara request specs
+  watch(%r{^app/views/(.+)/.*\.(erb|haml)$})          { |m| "spec/requests/#{m[1]}_spec.rb" }
+  
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$})   { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'spec/acceptance' }
+end
+

data/README.md

@@ -1,6 +1,11 @@
-# InputReader
+InputReader
+===========
 
-TODO: Write a gem description
+[![Build Status](https://travis-ci.org/sealink/input_reader.png?branch=master)](https://travis-ci.org/sealink/input_reader)
+[![Build Status](https://gemnasium.com/sealink/input_reader.png?travis)](https://gemnasium.com/sealink/input_reader)
+[![Build Status](https://codeclimate.com/github/sealink/input_reader.png)](https://codeclimate.com/github/sealink/input_reader)
+
+Reads and parses input and helps build input menus, etc.
 
 ## Installation
 

data/Rakefile

@@ -1,2 +1,12 @@
-#!/usr/bin/env rake
 require "bundler/gem_tasks"
+
+desc 'Default: run specs.'
+task :default => :spec
+
+require 'rspec/core/rake_task'
+
+desc "Run specs"
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = "./spec/**/*_spec.rb" # don't need this, it's default.
+  # Put spec opts in a file named .rspec in root
+end

data/input_reader.gemspec

@@ -14,4 +14,12 @@ Gem::Specification.new do |gem|
   gem.name          = "input_reader"
   gem.require_paths = ["lib"]
   gem.version       = InputReader::VERSION
+
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'simplecov'
+  gem.add_development_dependency 'simplecov-rcov'
+  gem.add_development_dependency 'guard-rspec'
+  gem.add_development_dependency 'coveralls'
+  gem.add_development_dependency 'travis'
 end

data/lib/input_reader.rb

@@ -1,50 +1,54 @@
 require "input_reader/version"
 
 module InputReader
-  require 'input_reader/input_reader'
+  require 'input_reader/builder'
 
   class << self
-    def get_input(options = nil)
-      InputReader::Builder.new(options).get_input
+    def boolean_true_values
+      %w{y yes t true 1}
     end
 
+    def boolean_false_values
+      %w{n no f false 0}
+    end
 
-    def get_string(options = nil)
-      self.get_input_with_exception_handling(options)
+    def get_input(options = {})
+      InputReader::Builder.new(options).get_input
     end
 
+    def get_string(options = {})
+      self.get_input_with_exception_handling(options)
+    end
 
-    def get_boolean(options = nil)
-      options ||= {}
-      true_values = %w{y t true 1}
-      false_values = %w{n f false 0}
-      all_values = true_values + false_values
-      options[:validators] = [{:message => "Invalid input given. Valid values are #{all_values.join(', ')}",
-          :validator => lambda { |input| all_values.include?(input.to_s.downcase) } }]
-      options[:prompt] ||= "(Y/N)?"
+    def get_boolean(options = {})
+      all_values           = boolean_true_values + boolean_false_values
+      options[:validators] = [{:message   => "Invalid input given. Valid values are #{all_values.join(', ')}",
+                               :validator => lambda { |input| all_values.include?(input.to_s.downcase) }}]
+      options[:prompt] ||= '(Y/N)?'
       input = self.get_input(options)
-      true_values.include?(input.to_s.downcase)
+      if boolean_true_values.include?(input.to_s.downcase)
+        true
+      elsif boolean_false_values.include?(input.to_s.downcase)
+        false
+      else
+        nil
+      end
     end
 
-
-    def get_int(options = nil)
+    def get_int(options = {})
       self.get_and_parse_input(:to_i, options)
     end
 
-
-    def get_date(options = nil)
-      self.get_and_parse_input(:to_date, options)
+    def get_date(options = {})
+      self.get_and_parse_input(lambda { |d| Date.parse(d) }, options)
     end
 
-
-    def get_datetime(options = nil)
-      self.get_and_parse_input(:to_datetime, options)
+    def get_datetime(options = {})
+      self.get_and_parse_input(lambda { |dt| DateTime.parse(dt) }, options)
     end
 
-
-    def get_array(options = nil)
-      options ||= {}
-      array = []
+    def get_array(options = {})
+      array         = []
       input_options = options.merge(:allow_blank => true)
       while input = self.get_input_with_exception_handling(input_options)
         array << input
@@ -52,107 +56,104 @@ module InputReader
       array
     end
 
-
-    def get_array_of_ints(options = nil)
+    def get_array_of_ints(options = {})
       self.get_and_parse_array(:to_i, options)
     end
 
-
-    def get_array_of_dates(options = nil)
-      self.get_and_parse_array(:to_date, options)
+    def get_array_of_dates(options = {})
+      self.get_and_parse_array(lambda { |d| Date.parse(d) }, options)
     end
 
-
-    def get_array_of_datetimes(options = nil)
-      self.get_and_parse_array(:to_datetime, options)
+    def get_array_of_datetimes(options = {})
+      self.get_and_parse_array(lambda { |dt| DateTime.parse(dt) }, options)
     end
 
-
-    def get_and_parse_array(parsers, options = nil)
-      options ||= {}
-      options[:parsers] = Array.wrap(options[:parsers]) + Array.wrap(parsers)
+    def get_and_parse_array(parsers, options = {})
+      options[:parsers] = Array(options[:parsers]) + Array(parsers)
       get_array(options)
     end
 
-
-    def get_and_parse_input(parsers, options = nil)
-      options ||= {}
-      options[:parsers] = Array.wrap(options[:parsers]) + Array.wrap(parsers)
+    def get_and_parse_input(parsers, options = {})
+      options[:parsers] = Array(options[:parsers]) + Array(parsers)
       self.get_input_with_exception_handling(options)
     end
 
-
-    def get_input_with_exception_handling(options = nil)
-      options ||= {}
+    def get_input_with_exception_handling(options = {})
       valid_input = false
       while !valid_input
         begin
           input = self.get_input(options)
           valid_input = true
+        rescue Interrupt
+          raise
         rescue Exception => e
-          raise e if e.is_a?(Interrupt)
           puts e.message
         end
       end
       input
     end
 
+    def prompt_choices(items, selection_attribute = nil)
+      items.each.with_index do |item, i|
+        option = if selection_attribute.is_a?(String) || selection_attribute.is_a?(Symbol)
+                   item.send(selection_attribute)
+                 elsif selection_attribute.is_a?(Proc)
+                   selection_attribute.call(item)
+                 else
+                   item
+                 end
+        puts "#{i + 1}. #{option}"
+      end
+    end
 
-    def select_item(items, options = nil)
-      options ||= {}
+    def select_item(items, options = {})
       prompt_choices(items, options[:selection_attribute])
       input = get_int({
-        :valid_values => (1..items.size).to_a,
-        :allow_blank => options[:allow_blank],
-        :prompt => options[:prompt] || "Choice: "
-      })
-      input && items[input - 1]
+                        :valid_values => (1..items.size).to_a,
+                        :allow_blank  => options[:allow_blank],
+                        :prompt       => options[:prompt] || 'Choice: '
+                      })
+      return nil if input.nil?
+      items[input - 1]
     end
 
-
-    def select_items(items, options = nil)
-      options ||= {}
+    def select_items(items, options = {})
       prompt_choices(items, options[:selection_attribute])
       puts "#{items.size + 1}. All"
       input = get_input({
-        :parsers => [lambda { |input|
-            choices = input.strip.gsub(/\s*,\s*/, ",").split(',').map(&:to_i)
-            if choices.include?(items.size + 1)
-              choices = (1..items.size).to_a
-            end
-            choices
-          }],
-        :validators => [lambda { |input| input.all? { |i| i > 0 && i <= items.size} }],
-        :allow_blank => options[:allow_blank],
-        :prompt => options[:prompt] || "Choices (separate with comma): "
-      })
-      input && input.map { |c| items[c - 1] }
+                          :parsers     => [lambda { |input|
+                            choices = input.strip.gsub(/\s*,\s*/, ',').split(',').map(&:to_i)
+                            if choices.include?(items.size + 1)
+                              choices = (1..items.size).to_a
+                            end
+                            choices
+                          }],
+                          :validators  => [lambda { |input| input.all? { |i| i > 0 && i <= items.size } }],
+                          :allow_blank => options[:allow_blank],
+                          :prompt      => options[:prompt] || 'Choices (separate with comma): '
+                        })
+      return [] if input.nil?
+      input.map { |c| items[c - 1] }
     end
 
-
     def confirmation_required(messages = '')
-      puts ""
-      puts "-" * 110
-      puts "[Messages]"
+      puts '-' * 110
+      puts '[Messages]'
       puts messages
-      puts "-" * 110
-      puts ""
-      print "Are you sure you want to do this? (Y/N): "
-      user_answer = STDIN.gets.chomp.upcase
+      puts '-' * 110
+      print 'Are you sure? (Y/N): '
 
-      if user_answer != 'Y' && user_answer != 'N'
-        puts "Please enter a valid response. Operation aborted. #{user_answer}"
-      else
-        if user_answer == 'Y'
+      case STDIN.gets.chomp.upcase
+        when 'Y'
           puts
           yield
-
-          puts "----------------------"
-          puts "Operation completed!!"
-          puts "----------------------"
+          puts '----------------------'
+          puts 'Operation completed!!'
+          puts '----------------------'
+        when 'N'
+          puts 'Operation aborted on user prompt'
         else
-          puts "Operation aborted on user prompt"
-        end
+          puts 'Please enter a valid response. Operation aborted.'
       end
     end
   end

data/lib/input_reader/builder.rb

@@ -0,0 +1,155 @@
+module InputReader
+  class Builder
+
+    attr_reader :input
+
+    def initialize(options = {})
+      @prompt                    = options[:prompt]
+      @allow_blank               = options[:allow_blank]
+      @default_value             = options[:default_value]
+      @valid_values              = Array(options[:valid_values])
+      @validators                = Array(options[:validators])
+      @unparsed_input_validators = Array(options[:unparsed_input_validators])
+      @parsed_input_validators   = Array(options[:parsed_input_validators])
+      @parsers                   = Array(options[:parsers])
+    end
+
+
+    def get_input
+      begin
+        $stdout.print "#{@prompt} "
+        flush
+        read_input
+      rescue Exception => e
+        puts e.message + e.class.inspect
+        exit
+      end while !valid_input?
+      @input
+    end
+
+
+    private
+
+    def read
+      $stdin.gets.chomp
+    end
+
+
+    def flush
+      $stdout.flush
+    end
+
+
+    def read_input
+      @input = read
+      @input = @default_value if blank_input?
+    end
+
+
+    def validate_and_parse_input
+      return false unless validate_unparsed_input
+      return true if blank_input?
+      parse_input
+      validate_parsed_input
+    end
+
+
+    def valid_input?
+      validate_and_parse_input
+    end
+
+
+    def blank_input?
+      blank?(@input)
+    end
+
+
+    def blank?(input)
+      case input
+      when NilClass then true
+      when String, Array then input.length == 0
+      else false
+      end
+    end
+
+
+    def validate_unparsed_input
+      validators = [
+        {
+          :validator => lambda { |input| @allow_blank || !blank?(input) },
+          :message   => 'No input given'
+        },
+      ] + @unparsed_input_validators
+      process_validations(validators)
+    end
+
+
+    def validate_parsed_input
+      validators = [
+        {
+          :validator => lambda { |input| blank?(@valid_values) || @valid_values.include?(input) },
+          :message   => "Invalid input given. Valid values are #{@valid_values.join(', ')}"
+        }
+      ] + @parsed_input_validators + @validators
+      process_validations(validators)
+    end
+
+
+    def process_validations(validators)
+      validators.each do |validator|
+        valid = process_validation(validator)
+
+        if !valid
+          puts error_message_for(validator)
+          return false
+        end
+      end
+      true
+    end
+
+
+    def process_validation(validator)
+      validator_proc = validator_proc_for(validator)
+      case validator_proc
+      when Proc
+        validator_proc.call(@input)
+      when String, Symbol
+        @input.send(validator_proc)
+      else
+        true
+      end
+    end
+
+
+    def validator_proc_for(validator)
+      if validator.is_a?(Proc)
+        validator
+      elsif validator.is_a?(Hash)
+        validator[:validator]
+      end
+    end
+
+
+    def error_message_for(validator)
+      if validator.is_a?(Hash) && validator[:message]
+        validator[:message]
+      else
+        'Invalid input'
+      end
+    end
+
+
+    def parse_input
+      @parsers.each do |parser|
+        case parser
+        when Proc
+          @input = parser.call(@input)
+        when String, Symbol
+          @input = @input.send(parser)
+        end
+      end
+      @input
+    end
+
+  end
+end

data/lib/input_reader/version.rb

@@ -1,3 +1,3 @@
 module InputReader
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/spec/input_reader_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+
+require 'input_reader'
+
+describe InputReader do
+  it 'should read strings' do
+    expect_output ' '
+    input '1'
+    InputReader.get_input.should == '1'
+
+    expect_output 'number '
+    input '2'
+    InputReader.get_input(:prompt => 'number').should == '2'
+  end
+
+  it 'should read integers' do
+    input '1'
+    InputReader.get_int.should == 1
+  end
+
+  it 'should read booleans' do
+    input 'y'
+    InputReader.get_boolean.should be true
+
+    input 'F'
+    InputReader.get_boolean.should be false
+  end
+
+  it 'should handle invalid boolean values' do
+    input 'x'
+    input 'y'
+    InputReader.get_boolean.should be true
+  end
+
+  it 'should handle dates' do
+    input '2012-01-13'
+    InputReader.get_date.should == Date.new(2012, 1, 13)
+  end
+
+  it 'should handle date times' do
+    input '2012-01-13 18:45'
+    InputReader.get_datetime.should == DateTime.new(2012, 1, 13, 18, 45, 0)
+  end
+
+  it 'should handle arrays' do
+    input ['1', '2', '3', '']
+    InputReader.get_array.should == ['1', '2', '3']
+  end
+
+  it 'should handle array of ints' do
+    input ['1', '2', '3', '']
+    InputReader.get_array_of_ints.should == [1, 2, 3]
+  end
+
+  it 'should handle array of dates' do
+    input ['2012-01-13', '2012-07-24', '']
+    InputReader.get_array_of_dates.should == [
+      Date.new(2012, 1, 13),
+      Date.new(2012, 7, 24)
+    ]
+  end
+
+  it 'should handle array of date times' do
+    input ['2012-01-13 14:45', '2012-07-24 19:59', '']
+    InputReader.get_array_of_datetimes.should == [
+      DateTime.new(2012, 1, 13, 14, 45, 0),
+      DateTime.new(2012, 7, 24, 19, 59)
+    ]
+  end
+
+  it 'should allow selecting between choices' do
+    input '2'
+    InputReader.select_item(['Alpha', 'Beta', 'Gamma']).should == 'Beta'
+  end
+
+  it 'should return nil if no choice is selected' do
+    input ''
+    InputReader.select_item(['Alpha', 'Beta', 'Gamma'],
+                            :allow_blank => true).should == nil
+  end
+
+  it 'should handle selecting between multiple choices' do
+    objects = [
+      double(:name => 'Alpha'),
+      double(:name => 'Beta'),
+      double(:name => 'Gamma')
+    ]
+    input '1,3'
+    InputReader.select_items(objects, :selection_attribute => :name).should ==
+      [objects[0], objects[2]]
+  end
+
+  it 'should return an empty array if no choices are selected' do
+    objects = [
+      double(:name => 'Alpha'),
+      double(:name => 'Beta'),
+      double(:name => 'Gamma')
+    ]
+    input ''
+    InputReader.select_items(objects,
+                             :selection_attribute => :name,
+                             :allow_blank         => true).should == []
+  end
+
+  it 'should allow confirming' do
+    input 'N'
+    block = lambda{ }
+    block.should_not_receive(:call)
+    InputReader.confirmation_required do
+      block.call
+    end
+
+    input 'Y'
+    block = lambda{ }
+    block.should_receive(:call)
+    InputReader.confirmation_required do
+      block.call
+    end
+
+    input 'X'
+    block = lambda{ }
+    block.should_not_receive(:call)
+    InputReader.confirmation_required do
+      block.call
+    end
+  end
+
+  it 'should validate unparsed input' do
+    input ['1', '2']
+    InputReader.get_int(
+      :parsed_input_validators => [{:validator => :even?}]
+    ).should == 2
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,34 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end
+
+require 'support/coverage_loader'
+
+def expect_output(output)
+  $stdout.should_receive(:print).with(output)
+end
+
+def input(input)
+  if input.is_a?(String)
+    $stdin.should_receive(:gets).once.and_return(input)
+  elsif input.is_a?(Array)
+    $stdin.should_receive(:gets).exactly(input.size).times.and_return(*input)
+  else
+  end
+end
+
+require 'input_reader'

data/spec/support/coverage_loader.rb

@@ -0,0 +1,26 @@
+MINIMUM_COVERAGE = 94
+
+unless ENV['COVERAGE'] == 'off'
+  require 'simplecov'
+  require 'simplecov-rcov'
+  require 'coveralls'
+  Coveralls.wear!
+
+  SimpleCov.formatters = [
+    SimpleCov::Formatter::RcovFormatter,
+    Coveralls::SimpleCov::Formatter
+  ]
+  SimpleCov.start do
+    add_filter '/vendor/'
+    add_filter '/spec/'
+    add_group 'lib', 'lib'
+  end
+  SimpleCov.at_exit do
+    SimpleCov.result.format!
+    percent = SimpleCov.result.covered_percent
+    unless percent >= MINIMUM_COVERAGE
+      puts "Coverage must be above #{MINIMUM_COVERAGE}%. It is #{"%.2f" % percent}%"
+      Kernel.exit(1)
+    end
+  end
+end

metadata

@@ -1,16 +1,113 @@
 --- !ruby/object:Gem::Specification
 name: input_reader
 version: !ruby/object:Gem::Version
-  version: 0.0.1
-  prerelease: 
+  version: 0.1.0
 platform: ruby
 authors:
 - Alessandro Berardi, Michael Noack
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-13 00:00:00.000000000 Z
-dependencies: []
+date: 2016-06-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov-rcov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: travis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Command line helpers to read input of various types, confirm, etc.
 email:
 - support@travellink.com.au
@@ -18,37 +115,45 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
 - Gemfile
+- Guardfile
 - LICENSE
 - README.md
 - Rakefile
 - input_reader.gemspec
 - lib/input_reader.rb
-- lib/input_reader/input_reader.rb
+- lib/input_reader/builder.rb
 - lib/input_reader/version.rb
+- spec/input_reader_spec.rb
+- spec/spec_helper.rb
+- spec/support/coverage_loader.rb
 homepage: ''
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.4.8
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Command line helpers to read input, etc.
-test_files: []
+test_files:
+- spec/input_reader_spec.rb
+- spec/spec_helper.rb
+- spec/support/coverage_loader.rb

data/lib/input_reader/input_reader.rb

@@ -1,140 +0,0 @@
-module InputReader
-class Builder
-
-  attr_reader :input
-
-  def initialize(options = nil)
-    options ||= {}
-    @prompt = options[:prompt]
-    @allow_blank = options[:allow_blank]
-    @default_value = options[:default_value]
-    @valid_values = Array.wrap(options[:valid_values])
-    @validators = Array.wrap(options[:validators])
-    @pre_validators = Array.wrap(options[:pre_validators])
-    @post_validators = Array.wrap(options[:post_validators])
-    @parsers = Array.wrap(options[:parsers])
-  end
-
-
-  def get_input
-    begin
-      print "#{@prompt} "
-      flush
-    rescue Exception => e
-      puts e.message + e.class.inspect
-      exit
-    end while !valid_input?
-    @input
-  end
-
-
-  private
-
-
-  def read
-    $stdin.gets.chomp
-  end
-
-
-  def flush
-    $stdout.flush
-  end
-
-
-  def self.prompt_choices(items, selection_attribute = nil)
-    items.each.with_index do |item,i|
-      option = if selection_attribute.is_a?(String) || selection_attribute.is_a?(Symbol)
-        item.send(selection_attribute)
-      elsif selection_attribute.is_a?(Proc)
-        selection_attribute.call(item)
-      else
-        item
-      end
-      puts "#{i + 1}. #{option}"
-    end
-  end
-  
-  
-  def valid_input?
-    @input = read
-    @input = @default_value if @input.blank?
-    pre_validate(@input) && (@input.blank? || post_validate(@input = parse(@input)))
-  end
-
-
-  def pre_validate(input)
-    pre_validators = [
-      {
-        :validator => lambda { |input| @allow_blank || !input.blank? },
-        :message => "No input given"
-      },
-    ] + @pre_validators
-    validate(input, pre_validators)
-  end
-
-
-  def post_validate(input)
-    post_validators = [
-      {
-        :validator => lambda { |input| @valid_values.blank? || @valid_values.include?(input) },
-        :message => "Invalid input given. Valid values are #{@valid_values.join(', ')}"
-      }
-    ] + @post_validators + @validators
-    validate(input, post_validators)
-  end
-
-
-  def validate(input,validators)
-
-    validators.each do |validator|
-
-      validator_proc = if validator.is_a?(Proc)
-        validator
-      elsif validator.is_a?(Hash)
-        validator[:validator]
-      end
-
-      error_message = if validator.is_a?(Hash) && validator[:message]
-        validator[:message]
-      else
-        "Invalid input"
-      end
-
-      valid = if validator_proc.is_a?(Proc)
-        validator_proc.call(input)
-      elsif validator_proc.is_a?(String) || validator_proc.is_a?(Symbol)
-        input.send(validator_proc)
-      elsif validator_proc.blank?
-        true
-      else
-        false
-      end
-
-      if !valid
-        puts error_message
-        return false
-      end
-
-    end
-
-    true
-
-  end
-
-
-  def parse(input)
-
-    @parsers.each do |parser|
-      if parser.is_a?(Proc)
-        input = parser.call(input)
-      elsif parser.is_a?(String) || parser.is_a?(Symbol)
-        input = input.send(parser)
-      end
-    end
-
-    input
-
-  end
-
-end
-end