ensure_it 0.1.3 → 0.1.4

data/lib/ensure_it/ensure_symbol.rb

@@ -4,66 +4,73 @@ module EnsureIt
       default
     end
 
-    def ensure_symbol!(default: nil, **opts)
-      EnsureIt.raise_error(
-        :ensure_symbol!,
-        **EnsureIt.ensure_symbol_error_options(**opts)
-      )
+    def ensure_symbol!(**opts)
+      EnsureIt.raise_error(:ensure_symbol!,
+                           **EnsureIt.ensure_symbol_error(**opts))
     end
   end
 
   patch String do
-    def ensure_symbol(default: nil, values: nil, downcase: nil, **opts)
-      value = downcase == true ? self.downcase.to_sym : to_sym
-      if values.nil? || values.is_a?(Array) && values.include?(value)
-        value
-      else
-        default
+    def ensure_symbol(default: nil, **opts)
+      return to_sym if opts.empty?
+      catch :wrong do
+        return EnsureIt.ensure_symbol(to_sym, **opts)
       end
+      default
     end
 
-    def ensure_symbol!(default: nil, values: nil, downcase: nil, **opts)
-      value = downcase == true ? self.downcase.to_sym : to_sym
-      if values.nil? || values.is_a?(Array) && values.include?(value)
-        return value
+    def ensure_symbol!(**opts)
+      return to_sym if opts.empty?
+      catch :wrong do
+        return EnsureIt.ensure_symbol(to_sym, **opts)
       end
-      EnsureIt.raise_error(
-        :ensure_symbol!,
-        **EnsureIt.ensure_symbol_error_options(**opts)
-      )
+      EnsureIt.raise_error(:ensure_symbol!,
+                           **EnsureIt.ensure_symbol_error(**opts))
     end
   end
 
   patch Symbol do
-    def ensure_symbol(default: nil, values: nil, downcase: nil, **opts)
-      value = downcase == true ? self.to_s.downcase.to_sym : self
-      if values.nil? || values.is_a?(Array) && values.include?(value)
-        value
-      else
-        default
+    def ensure_symbol(default: nil, **opts)
+      return self if opts.empty?
+      catch :wrong do
+        return EnsureIt.ensure_symbol(self, **opts)
       end
+      default
     end
 
-    def ensure_symbol!(default: nil, values: nil, downcase: nil, **opts)
-      value = downcase == true ? self.to_s.downcase.to_sym : self
-      if values.nil? || values.is_a?(Array) && values.include?(value)
-        return value
+    def ensure_symbol!(default: nil, **opts)
+      return self if opts.empty?
+      catch :wrong do
+        return EnsureIt.ensure_symbol(self, **opts)
       end
-      EnsureIt.raise_error(
-        :ensure_symbol!,
-        **EnsureIt.ensure_symbol_error_options(**opts)
+      EnsureIt.raise_error(:ensure_symbol!,
+                           **EnsureIt.ensure_symbol_error(**opts))
+    end
+  end
+
+  def self.ensure_symbol(sym, values: nil, downcase: nil, name_of: nil, **opts)
+    if name_of.nil?
+      value = downcase == true ? sym.to_s.downcase.to_sym : sym
+    else
+      value = EnsureIt::StringUtils.ensure_name(
+        sym.to_s, downcase: downcase, name_of: name_of, **opts
       )
+      throw :wrong if value.nil?
+      value = value.to_sym
     end
+    throw :wrong if values.is_a?(Array) && !values.include?(value)
+    value
   end
 
-  def self.ensure_symbol_error_options(**opts)
-    unless opts.key?(opts[:message])
-      opts[:message] = '#{subject} should be' +
-        if opts[:values].is_a?(Array)
-          " one of #{opts[:values]}"
-        else
-          ' a Symbol or a String'
-        end
+  def self.ensure_symbol_error(**opts)
+    unless opts.key?(:message)
+      opts[:message] = '#{subject} should be a Symbol or a String'
+      if opts.key?(:name_of)
+        opts[:message] << " and should be a name of #{opts[:name_of]}"
+      end
+      if opts[:values].is_a?(Array)
+        opts[:message] << " and should contained in #{opts[:values]}"
+      end
     end
     opts
   end

data/lib/ensure_it/errors.rb

@@ -59,8 +59,8 @@ module EnsureIt
     end
   end
 
-  def self.raise_error(method_name, message: nil, error: Error, **opts)
-    error = Error unless error <= Exception
+  def self.raise_error(method_name, message: nil, error: nil, **opts)
+    error = EnsureIt.config.error_class if error.nil? || !(error <= Exception)
     error_msg = ErrorMessage.new(method_name, message, caller[1..-1])
     # save message in backtrace in variables to not call getter
     # methods of error_msg instance in raise call

data/lib/ensure_it/string_utils.rb

@@ -0,0 +1,61 @@
+module EnsureIt
+  module StringUtils
+    NAME_TYPES = %i(local instance_variable class_variable setter getter
+                    checker bang method class)
+    NAME_REGEXP = /\A
+      (?<class_access>@{1,2})?
+      (?<name>[a-z_][a-zA-Z_0-9]*)
+      (?<modifier>[?!=])?
+    \z/x
+    CLASS_NAME_REGEXP = /\A
+      [A-Z][a-zA-Z_0-9]*(?:::[A-Z][a-zA-Z_0-9]*)*
+    \z/x
+    CLASS_NAME_DOWNCASE_REGEXP = /\A
+      [a-z][a-zA-Z_0-9]*(?:\/[a-z][a-zA-Z_0-9]*)*
+    \z/x
+
+    using EnsureIt if ENSURE_IT_REFINED
+
+    def self.ensure_name(str, name_of: nil, **opts)
+      str = str.ensure_string!
+      name_of = name_of.ensure_symbol(
+        downcase: true,
+        values: NAME_TYPES,
+        default: NAME_TYPES[0]
+      )
+      if name_of == :class
+        m = CLASS_NAME_REGEXP.match(str)
+        if m.nil?
+          return nil if opts[:downcase] != true
+          m = CLASS_NAME_DOWNCASE_REGEXP.match(str)
+          return nil if m.nil?
+          str = str
+            .split('/')
+            .map { |x| x.split('_').map(&:capitalize).join }
+            .join('::')
+        end
+        if opts[:exist] == true
+          begin
+            Object.const_get(str)
+          rescue NameError
+            return nil
+          end
+        end
+        str
+      else
+        m = NAME_REGEXP.match(str)
+        return nil if m.nil?
+        case name_of
+        when :local, :getter then m[:name]
+        when :instance_variable then '@' + m[:name]
+        when :class_variable then '@@' + m[:name]
+        when :setter then m[:name] + '='
+        when :checker then m[:name] + '?'
+        when :bang then m[:name] + '!'
+        when :method then m[:name] + (m[:modifier] || '')
+        else m[:name]
+        end
+      end
+    end
+  end
+end

data/lib/ensure_it/version.rb

@@ -1,3 +1,3 @@
 module EnsureIt
-  VERSION = '0.1.3'
+  VERSION = '0.1.4'
 end

data/spec/lib/config_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe EnsureIt::Config do
-  describe '::errors' do
+  describe '.errors' do
     after { described_class.instance_variable_set(:@errors, nil) }
 
     it 'gives :smart by default' do
@@ -14,7 +14,7 @@ describe EnsureIt::Config do
     end
   end
 
-  describe '::errors=' do
+  describe '.errors=' do
     after { described_class.instance_variable_set(:@errors, nil) }
 
     it 'allows to change value' do
@@ -27,16 +27,45 @@ describe EnsureIt::Config do
       expect(described_class.errors).to eq :smart
     end
   end
+
+  describe '.error_class' do
+    after { described_class.instance_variable_set(:@error_class, nil) }
+
+    it 'gives EsnureIt::Error by default' do
+      expect(described_class.error_class).to eq EnsureIt::Error
+    end
+
+    it 'calls setter if value given' do
+      expect(described_class).to receive(:error_class=).with(ArgumentError)
+      described_class.error_class ArgumentError
+    end
+  end
+
+  describe '.error_class=' do
+    after { described_class.instance_variable_set(:@error_class, nil) }
+
+    it 'allows to change value' do
+      described_class.error_class = ArgumentError
+      expect(described_class.error_class).to eq ArgumentError
+    end
+
+    it "doesn't change value to wrong classes" do
+      described_class.error_class = ArgumentError
+      described_class.error_class = Object
+      expect(described_class.error_class).to eq ArgumentError
+    end
+  end
+
 end
 
 describe EnsureIt do
-  describe '::config' do
+  describe '.config' do
     it 'returns Config module' do
       expect(described_class.config).to eq EnsureIt::Config
     end
   end
 
-  describe '::configure' do
+  describe '.configure' do
     it 'returns Config module' do
       expect(described_class.config).to eq EnsureIt::Config
     end

data/spec/lib/ensure_array_spec.rb

@@ -19,29 +19,27 @@ describe EnsureIt do
       expect(call_for(obj)).to eq obj
     end
 
-    it 'compacts array with compact option' do
-      expect(call_for([1, nil, 2], compact: true)).to eq [1, 2]
+    it 'compacts array with compact argument' do
+      expect(call_for([1, nil, 2], :compact)).to eq [1, 2]
     end
 
-    it 'flattens array with flatten option' do
-      expect(call_for([1, [2, 3], 4], flatten: true)).to eq [1, 2, 3, 4]
+    it 'flattens array with flatten argument' do
+      expect(call_for([1, [2, 3], 4], :flatten)).to eq [1, 2, 3, 4]
     end
 
-    [:sorted, :ordered].each do |o|
-      it "flattens and then sorts array with flatten and #{o} options" do
-        expect(
-          call_for([1, [5, 6], 4], flatten: true, o => true)
-        ).to eq [1, 4, 5, 6]
-      end
+    it 'flattens and then sorts array with flatten and sort arguments' do
+      expect(
+        call_for([1, [5, 6], 4], :flatten, :sort)
+      ).to eq [1, 4, 5, 6]
+    end
 
-      it "sorts descending with #{o}: :desc option" do
-        expect(call_for([1, 5, 6, 4], o => :desc)).to eq [6, 5, 4, 1]
-      end
+    it 'sorts descending with sort_desc argument' do
+      expect(call_for([1, 5, 6, 4], :sort_desc)).to eq [6, 5, 4, 1]
     end
 
     it 'calls :ensure_* for each element' do
       arr = ['s', nil, :v]
-      expect(call_for(arr, :ensure_symbol, compact: true)).to eq [:s, :v]
+      expect(call_for(arr, :ensure_symbol, :compact)).to eq [:s, :v]
     end
 
     it 'calls standard method for each element' do
@@ -53,6 +51,12 @@ describe EnsureIt do
       arr = ['s', :v]
       expect(call_for(arr, :ensure_string, :to_sym)).to eq [:s, :v]
     end
+
+    it 'selects only values, specified in values option' do
+      expect(
+        call_for([1, 5, 6, 4], values: [1, 6, 8])
+      ).to eq [1, 6]
+    end
   end
 
   describe '#ensure_array' do

data/spec/lib/ensure_class_spec.rb

@@ -21,6 +21,10 @@ describe EnsureIt do
     it 'and checks for ancestors' do
       expect(call_for(Array, Enumerable, Array)).to eq Array
     end
+
+    it 'and converts string to class with string option' do
+      expect(call_for('Array', string: true)).to eq Array
+    end
   end
 
   describe '#ensure_class' do

data/spec/lib/ensure_string_spec.rb

@@ -33,6 +33,13 @@ describe EnsureIt do
       expect(call_for(:teST, downcase: true)).to eq 'test'
       expect(call_for('teST', downcase: true)).to eq 'test'
     end
+
+    it 'and calls ensure_name with name_of option' do
+      expect(EnsureIt::StringUtils).to receive(:ensure_name).with(
+        'test', name_of: :setter, downcase: nil
+      ).and_call_original
+      expect(call_for('test', name_of: :setter)).to eq 'test='
+    end
   end
 
   describe '#ensure_string' do
@@ -53,7 +60,7 @@ describe EnsureIt do
     it 'raises correct error message with :numbers option' do
       expect { call_for(nil, numbers: true) }.to raise_error(
         EnsureIt::Error,
-        /should be a String, Symbol, Numeric or Rational/
+        /should be a String or a Symbol or a Numeric/
       )
     end
   end

data/spec/lib/ensure_symbol_spec.rb

@@ -31,6 +31,13 @@ describe EnsureIt do
       expect(call_for(:teST, downcase: true)).to eq :test
       expect(call_for('teST', downcase: true)).to eq :test
     end
+
+    it 'and calls ensure_name with name_of option' do
+      expect(EnsureIt::StringUtils).to receive(:ensure_name).with(
+        'test', name_of: :setter, downcase: nil
+      ).and_call_original
+      expect(call_for(:test, name_of: :setter)).to eq :test=
+    end
   end
 
   describe '#ensure_symbol' do

data/spec/lib/errors_spec.rb

@@ -10,11 +10,14 @@ end
 describe EnsureIt do
   before do
     @errors = EnsureIt.config.errors
+    @error_class = EnsureIt.config.error_class
     EnsureIt::Config.instance_variable_set(:@errors, nil)
+    EnsureIt::Config.instance_variable_set(:@error_class, nil)
   end
 
   after do
     EnsureIt::Config.instance_variable_set(:@errors, @errors)
+    EnsureIt::Config.instance_variable_set(:@error_class, @error_class)
   end
 
   describe '.raise_error' do
@@ -30,6 +33,13 @@ describe EnsureIt do
       }.to raise_error ArgumentError, 'test'
     end
 
+    it 'raises error of class, specified with error_class=' do
+      EnsureIt.configure { |c| c.error_class = ArgumentError }
+      expect {
+        call_error(:test_method)
+      }.to raise_error ArgumentError
+    end
+
     it 'raises error with callers backtrace' do
       backtrace = nil
       begin

data/spec/lib/string_utils_spec.rb

@@ -0,0 +1,164 @@
+require 'spec_helper'
+
+describe EnsureIt::StringUtils do
+  describe '.ensure_name' do
+    NAMES = %w(local @inst_var @@class_var setter= getter checker?
+               bang! Object)
+
+    if ENSURE_IT_REFINED != true
+      it 'checks str argument' do
+        str = 'str'
+        expect(str).to receive(:ensure_string!).and_call_original
+        described_class.ensure_name(str)
+      end
+
+      it 'checks name_of option' do
+        str = 'str'
+        expect(str).to receive(:ensure_symbol).with(
+          downcase: true,
+          values: EnsureIt::StringUtils::NAME_TYPES,
+          default: EnsureIt::StringUtils::NAME_TYPES[0]
+        ).and_call_original
+        described_class.ensure_name('str', name_of: str)
+      end
+    end
+
+    describe 'name_of: :class' do
+      it 'rejects non-class-name strings' do
+        expect(
+          described_class.ensure_name('just text', name_of: :class)
+        ).to be_nil
+        expect(
+          described_class.ensure_name('just_text', name_of: :class)
+        ).to be_nil
+      end
+
+      it 'accpets class-name strings' do
+        expect(
+          described_class.ensure_name('Namespace::SomeClass', name_of: :class)
+        ).to eq 'Namespace::SomeClass'
+      end
+
+      it 'accpets low-cased class-name strings with downcase option' do
+        expect(
+          described_class.ensure_name(
+            'low/cased_class', name_of: :class, downcase: true
+          )
+        ).to eq 'Low::CasedClass'
+      end
+
+      it 'rejects non-existent class names with exist option' do
+        expect(Object.const_defined?(:UnknownClass)).to be_false
+        expect(
+          described_class.ensure_name(
+            'UnknownClass', name_of: :class, exist: true
+          )
+        ).to be_nil
+        expect(
+          described_class.ensure_name(
+            'unknown_class', name_of: :class, exist: true, downcase: true
+          )
+        ).to be_nil
+      end
+
+      it 'accepts exists classes with exist option' do
+        expect(
+          described_class.ensure_name('Object', name_of: :class, exist: true)
+        ).to eq 'Object'
+        expect(
+          described_class.ensure_name(
+            'object', name_of: :class, exist: true, downcase: true
+          )
+        ).to eq 'Object'
+      end
+    end
+
+    describe 'name_of: :local' do
+      it 'converts names to local variable name' do
+        expect(NAMES.map { |x|
+          described_class.ensure_name(x, name_of: :local)
+        }).to match_array(
+          %w(local inst_var class_var setter getter checker
+             bang) + [nil]
+        )
+      end
+    end
+
+    describe 'name_of: :instance_variable' do
+      it 'converts names to instance variable name' do
+        expect(NAMES.map { |x|
+          described_class.ensure_name(x, name_of: :instance_variable)
+        }).to match_array(
+          %w(@local @inst_var @class_var @setter @getter @checker
+             @bang) + [nil]
+        )
+      end
+    end
+
+    describe 'name_of: :class_variable' do
+      it 'converts names to class variable name' do
+        expect(NAMES.map { |x|
+          described_class.ensure_name(x, name_of: :class_variable)
+        }).to match_array(
+          %w(@@local @@inst_var @@class_var @@setter @@getter @@checker
+             @@bang) + [nil]
+        )
+      end
+    end
+
+    describe 'name_of: :setter' do
+      it 'converts names to setter method name' do
+        expect(NAMES.map { |x|
+          described_class.ensure_name(x, name_of: :setter)
+        }).to match_array(
+          %w(local= inst_var= class_var= setter= getter= checker=
+             bang=) + [nil]
+        )
+      end
+    end
+
+    describe 'name_of: :getter' do
+      it 'converts names to getter method name' do
+        expect(NAMES.map { |x|
+          described_class.ensure_name(x, name_of: :getter)
+        }).to match_array(
+          %w(local inst_var class_var setter getter checker
+             bang) + [nil]
+        )
+      end
+    end
+
+    describe 'name_of: :checker' do
+      it 'converts names to checker method name' do
+        expect(NAMES.map { |x|
+          described_class.ensure_name(x, name_of: :checker)
+        }).to match_array(
+          %w(local? inst_var? class_var? setter? getter? checker?
+             bang?) + [nil]
+        )
+      end
+    end
+
+    describe 'name_of: :bang' do
+      it 'converts names to bang method name' do
+        expect(NAMES.map { |x|
+          described_class.ensure_name(x, name_of: :bang)
+        }).to match_array(
+          %w(local! inst_var! class_var! setter! getter! checker!
+             bang!) + [nil]
+        )
+      end
+    end
+
+    describe 'name_of: :method' do
+      it 'converts names to method name' do
+        expect(NAMES.map { |x|
+          described_class.ensure_name(x, name_of: :method)
+        }).to match_array(
+          %w(local inst_var class_var setter= getter checker?
+             bang!) + [nil]
+        )
+      end
+    end
+  end
+end