cli_miami 0.0.9 → 1.0.1.pre

data/lib/cli_miami/validation.rb

@@ -0,0 +1,189 @@
+#
+# validates user input values against their expected type
+#
+class CliMiami::Validation
+  attr_reader :error, :valid, :value
+
+  # validates string provided by the user
+  #
+  # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+  def initialize initial_value, options
+    @options = CliMiami.get_options options
+    @value = initial_value
+    @valid = true
+    @error = nil
+
+    # convert
+    # only attempt to convert strings
+    # if not a string, skip conversion and go straight to validation
+    if initial_value.is_a? String
+      begin
+        @value = send("convert_string_to_#{options[:type]}", initial_value, @options)
+      rescue
+        @error = CliMiami::Error.new(initial_value, @options, :convert).message
+        @valid = false
+      end
+    end
+
+    return if @value.nil? || !@valid
+
+    # validate
+    begin
+      # keep all values the same unless validation fails
+      send "validate_#{options[:type]}", @value, @options
+    rescue => error
+      # if validation fails, set values, including error to the specific validation error
+      @error = error.to_s
+      @valid = false
+    end
+  end
+  # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+  def valid?
+    @valid
+  end
+
+private
+
+  #
+  # TYPE CONVERSIONS
+  # all type conversions must raise an exception if they fail
+  #
+  def convert_string_to_boolean string, _options
+    return true if CliMiami::BOOLEAN_TRUE_VALUES.include? string.downcase
+    return false if CliMiami::BOOLEAN_FALSE_VALUES.include? string.downcase
+    raise
+  end
+
+  def convert_string_to_file string, _options
+    return string if string.empty?
+    File.absolute_path(File.expand_path(string))
+  end
+
+  # the `Integer` class fails when passed a float, so we convert to a float and back to an integer
+  # this allows users to enter a float when an integer is requested without it failing
+  #
+  def convert_string_to_fixnum string, _options
+    Integer Float(string).to_i
+  end
+
+  def convert_string_to_float string, _options
+    Float string
+  end
+
+  def convert_string_to_range string, _options
+    range_array = string.split('..').map { |i| Float(i) }.sort
+
+    # check that array has 2 supported range values
+    return Range.new(range_array[0], range_array[1]) if range_array.length == 2
+    raise
+  end
+
+  # pass-through method for converting a string to a string
+  def convert_string_to_string string, _options
+    string
+  end
+
+  def convert_string_to_symbol string, _options
+    raw_symbol = string.underscore.to_sym
+
+    # if the symbol is quoted, remove some characters and try converting again
+    if raw_symbol.inspect =~ /\:\"/
+      # convert non a-z to underscores, then remove duplicate or leading/trailing underscores
+      converted_symbol = raw_symbol.to_s.gsub(/[^a-z]/, '_').gsub(/\_+/, '_').gsub(/^_/, '').gsub(/_$/, '').to_sym
+
+      # if symbol was converted, return it, otherwise raise an error
+      return converted_symbol unless converted_symbol.empty?
+      raise
+    end
+
+    raw_symbol
+  end
+
+  #
+  # TYPE VALIDATORS
+  # all type validators must raise an exception if they fail
+  #
+
+  # validate the value is within the min and max values
+  #
+  def validate_length value, length, options
+    unless (options[:min]..options[:max]).cover? length
+      options[:value_length] = length
+
+      # replace empty values with i18n `empty` string
+      value = I18n.t('cli_miami.core.empty') if value.respond_to?(:empty?) && value.empty?
+
+      raise CliMiami::Error.new(value, options, :length).message
+    end
+  end
+
+  # validate that the value passes a regular expression
+  #
+  def validate_regexp value, options
+    unless value =~ options[:regexp]
+      raise CliMiami::Error.new(value, options, :regexp).message
+    end
+  end
+
+  def validate_array array, options
+    validate_length array, array.length, options
+  end
+
+  # no validation needed for boolean types
+  # type conversion is all the validation required
+  def validate_boolean boolean, options
+  end
+
+  def validate_file file, options
+    raise if file.empty?
+    File.new File.expand_path file
+  rescue
+    raise CliMiami::Error.new(file, options, :validate).message
+  end
+
+  def validate_fixnum fixnum, options
+    validate_length fixnum, fixnum, options
+  end
+
+  def validate_float float, options
+    validate_length float, float, options
+  end
+
+  # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+  def validate_hash hash, options
+    hash.deep_symbolize_keys!
+
+    validate_length hash, hash.keys.length, options
+
+    # return if no value options are set
+    value_options = options[:value_options]
+    return unless value_options
+
+    # validate required keys are set
+    if value_options[:keys]
+      missing_keys = Set.new(value_options[:keys].map(&:to_sym)) - Set.new(hash.keys)
+      value_options[:missing_values] = missing_keys.to_a.to_sentence
+
+      unless missing_keys.empty?
+        raise CliMiami::Error.new(hash, options, :keys).message
+      end
+    end
+  end
+  # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+  def validate_range range, options
+    range_diff = (range.max - range.min) + 1
+    validate_length range, range_diff, options
+  end
+
+  def validate_string string, options
+    validate_length string, string.length, options
+    validate_regexp string, options
+  end
+
+  def validate_symbol symbol, options
+    validate_length symbol, symbol.to_s.length, options
+    validate_regexp symbol, options
+  end
+end

data/lib/cli_miami.rb

@@ -7,6 +7,6 @@
 # the core initilization runs from `namespaced.rb`
 require 'namespaced'
 
-# create alias classes to support `A.sk` and `S.ay`
+# create alias classes to support `A.sk` and `S.ay` syntax
 A = CliMiami::A
 S = CliMiami::S

data/lib/namespaced.rb

@@ -1,30 +1,80 @@
-# This is the primary initializer
-
+# root namespace class
+#
 class CliMiami
+  # require & include core first
+  require 'cli_miami/core'
+  include CliMiami::Core
+
+  # CliMiami library
+  require 'cli_miami/error'
+  require 'cli_miami/validation'
   require 'cli_miami/ask'
   require 'cli_miami/say'
 
-  # default presets
-  @@presets = {
-    :fail => {
-      :color => :red
-    },
-    :warn => {
-      :color => :yellow
-    },
-    :success => {
-      :color => :green
-    }
-  }
-
-  # Returns all presets
-  def self.presets
-    @@presets
-  end
-
   # Create a new custom preset
   def self.set_preset type, options
-    raise 'Preset must be a hash of options' unless options.is_a? Hash
+    raise ArgumentError, 'Preset must be a hash of options' unless options.is_a? Hash
     @@presets[type] = options
   end
+
+  # build an options hash from preset options and/or additional options
+  #
+  # build shared validation hash object
+  #
+  # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+  def self.get_options user_options = {}
+    # lookup preset if passed in as a symbol, or as a :preset key in an options hash
+    if user_options.is_a? Hash
+      user_options.deep_symbolize_keys!
+      options = @@presets[user_options.delete(:preset)] || {}
+      options.deep_merge! user_options
+    else
+      options = @@presets[user_options.to_sym] || {}
+    end
+
+    # make sure all keys are symbols
+    options.deep_symbolize_keys!
+
+    # set defaults
+    options.reverse_merge!(
+      description: I18n.t('cli_miami.core.no_description'),
+      max: Float::INFINITY,
+      min: options.delete(:required) ? 1 : 0,
+      newline: true,
+      justify: :left,
+      padding: 0,
+      regexp: //,
+      style: [],
+      type: :string
+    )
+
+    # prepare style array
+    options[:style] = [options[:style]].flatten
+
+    # lookup type in type map
+    options[:type] = TYPE_MAP[options[:type].to_sym] || :string
+
+    # convert range to min/max values
+    range = options.delete(:range)
+    if range
+      options[:min] = range.min
+      options[:max] = range.max
+    end
+
+    # convert length to min/max values
+    length = options.delete(:length)
+    if length
+      options[:min] = options[:max] = length
+    end
+
+    # if value options are set, apply the same treatment to them
+    value_options = options[:value_options]
+    if value_options
+      options[:value_options] = get_options value_options
+      options[:value_options][:description] = options[:description]
+    end
+
+    options
+  end
+  # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 end

data/spec/fixtures/i18n.yml

@@ -0,0 +1,36 @@
+en:
+  cli_miami:
+    errors:
+      spec: generic error
+
+      type:
+        spec: "type: %{value} - %{allowed_values}"
+        nested:
+          spec: nested spec
+
+      array:
+        spec: "array: %{value} - %{allowed_values}"
+
+      boolean:
+        spec: "boolean: %{value} - %{allowed_values}"
+
+      file:
+        spec: "file: %{value} - %{allowed_values}"
+
+      fixnum:
+        spec: "fixnum: %{value} - %{allowed_values}"
+
+      float:
+        spec: "float: %{value} - %{allowed_values}"
+
+      hash:
+        spec: "hash: %{value} - %{allowed_values}"
+
+      range:
+        spec: "range: %{value} - %{allowed_values}"
+
+      string:
+        spec: "string: %{value} - %{allowed_values}"
+
+      symbol:
+        spec: "symbol: %{value} - %{allowed_values}"

data/spec/lib/cli_miami/ask_spec.rb

@@ -0,0 +1,134 @@
+describe CliMiami::A do
+  before do
+    @q = 'Who am i?'
+    allow(CliMiami::S).to receive(:ay).and_call_original
+    allow_any_instance_of(CliMiami::A).to receive(:request_string).and_return 'Jane Doe'
+  end
+
+  after do
+    allow_any_instance_of(CliMiami::A).to receive(:request_string).and_call_original
+  end
+
+  describe '.sk' do
+    context 'when passed a block' do
+      it 'should yield a response' do
+        CliMiami::A.sk @q do |response|
+          expect(response).to eq 'Jane Doe'
+        end
+      end
+    end
+
+    context 'when not passed a block' do
+      it 'should return a response' do
+        expect(CliMiami::A.sk(@q).value).to eq 'Jane Doe'
+      end
+    end
+  end
+
+  #
+  # COMPLEX REQUEST TYPES
+  #
+  describe 'ARRAY' do
+    it 'should allow user to enter values until they enter an empty string' do
+      allow($stdin).to receive(:gets).and_return 'foo', 'bar', ''
+      ask = CliMiami::A.sk @q, type: :array
+      expect(ask.value).to eq %w(foo bar)
+    end
+
+    it 'should prevent user from entering less than the minimum' do
+      allow($stdin).to receive(:gets).and_return 'foo', '', 'bar', ''
+      ask = CliMiami::A.sk @q, type: :array, min: 2
+      expect(ask.value).to eq %w(foo bar)
+    end
+
+    it 'should stop prompting user when the maximum is reached' do
+      allow($stdin).to receive(:gets).and_return 'foo', 'bar'
+      ask = CliMiami::A.sk @q, type: :array, max: 2
+      expect(ask.value).to eq %w(foo bar)
+    end
+  end
+
+  describe 'HASH' do
+    it 'should allow user to enter keys & values until they enter an empty key string' do
+      allow($stdin).to receive(:gets).and_return 'foo1', '1', 'bar1', '2', ''
+      ask = CliMiami::A.sk @q, type: :hash
+      expect(ask.value).to eq(foo1: '1', bar1: '2')
+    end
+
+    it 'should prevent user from entering less than the minimum' do
+      allow($stdin).to receive(:gets).and_return 'foo2', '1', '', 'bar2', '2', ''
+      ask = CliMiami::A.sk @q, type: :hash, min: 2
+      expect(ask.value).to eq(foo2: '1', bar2: '2')
+    end
+
+    it 'should stop prompting user when the maximum is reached' do
+      allow($stdin).to receive(:gets).and_return 'foo3', '1'
+      ask = CliMiami::A.sk @q, type: :hash, max: 1
+      expect(ask.value).to eq(foo3: '1')
+    end
+
+    context 'when keys options is set' do
+      it 'should prompt for keys first, then user-defined keys' do
+        allow($stdin).to receive(:gets).and_return '1', 'bar4', '2', ''
+        ask = CliMiami::A.sk @q, type: :hash, keys: [:foo4]
+        expect(ask.value).to eq(foo4: '1', bar4: '2')
+      end
+    end
+  end
+
+  describe 'RANGE' do
+    it 'should allow user to enter floats or integers for start and end values' do
+      allow($stdin).to receive(:gets).and_return '1.1', '3'
+      ask = CliMiami::A.sk @q, type: :range
+      expect(ask.value).to eq((1.1..3.0))
+    end
+
+    it 'should prevent user from entering non-numeric values' do
+      allow($stdin).to receive(:gets).and_return 'foo', '1', 'bar', '3'
+      ask = CliMiami::A.sk @q, type: :range
+      expect(ask.value).to eq((1.0..3.0))
+    end
+
+    it 'should re-prompt user if range is invalid' do
+      allow($stdin).to receive(:gets).and_return '1', '3', '1', '4'
+      ask = CliMiami::A.sk @q, type: :range, min: 4
+      expect(ask.value).to eq((1.0..4.0))
+    end
+  end
+
+  #
+  # SIMPLE REQUEST TYPES
+  #
+  context 'with simple types' do
+    shared_examples 'when prompting the user' do |type, invalid_string, valid_string, value|
+      it 'should prompt until a valid value is entered' do
+        allow($stdin).to receive(:gets).and_return(invalid_string, valid_string)
+        allow(Readline).to receive(:readline).and_return(invalid_string, valid_string)
+        ask = CliMiami::A.sk type.to_s, type: type
+        expect(ask.value).to eq value
+      end
+    end
+
+    describe 'BOOLEAN' do
+      it_behaves_like 'when prompting the user', :boolean, 'foo', 'TrUe', true
+    end
+
+    describe 'FILE' do
+      it_behaves_like 'when prompting the user', :file, 'foo', '.', Dir.pwd
+    end
+
+    describe 'FLOAT' do
+      it_behaves_like 'when prompting the user', :float, 'foo', '2.0', 2.0
+      it_behaves_like 'when prompting the user', :float, 'foo', '3', 3
+    end
+
+    describe 'FIXNUM' do
+      it_behaves_like 'when prompting the user', :fixnum, 'foo', '2', 2
+      it_behaves_like 'when prompting the user', :fixnum, 'foo', '3.8', 3
+    end
+
+    describe 'SYMBOL' do
+      it_behaves_like 'when prompting the user', :symbol, '$', '$f_ 0o8<0o', :f_o_o
+    end
+  end
+end

data/spec/lib/cli_miami/error_spec.rb

@@ -0,0 +1,75 @@
+describe CliMiami::Error do
+  describe '.initialize' do
+    context 'with valid type error' do
+      CliMiami::TYPE_MAP.values.uniq.each do |type|
+        case type
+
+        when :array
+          value_type = [1, nil, :foo, '', (1..2)]
+          value_string = '1, [EMPTY], foo, [EMPTY], and 1-2'
+          allowed_values = '1-38'
+
+        when :boolean
+          value_type = true
+          value_string = 'true'
+          allowed_values = (CliMiami::BOOLEAN_TRUE_VALUES + CliMiami::BOOLEAN_FALSE_VALUES).to_sentence
+
+        when :file
+          value_type = File.new('.')
+          value_string = File.expand_path('.')
+          allowed_values = '?'
+
+        when :fixnum
+          value_type = 6
+          value_string = '6'
+          allowed_values = '1-38'
+
+        when :float
+          value_type = 6.66
+          value_string = '6.66'
+          allowed_values = '1-38'
+
+        when :hash
+          value_type = { foo: 1, bar: 2 }
+          value_string = 'foo: 1 and bar: 2'
+          allowed_values = '1-38'
+
+        when :range
+          value_type = (4..20)
+          value_string = '4-20'
+          allowed_values = '1-38'
+
+        when :string
+          value_type = 'foo'
+          value_string = 'foo'
+          allowed_values = '1-38'
+
+        when :symbol
+          value_type = :foo
+          value_string = 'foo'
+          allowed_values = '1-38'
+        end
+
+        it "should convert #{type} to string" do
+          expect(CliMiami::Error.new(value_type, { type: type, min: 1, max: 38, regexp: /6{3}/ }, :spec).message).to eq "#{type}: #{value_string} - #{allowed_values}"
+        end
+      end
+
+      it 'should support multiple/nested keys' do
+        expect(CliMiami::Error.new('foo', { type: :type }, :nested, :spec).message).to eq 'nested spec'
+      end
+    end
+
+    context 'with invalid type error' do
+      it 'should have a generic error' do
+        expect(CliMiami::Error.new('foo', { type: :foo }, :spec).message).to eq 'generic error'
+      end
+    end
+
+    context 'when no error is found' do
+      it 'should have an unknown error' do
+        expect(CliMiami::Error.new('foo', { type: :foo }, :bar).message).to eq 'Unknown Error'
+      end
+    end
+  end
+end

data/spec/lib/cli_miami/say_spec.rb

@@ -0,0 +1,87 @@
+describe CliMiami::S do
+  subject { CliMiami::S }
+
+  describe '.ay' do
+    it 'should not accept no arguments' do
+      expect { subject.ay 'no arguments' }.to_not raise_error
+    end
+
+    context 'with options' do
+      it 'should accept color' do
+        expect($stdout).to receive(:puts).with "\e[31mcolor\e[0m"
+        subject.ay 'color', color: :red
+      end
+
+      it 'should accept bgcolor' do
+        expect($stdout).to receive(:puts).with "\e[41mbgcolor\e[0m"
+        subject.ay 'bgcolor', bgcolor: :red
+      end
+
+      it 'should accept justify / padding' do
+        expect($stdout).to receive(:puts).with(/^\s{1}justify\s{2}$/)
+        subject.ay 'justify', justify: :center, padding: 10
+      end
+
+      it 'should accept indent' do
+        expect($stdout).to receive(:puts).with(/^\s{10}indent$/)
+        subject.ay 'indent', indent: 10
+      end
+
+      it 'should accept newline' do
+        # when true, use puts
+        expect($stdout).to receive(:puts).with 'newline'
+        subject.ay 'newline', newline: true
+
+        # when false, use print
+        expect($stdout).to receive(:print).with 'newline '
+        subject.ay 'newline', newline: false
+      end
+
+      it 'should accept overwrite' do
+        expect($stdout).to receive(:print).with "overwrite\r "
+        subject.ay 'overwrite', overwrite: true
+      end
+
+      context 'with style' do
+        it 'should accept style' do
+          expect($stdout).to receive(:puts).with "\e[4mstyle\e[0m"
+          subject.ay 'style', style: :underline
+        end
+
+        it 'should apply bright style to color' do
+          expect($stdout).to receive(:puts).with "\e[91mbright\e[0m"
+          subject.ay 'bright', color: :red, style: :bright
+        end
+
+        it 'should accept multiple styles' do
+          expect($stdout).to receive(:puts).with "\e[4m\e[1m\e[91mmultiple\e[0m\e[0m\e[0m"
+          subject.ay 'multiple', color: :red, style: [:bright, :bold, :underline]
+        end
+      end
+    end
+
+    context 'with preset' do
+      before do
+        CliMiami.set_preset :preset_symbol,
+          color: :blue,
+          bgcolor: :white,
+          style: :underline
+      end
+
+      it 'should apply preset as symbol' do
+        expect($stdout).to receive(:puts).with "\e[4m\e[47m\e[34mpreset\e[0m\e[0m\e[0m"
+        subject.ay 'preset', :preset_symbol
+      end
+
+      it 'should apply preset as option' do
+        expect($stdout).to receive(:puts).with "\e[4m\e[47m\e[34mpreset\e[0m\e[0m\e[0m"
+        subject.ay 'preset', preset: :preset_symbol
+      end
+
+      it 'should override presets with additional options' do
+        expect($stdout).to receive(:puts).with "\e[4m\e[47m\e[31mpreset\e[0m\e[0m\e[0m"
+        subject.ay 'preset', preset: :preset_symbol, color: :red
+      end
+    end
+  end
+end

data/spec/lib/cli_miami/validation_spec.rb

@@ -0,0 +1,52 @@
+describe CliMiami::Validation do
+  describe '.initialize' do
+    shared_examples 'a valid type' do |type, valid_string, value|
+      it "and should return a #{type}" do
+        validation = CliMiami::Validation.new valid_string, type: type
+        expect(validation.value).to eq value
+        expect(validation.valid?).to eq true
+      end
+    end
+
+    shared_examples 'an invalid type' do |type, invalid_string|
+      it 'and should set the error field' do
+        validation = CliMiami::Validation.new invalid_string, type: type
+        expect(validation.value).to eq invalid_string
+        expect(validation.valid?).to eq false
+        expect(validation.error).to_not be_empty
+      end
+    end
+
+    describe 'BOOLEAN' do
+      it_behaves_like 'a valid type', :boolean, 'TrUe', true
+      it_behaves_like 'an invalid type', :boolean, 'foo'
+    end
+
+    describe 'FILE' do
+      it_behaves_like 'a valid type', :file, '.', Dir.pwd
+      it_behaves_like 'an invalid type', :file, File.join(Dir.pwd, 'foo')
+    end
+
+    describe 'FLOAT' do
+      it_behaves_like 'a valid type', :float, '2.0', 2.0
+      it_behaves_like 'a valid type', :float, '3', 3.0
+      it_behaves_like 'an invalid type', :float, 'foo'
+    end
+
+    describe 'FIXNUM' do
+      it_behaves_like 'a valid type', :fixnum, '3', 3
+      it_behaves_like 'a valid type', :fixnum, '3.8', 3
+      it_behaves_like 'an invalid type', :fixnum, 'foo'
+    end
+
+    describe 'RANGE' do
+      it_behaves_like 'a valid type', :range, '2..4', (2..4)
+      it_behaves_like 'an invalid type', :range, 'foo'
+    end
+
+    describe 'SYMBOL' do
+      it_behaves_like 'a valid type', :symbol, '$F 8o*: .o.!', :f_o_o
+      it_behaves_like 'an invalid type', :symbol, '$'
+    end
+  end
+end