ensure_it 0.1.3 → 0.1.4

data/lib/ensure_it/ensure_hash.rb

@@ -4,7 +4,7 @@ module EnsureIt
       default
     end
 
-    def ensure_hash!(*args, default: nil, **opts)
+    def ensure_hash!(*args, **opts)
       opts[:message] ||= '#{subject} should be a Hash'
       EnsureIt.raise_error(:ensure_hash!, **opts)
     end
@@ -13,7 +13,7 @@ module EnsureIt
   patch Hash do
     using EnsureIt if ENSURE_IT_REFINED
 
-    def ensure_hash(*args, **opts)
+    def ensure_hash(*args, default: {}, **opts)
       return self if opts.empty? || opts[:symbolize_keys] != true
       Hash[map { |k, v| [k.ensure_symbol, v] }.reject { |x| x[0].nil? }]
     end

data/lib/ensure_it/ensure_instance_of.rb

@@ -10,7 +10,7 @@ module EnsureIt
       is_a?(klass) ? self : default
     end
 
-    def ensure_instance_of!(klass, default: nil, **opts)
+    def ensure_instance_of!(klass, **opts)
       unless klass.is_a?(Class)
         fail(
           ArgumentError,

data/lib/ensure_it/ensure_integer.rb

@@ -1,156 +1,136 @@
 module EnsureIt
-  OCT_REGEXP = /\A0\d+\z/
-  INT_REGEXP = /\A[+\-]?\d[\d_]*\z/
-  HEX_REGEXP = /\A0x[0-9a-zA-Z]+\z/
-  BIN_REGEXP = /\A0b[01]+\z/
-
   patch Object do
     def ensure_integer(default: nil, **opts)
       default
     end
 
-    def ensure_integer!(default: nil, **opts)
-      EnsureIt.raise_error(
-        :ensure_integer!,
-        **EnsureIt::ensure_integer_error_options(**opts)
-      )
+    def ensure_integer!(**opts)
+      EnsureIt.raise_error(:ensure_integer!,
+                           **EnsureIt::ensure_integer_error(**opts))
     end
   end
 
   patch String do
-    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 return default
-      end
-      if values.nil? || values.is_a?(Array) || values.include?(self)
-        value
-      else
-        default
-      end
+    def ensure_integer(default: nil, **opts)
+      catch(:wrong) { return EnsureIt.ensure_integer_string(self, **opts) }
+      default
     end
 
-    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)
-      )
+    def ensure_integer!(**opts)
+      catch(:wrong) { return EnsureIt.ensure_integer_string(self, **opts) }
+      EnsureIt.raise_error(:ensure_integer!,
+                           **EnsureIt::ensure_integer_error(**opts))
     end
   end
 
   patch Integer do
-    def ensure_integer(default: nil, values: nil, **opts)
-      if values.nil? || values.is_a?(Array) && values.include?(self)
-        self
-      else
-        default
-      end
+    def ensure_integer(default: nil, **opts)
+      return self if opts.empty?
+      catch(:wrong) { return EnsureIt.ensure_integer(self, **opts) }
+      default
     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)
-      )
+    def ensure_integer!(**opts)
+      return self if opts.empty?
+      catch(:wrong) { return EnsureIt.ensure_integer(self, **opts) }
+      EnsureIt.raise_error(:ensure_integer!,
+                           **EnsureIt::ensure_integer_error(**opts))
     end
   end
 
   patch Float do
-    def ensure_integer(default: nil, values: nil, **opts)
-      return round if values.nil?
-      value = round
-      values.is_a?(Array) && values.include?(value) ? value : default
+    def ensure_integer(default: nil, **opts)
+      return round if opts.empty?
+      catch(:wrong) { return EnsureIt.ensure_integer(round, **opts) }
+      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)
-      )
+    def ensure_integer!(**opts)
+      return round if opts.empty?
+      catch(:wrong) { return EnsureIt.ensure_integer(round, **opts) }
+      EnsureIt.raise_error(:ensure_integer!,
+                           **EnsureIt::ensure_integer_error(**opts))
     end
   end
 
   patch Rational do
-    def ensure_integer(default: nil, values: nil, **opts)
-      return round if values.nil?
-      value = round
-      values.is_a?(Array) && values.include?(value) ? value : default
+    def ensure_integer(default: nil, **opts)
+      return round if opts.empty?
+      catch(:wrong) { return EnsureIt.ensure_integer(round, **opts) }
+      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)
-      )
+    def ensure_integer!(**opts)
+      return round if opts.empty?
+      catch(:wrong) { return EnsureIt.ensure_integer(round, **opts) }
+      EnsureIt.raise_error(:ensure_integer!,
+                           **EnsureIt::ensure_integer_error(**opts))
     end
   end
 
   patch TrueClass do
-    def ensure_integer(default: nil, values: nil, boolean: nil, **opts)
+    def ensure_integer(default: 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
-        default
+        return value if opts.empty?
+        catch(:wrong) { return EnsureIt.ensure_integer(value, **opts) }
       end
+      default
     end
 
-    def ensure_integer!(default: nil, values: nil, boolean: nil, **opts)
+    def ensure_integer!(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)
+        return value if opts.empty?
+        catch(:wrong) { return EnsureIt.ensure_integer(value, **opts) }
       end
-      EnsureIt.raise_error(
-        :ensure_integer!,
-        **EnsureIt::ensure_integer_error_options(**opts)
-      )
+      EnsureIt.raise_error(:ensure_integer!,
+                           **EnsureIt::ensure_integer_error(**opts))
     end
   end
 
   patch FalseClass do
-    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))
+    def ensure_integer(default: nil, boolean: nil, **opts)
+      if boolean == true || boolean.is_a?(Integer)
+        return 0 if opts.empty?
+        catch(:wrong) { return EnsureIt.ensure_integer(0, **opts) }
+      end
       default
     end
 
     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)
-      )
+      if boolean == true || boolean.is_a?(Integer)
+        return 0 if opts.empty?
+        catch(:wrong) { return EnsureIt.ensure_integer(0, **opts) }
+      end
+      EnsureIt.raise_error(:ensure_integer!,
+                           **EnsureIt::ensure_integer_error(**opts))
+    end
+  end
+
+  OCT_REGEXP = /\A0\d+\z/
+  INT_REGEXP = /\A[+\-]?\d[\d_]*\z/
+  HEX_REGEXP = /\A0x[0-9a-zA-Z]+\z/
+  BIN_REGEXP = /\A0b[01]+\z/
+
+  def self.ensure_integer(int, values: nil, **opts)
+    throw :wrong if values.is_a?(Array) && !values.include?(int)
+    int
+  end
+
+  def self.ensure_integer_string(str, **opts)
+    value = case str
+      when OCT_REGEXP then opts[:octal] == true ? str.to_i(8) : str.to_i
+      when INT_REGEXP then str.to_i
+      when HEX_REGEXP then str[2..-1].to_i(16)
+      when BIN_REGEXP then str[2..-1].to_i(2)
+      else throw :wrong
     end
+    return value if opts.empty?
+    return EnsureIt.ensure_integer(value, **opts)
   end
 
-  def self.ensure_integer_error_options(**opts)
+  def self.ensure_integer_error(**opts)
     unless opts.key?(:message)
       opts[:message] = '#{subject} should be an integer or be able' \
                        ' to convert to it'

data/lib/ensure_it/ensure_string.rb

@@ -1,90 +1,156 @@
+# @!method ensure_string(opts = {})
+#
+# Ensures that subject is a string. Without options for symbols returns
+# converted to string value, for strings, returns self, for others - value,
+# specified in default option or nil. With `numbers: true` option, also
+# converts numbers to string.
+#
+# With `downcase: true` option downcases value.
+#
+# If `values` option specified, returns default value if converted value
+# is not included in specified array. **Warning:** there are no type checks
+# of array elements, so if you, for example, specify array of integers here,
+# this method will allways return default value.
+#
+# `name_of` option, if specified, should be one of: `:local`,
+# `:instance_variable`, `:class_variable`, `:setter`, `:getter`, `:checker`,
+# `:bang`, `:method`, `:class` or its string equivalents. This option allow you
+# to be ensured that return value is a valid name of local variable,
+# instance variable, class variable, setter method, getter method, checker
+# method (ending with `?`), bang method (ending with `!`), any method or
+# class, respectively to option values above. See examples below for details.
+# If you want to convert underscored downcased notations of classes, use
+# `downcase: true` option. Also, with `name_of: :class`, `exist: true` option
+# can specified to ensures that class exists.
+#
+# @example  usage of `name_of` option
+# ```ruby
+#   'some text'.ensure_string(name_of: :local) # => nil
+#   'some_text'.ensure_string(name_of: :local) # => 'some_text'
+#
+#   'some_text'.ensure_string(name_of: :instance_variable) # => '@some_text'
+#   '@some_text'.ensure_string(name_of: :instance_variable) # => '@some_text'
+#   'some_text='.ensure_string(name_of: :instance_variable) # => '@some_text'
+#
+#   'some_text'.ensure_string(name_of: :setter) # => 'some_text='
+#   'some_text?'.ensure_string(name_of: :setter) # => 'some_text='
+#   'some_text='.ensure_string(name_of: :setter) # => 'some_text='
+#
+#   'some_text'.ensure_string(name_of: :class) # => nil
+#   'Some::Text'.ensure_string(name_of: :class) # => Some::Text
+#   'some_text'.ensure_string(name_of: :class, downcase: true) # => SomeText
+#   'some/text'.ensure_string(name_of: :class, downcase: true) # => Some::Text
+#   'Some::Text'.ensure_string(name_of: :class, exist: true) # => nil
+#   'Object'.ensure_string(name_of: :class, exist: true) # => 'Object'
+# ```
+#
+# @param [Hash] opts the options
+# @option opts [Object] :default (nil) default value for wrong subject
+# @option opts [Array] :values an array of possible values
+# @option opts [Boolean] :downcase convert string to downcase
+# @option opts [<String, Symbol>] :name_of string should be a name of variable
+#   or method
+
+# @private
 module EnsureIt
   patch Object do
     def ensure_string(default: nil, **opts)
       default
     end
 
-    def ensure_string!(default: nil, **opts)
-      EnsureIt.raise_error(
-        :ensure_string!,
-        **EnsureIt.ensure_string_error_options(**opts)
-      )
+    def ensure_string!(**opts)
+      EnsureIt.raise_error(:ensure_string!,
+                           **EnsureIt.ensure_string_error(**opts))
     end
   end
 
   patch String do
-    def ensure_string(default: nil, values: nil, downcase: nil, **opts)
-      value = downcase == true ? self.downcase : self
-      if values.nil? || values.is_a?(Array) && values.include?(value)
-        value
-      else
-        default
+    def ensure_string(default: nil, **opts)
+      return self if opts.empty?
+      catch :wrong do
+        return EnsureIt.ensure_string(self, **opts)
       end
+      default
     end
 
-    def ensure_string!(default: nil, values: nil, downcase: nil, **opts)
-      value = downcase == true ? self.downcase : self
-      if values.nil? || values.is_a?(Array) && values.include?(value)
-        return value
+    def ensure_string!(**opts)
+      return self if opts.empty?
+      catch :wrong do
+        return EnsureIt.ensure_string(self, **opts)
       end
-      EnsureIt.raise_error(
-        :ensure_string!,
-        **EnsureIt.ensure_string_error_options(**opts)
-      )
+      EnsureIt.raise_error(:ensure_string!,
+                           **EnsureIt.ensure_string_error(**opts))
     end
   end
 
   patch Symbol do
-    def ensure_string(default: nil, values: nil, downcase: nil, **opts)
-      value = downcase == true ? to_s.downcase : to_s
-      if values.nil? || values.is_a?(Array) && values.include?(value)
-        value
-      else
-        default
+    def ensure_string(default: nil, **opts)
+      return to_s if opts.empty?
+      catch :wrong do
+        return EnsureIt.ensure_string(to_s, **opts)
       end
+      default
     end
 
-    def ensure_string!(default: nil, values: nil, downcase: nil, **opts)
-      value = downcase == true ? to_s.downcase : to_s
-      if values.nil? || values.is_a?(Array) && values.include?(value)
-        return value
+    def ensure_string!(**opts)
+      return to_s if opts.empty?
+      catch :wrong do
+        return EnsureIt.ensure_string(to_s, **opts)
       end
-      EnsureIt.raise_error(
-        :ensure_string!,
-        **EnsureIt.ensure_string_error_options(**opts)
-      )
+      EnsureIt.raise_error(:ensure_string!,
+                           **EnsureIt.ensure_string_error(**opts))
     end
   end
 
   patch Numeric do
     using EnsureIt if ENSURE_IT_REFINED
 
-    def ensure_string(default: nil, values: nil, numbers: false, **opts)
+    def ensure_string(default: nil, numbers: false, **opts)
       return default if numbers != true
-      value = to_s
-      values.is_a?(Array) && !values.include?(value) ? default : value
+      catch :wrong do
+        return EnsureIt.ensure_string(to_s, **opts)
+      end
+      default
     end
 
-    def ensure_string!(default: nil, values: nil, numbers: false, **opts)
+    def ensure_string!(numbers: false, **opts)
       if numbers == true
-        value = to_s
-        return value if !values.is_a?(Array) || values.include?(value)
+        catch :wrong do
+          return EnsureIt.ensure_string(to_s, **opts)
+        end
       end
       EnsureIt.raise_error(
         :ensure_string!,
-        **EnsureIt.ensure_string_error_options(**opts)
+        **EnsureIt.ensure_string_error(numbers: numbers, **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
+  def self.ensure_string(str, values: nil, downcase: nil, name_of: nil, **opts)
+    if name_of.nil?
+      value = downcase == true ? str.downcase : str
+    else
+      value = EnsureIt::StringUtils.ensure_name(
+        str, downcase: downcase, name_of: name_of, **opts
+      )
+      throw :wrong if value.nil?
+    end
+    throw :wrong if values.is_a?(Array) && !values.include?(value)
+    value
+  end
+
+  def self.ensure_string_error(**opts)
+    unless opts.key?(:message)
+      opts[:message] = '#{subject} should be a String or a Symbol'
+      if opts[:numbers] == true
+        opts[:message] << ' or a Numeric'
+      end
+      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