ensure_it 0.1.1 → 0.1.2

data/lib/ensure_it/ensure_integer.rb

@@ -5,85 +5,156 @@ module EnsureIt
   BIN_REGEXP = /\A0b[01]+\z/
 
   patch Object do
-    def ensure_integer(**opts)
-      opts.key?(:wrong) ? opts[:wrong] : nil
+    def ensure_integer(default: nil, **opts)
+      default
     end
 
-    def ensure_integer!(**opts)
-      opts[:message] ||= '#{subject} should be an integer or be able' \
-                         ' to convert to it'
-      EnsureIt.raise_error(:ensure_integer!, **opts)
+    def ensure_integer!(default: nil, **opts)
+      EnsureIt.raise_error(
+        :ensure_integer!,
+        **EnsureIt::ensure_integer_error_options(**opts)
+      )
     end
   end
 
   patch String do
-    using EnsureIt if ENSURE_IT_REFINES
-
-    def ensure_integer(**opts)
-      case self
+    def ensure_integer(default: nil, values: nil, **opts)
+      value = case self
       when OCT_REGEXP then opts[:octal] == true ? self.to_i(8) : self.to_i
       when INT_REGEXP then self.to_i
       when HEX_REGEXP then self[2..-1].to_i(16)
       when BIN_REGEXP then self[2..-1].to_i(2)
-      else nil
+      else return default
+      end
+      if values.nil? || values.is_a?(Array) || values.include?(self)
+        value
+      else
+        default
       end
     end
 
-    def ensure_integer!(**opts)
-      ensure_integer(**opts) || super(**opts)
+    def ensure_integer!(default: nil, values: nil, **opts)
+      value = case self
+      when OCT_REGEXP then opts[:octal] == true ? self.to_i(8) : self.to_i
+      when INT_REGEXP then self.to_i
+      when HEX_REGEXP then self[2..-1].to_i(16)
+      when BIN_REGEXP then self[2..-1].to_i(2)
+      else
+        EnsureIt.raise_error(
+          :ensure_integer!,
+          **EnsureIt::ensure_integer_error_options(**opts)
+        )
+      end
+      if values.nil? || values.is_a?(Array) || values.include?(self)
+        return value
+      end
+      EnsureIt.raise_error(
+        :ensure_integer!,
+        **EnsureIt::ensure_integer_error_options(**opts)
+      )
     end
   end
 
   patch Integer do
-    def ensure_integer(**opts)
-      self
+    def ensure_integer(default: nil, values: nil, **opts)
+      if values.nil? || values.is_a?(Array) && values.include?(self)
+        self
+      else
+        default
+      end
+    end
+
+    def ensure_integer!(default: nil, values: nil, **opts)
+      if values.nil? || values.is_a?(Array) && values.include?(self)
+        return self
+      end
+      EnsureIt.raise_error(
+        :ensure_integer!,
+        **EnsureIt::ensure_integer_error_options(**opts)
+      )
     end
-    alias_method :ensure_integer!, :ensure_integer
   end
 
   patch Float do
-    def ensure_integer(**opts)
-      round
+    def ensure_integer(default: nil, values: nil, **opts)
+      return round if values.nil?
+      value = round
+      values.is_a?(Array) && values.include?(value) ? value : default
+    end
+
+    def ensure_integer!(default: nil, values: nil, **opts)
+      return round if values.nil?
+      value = round
+      return value if values.is_a?(Array) && values.include?(value)
+      EnsureIt.raise_error(
+        :ensure_integer!,
+        **EnsureIt::ensure_integer_error_options(**opts)
+      )
     end
-    alias_method :ensure_integer!, :ensure_integer
   end
 
   patch Rational do
-    def ensure_integer(**opts)
-      round
+    def ensure_integer(default: nil, values: nil, **opts)
+      return round if values.nil?
+      value = round
+      values.is_a?(Array) && values.include?(value) ? value : default
+    end
+
+    def ensure_integer!(default: nil, values: nil, **opts)
+      return round if values.nil?
+      value = round
+      return value if values.is_a?(Array) && values.include?(value)
+      EnsureIt.raise_error(
+        :ensure_integer!,
+        **EnsureIt::ensure_integer_error_options(**opts)
+      )
     end
-    alias_method :ensure_integer!, :ensure_integer
   end
 
   patch TrueClass do
-    using EnsureIt if ENSURE_IT_REFINES
-
-    def ensure_integer(**opts)
-      if opts[:boolean] == true || opts[:boolean].is_a?(Integer)
-        opts[:boolean] == true ? 1 : opts[:boolean]
+    def ensure_integer(default: nil, values: nil, boolean: nil, **opts)
+      if boolean == true || boolean.is_a?(Integer)
+        value = boolean == true ? 1 : boolean
+        values.is_a?(Array) && !values.include?(value) ? default : value
       else
-        nil
+        default
       end
     end
 
-    def ensure_integer!(**opts)
-      if opts[:boolean] == true || opts[:boolean].is_a?(Integer)
-        opts[:boolean] == true ? 1 : opts[:boolean]
-      else
-        super(**opts)
+    def ensure_integer!(default: nil, values: nil, boolean: nil, **opts)
+      if boolean == true || boolean.is_a?(Integer)
+        value = boolean == true ? 1 : boolean
+        return value unless values.is_a?(Array) && !values.include?(value)
       end
+      EnsureIt.raise_error(
+        :ensure_integer!,
+        **EnsureIt::ensure_integer_error_options(**opts)
+      )
     end
   end
 
   patch FalseClass do
-    using EnsureIt if ENSURE_IT_REFINES
+    def ensure_integer(default: nil, values: nil, boolean: nil, **opts)
+      return 0 if (boolean == true || boolean.is_a?(Integer)) &&
+                  (!values.is_a?(Array) || values.include?(0))
+      default
+    end
 
-    def ensure_integer(**opts)
-      opts[:boolean] == true || opts[:boolean].is_a?(Integer) ? 0 : nil
+    def ensure_integer!(default: nil, values: nil, boolean: nil, **opts)
+      return 0 if (boolean == true || boolean.is_a?(Integer)) &&
+                  (!values.is_a?(Array) || values.include?(0))
+      EnsureIt.raise_error(
+        :ensure_integer!,
+        **EnsureIt::ensure_integer_error_options(**opts)
+      )
     end
+  end
 
-    def ensure_integer!(**opts)
-      opts[:boolean] == true || opts[:boolean].is_a?(Integer) ? 0 : super(**opts)
+  def self.ensure_integer_error_options(**opts)
+    unless opts.key?(:message)
+      opts[:message] = '#{subject} should be an integer or be able' \
+                       ' to convert to it'
     end
+    opts
   end
 end

data/lib/ensure_it/ensure_string.rb

@@ -1,43 +1,92 @@
 module EnsureIt
   patch Object do
-    def ensure_string(**opts)
-      opts.key?(:wrong) ? opts[:wrong] : nil
+    def ensure_string(default: nil, **opts)
+      default
     end
 
-    def ensure_string!(**opts)
-      opts[:message] ||=
-        if opts[:numbers] == true
-          '#{subject} should be a String, Symbol, Numeric or Rational'
-        else
-          '#{subject} should be a String or a Symbol'
-        end
-      EnsureIt.raise_error(:ensure_string!, **opts)
+    def ensure_string!(default: nil, **opts)
+      EnsureIt.raise_error(
+        :ensure_string!,
+        **EnsureIt.ensure_string_error_options(**opts)
+      )
     end
   end
 
   patch String do
-    def ensure_string(**opts)
-      self
+    def ensure_string(default: nil, values: nil, **opts)
+      if values.nil? || values.is_a?(Array) && values.include?(self)
+        self
+      else
+        default
+      end
+    end
+
+    def ensure_string!(default: nil, values: nil, **opts)
+      if values.nil? || values.is_a?(Array) && values.include?(self)
+        return self
+      end
+      EnsureIt.raise_error(
+        :ensure_string!,
+        **EnsureIt.ensure_string_error_options(**opts)
+      )
     end
-    alias_method :ensure_string!, :ensure_string
   end
 
   patch Symbol do
-    def ensure_string(**opts)
-      to_s
+    def ensure_string(default: nil, values: nil, **opts)
+      if values.nil?
+        to_s
+      elsif values.is_a?(Array)
+        value = to_s
+        values.include?(value) ? value : default
+      else
+        default
+      end
+    end
+
+    def ensure_string!(default: nil, values: nil, **opts)
+      return to_s if values.nil?
+      if values.is_a?(Array)
+        value = to_s
+        return value if values.include?(value)
+      end
+      EnsureIt.raise_error(
+        :ensure_string!,
+        **EnsureIt.ensure_string_error_options(**opts)
+      )
     end
-    alias_method :ensure_string!, :ensure_string
   end
 
   patch Numeric do
-    using EnsureIt if ENSURE_IT_REFINES
+    using EnsureIt if ENSURE_IT_REFINED
 
-    def ensure_string(**opts)
-      opts[:numbers] == true ? to_s : nil
+    def ensure_string(default: nil, values: nil, numbers: false, **opts)
+      return default if numbers != true
+      value = to_s
+      values.is_a?(Array) && !values.include?(value) ? default : value
     end
 
-    def ensure_string!(**opts)
-      opts[:numbers] == true ? to_s : super(**opts)
+    def ensure_string!(default: nil, values: nil, numbers: false, **opts)
+      if numbers == true
+        value = to_s
+        return value if !values.is_a?(Array) || values.include?(value)
+      end
+      EnsureIt.raise_error(
+        :ensure_string!,
+        **EnsureIt.ensure_string_error_options(**opts)
+      )
+    end
+  end
+
+  def self.ensure_string_error_options(**opts)
+    unless opts.key?(opts[:message])
+      opts[:message] =
+        if opts[:numbers] == true
+          '#{subject} should be a String, Symbol, Numeric or Rational'
+        else
+          '#{subject} should be a String or a Symbol'
+        end
     end
+    opts
   end
 end

data/lib/ensure_it/ensure_symbol.rb

@@ -1,26 +1,71 @@
 module EnsureIt
   patch Object do
-    def ensure_symbol(**opts)
-      opts.key?(:wrong) ? opts[:wrong] : nil
+    def ensure_symbol(default: nil, **opts)
+      default
     end
 
-    def ensure_symbol!(**opts)
-      opts[:message] ||= '#{subject} should be a Symbol or a String'
-      EnsureIt.raise_error(:ensure_symbol!, **opts)
+    def ensure_symbol!(default: nil, **opts)
+      EnsureIt.raise_error(
+        :ensure_symbol!,
+        **EnsureIt.ensure_symbol_error_options(**opts)
+      )
     end
   end
 
   patch String do
-    def ensure_symbol(**opts)
-      to_sym
+    def ensure_symbol(default: nil, values: nil, **opts)
+      if values.nil?
+        to_sym
+      elsif values.is_a?(Array)
+        value = to_sym
+        values.include?(value) ? value : default
+      else
+        default
+      end
+    end
+
+    def ensure_symbol!(default: nil, values: nil, **opts)
+      return to_sym if values.nil?
+      if values.is_a?(Array)
+        value = to_sym
+        return value if values.include?(value)
+      end
+      EnsureIt.raise_error(
+        :ensure_symbol!,
+        **EnsureIt.ensure_symbol_error_options(**opts)
+      )
     end
-    alias_method :ensure_symbol!, :ensure_symbol
   end
 
   patch Symbol do
-    def ensure_symbol(**opts)
-      self
+    def ensure_symbol(default: nil, values: nil, **opts)
+      if values.nil? || values.is_a?(Array) && values.include?(self)
+        self
+      else
+        default
+      end
+    end
+
+    def ensure_symbol!(default: nil, values: nil, **opts)
+      if values.nil? || values.is_a?(Array) && values.include?(self)
+        return self
+      end
+      EnsureIt.raise_error(
+        :ensure_symbol!,
+        **EnsureIt.ensure_symbol_error_options(**opts)
+      )
+    end
+  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
     end
-    alias_method :ensure_symbol!, :ensure_symbol
+    opts
   end
 end

data/lib/ensure_it/errors.rb

@@ -62,19 +62,20 @@ module EnsureIt
   def self.raise_error(method_name, message: nil, error: Error, **opts)
     error = Error unless error <= Exception
     error_msg = ErrorMessage.new(method_name, message, caller[1..-1])
-    if opts.key?(:smart) && opts[:smart] != true ||
-       EnsureIt.config.errors != :smart
-      raise error, error_msg.message, error_msg.backtrace
+    # save message in backtrace in variables to not call getter
+    # methods of error_msg instance in raise call
+    error_message = error_msg.message
+    error_backtrace = error_msg.backtrace
+    if opts[:smart] == true || EnsureIt.config.errors == :smart
+      inspect_source(error_msg, **opts)
+      activate_smart_errors(error_msg, **opts)
     end
-    raise_smart_error(error_msg, error, **opts)
+    raise error, error_message, error_backtrace
   end
 
-  def self.raise_smart_error(error, error_class, **opts)
-    inspect_source(error, **opts)
+  def self.activate_smart_errors(error, **opts)
     tp_count = 0
     error_obj = nil
-    error_message = error.message
-    error_backtrace = error.backtrace
     #
     # first trace point is to capture raise object before exitting
     # from :ensure_* method
@@ -88,30 +89,24 @@ module EnsureIt
       else
         # skip returns from :raise_smart_error and :raise_error
         tp_count += 1
-        if tp_count > 1
-          # at this moment we are at end of 'ensure_' method
+        if tp_count > 2
           first_tp.disable
-          TracePoint.trace(:return) do |second_tp|
-            # skip return from :ensure_* method
-            tp_count += 1
-            if tp_count > 3
-              # now we are in caller context
-              second_tp.disable
-              unless error_obj.nil?
-                # inspect caller code
-                inspect_code(second_tp, error, **opts)
-                # patch error message
-                error_obj.extend(Module.new do
-                  @@ensure_it_message = error.message
-                  def message; @@ensure_it_message; end
-                end)
-              end
+          # at this moment we are at the end of 'ensure_' method
+          # skip last code line in :ensure_* method
+          TracePoint.trace(:return, :line) do |second_tp|
+            # now we are in caller context
+            second_tp.disable
+            unless error_obj.nil?
+              # inspect caller code
+              inspect_code(second_tp, error, **opts)
+              # patch error message
+              msg = error.message
+              error_obj.define_singleton_method(:message) { msg }
             end
           end
         end
       end
     end
-    raise error_class, error_message, error_backtrace
   end
 
   def self.inspect_source(error, **opts)
@@ -168,6 +163,6 @@ module EnsureIt
     line
   end
 
-  private_class_method :raise_smart_error, :inspect_source, :inspect_code,
+  private_class_method :activate_smart_errors, :inspect_source, :inspect_code,
                        :read_line_number
 end

data/lib/ensure_it/patch.rb

@@ -1,5 +1,5 @@
 module EnsureIt
-  if ENSURE_IT_REFINES
+  if ENSURE_IT_REFINED
     def self.patch(target, &block)
       module_eval do
         refine target do

data/lib/ensure_it/version.rb

@@ -1,3 +1,3 @@
 module EnsureIt
-  VERSION = '0.1.1'
+  VERSION = '0.1.2'
 end

data/lib/ensure_it.rb

@@ -2,7 +2,7 @@ if RUBY_VERSION < '2.0.0'
   fail %q{EnsureIt: library doesn't support ruby < 2.0.0}
 end
 
-defined?(ENSURE_IT_REFINES) || ENSURE_IT_REFINES = false
+defined?(ENSURE_IT_REFINED) || ENSURE_IT_REFINED = false
 
 require File.join %w(ensure_it version)
 require File.join %w(ensure_it config)

data/lib/{ensure_it_refines.rb → ensure_it_refined.rb}

@@ -1,7 +1,7 @@
 if RUBY_VERSION >= '2.1'
-  ENSURE_IT_REFINES = true
+  ENSURE_IT_REFINED = true
 else
-  ENSURE_IT_REFINES = false
+  ENSURE_IT_REFINED = false
   warn 'EsureIt: refines supported only for ruby >= 2.1'
 end