ensure_it 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5d381a0a403aaacdf696b7c0a266bce2fa39ae74
-  data.tar.gz: 25c551cabb907a4c8319a5e1b21745033eba16ec
+  metadata.gz: b5f9d6674b5751ec725332d84f6a9527d1824efa
+  data.tar.gz: b5b0fbe8eec8d2ddd7e35b8a79c5560e7541868f
 SHA512:
-  metadata.gz: ee79f33c6d6029d32b4b6bb363a9247c22580805d3665bb1ec7f7895ee44faac4dec601d6f1b506c17b5a583f931ee6e9e23e8b05759bd21fa90235a6dc305c1
-  data.tar.gz: c65f42a800eff72dc0a663d0f92ad9e4a9a3eabbcbfb7a8126b8384f43115d9b3ff613c86e6f569996524f1fa5154f3a8d1607a00ca84b72d9a5b52397daa33a
+  metadata.gz: 77f9808d8d5ede9eea61208535bec4e3b8609b3a9a254cba63203b29fb8fe34ab8f970fca2b341ce9cc3512e4f10d0e0ac7538ac80e2d6189d343d01cf59dd52
+  data.tar.gz: 34765d4a0fd5e73c2e9bd2b33b2d931ad55983004bd126a083704402a34478f0cf38dfc207adb47dbcf0a9af3814c80af326ba439d81806eaff27509e9047e64

data/.yardopts

@@ -0,0 +1,3 @@
+--no-private
+--markup markdown
+--embed-mixins

data/README.md

@@ -11,7 +11,7 @@ The main goal of EnsureIt is to provide as fast executed code as it possible wit
 
 > **Note:** this library doesn't support ruby older than `2.0.0`
 
-Simplest example (you can find at `examples/symbol.rb`):
+Simple example (you can find it at `examples/symbol.rb`):
 
 ```ruby
 require 'rubygems'
@@ -69,7 +69,7 @@ $ gem install ensure_it
 
 ## Configuration
 
-For this moment only one configuration option available - global setting of smart errors (see [Usage section](#usage)):
+For this moment only two configuration options available - global setting of smart errors (see [Usage section](#usage)) and default errors class (that will be used if it doesn't specified in methods calls):
 
 ```ruby
 require 'ensure_it'
@@ -77,6 +77,7 @@ require 'ensure_it'
 EnsureIt.configuration do |config|
   # config.errors = :standard
   config.errors = :smart
+  config.error_class = ArgumentError
 end
 ```
 
@@ -185,20 +186,19 @@ true.ensure_float # => nil
 
 ### ensure_array, ensure_array!
 
-By default, returns Array only for Array itself and **empty** array (not nil) for others. This method have many usefull optioins. Just list it in example:
+By default, returns Array only for Array itself and **empty** array (not nil) for others. You can specify any number of arguments. Each argument can be a Proc or a symbol. If Proc given, it will be used as argument for `map` method of array, if symbol specified and it is one of `compact`, `flatten`, `reverse`, `rotate`, `shuffle`, `sort`, `sort_desc`, `uniq` then respective method wiill be called for array (for `sort_desc`, `sort` and then `reverse` will be called). In other cases specified method will be called for each array element inside `map` function. All arguments are processed in specified order. Examples:
 
 ```ruby
 [1, nil, 2].ensure_array # => [1, nil, 2]
 true.ensure_array # => []
 true.ensure_array(default: nil) # => nil
-[1, nil, 2].ensure_array(compact: true) # => [1, 2]
-[1, [2, 3], 4].ensure_array(flatten: true) # => [1, 2, 3, 4]
-[1, [5, 6], 4].ensure_array(flatten: true, sorted: true) # => [1, 4, 5, 6]
-[1, [5, 6], 4].ensure_array(flatten: true, sorted: :desc) # => [6, 5, 4, 1]
-[1, [5, 6], 4].ensure_array(flatten: true, ordered: true) # => alias to sorted
+[1, nil, 2].ensure_array(:compact) # => [1, 2]
+[1, [2, 3], 4].ensure_array(:flatten) # => [1, 2, 3, 4]
+[1, [5, 6], 4].ensure_array(:flatten, :sort) # => [1, 4, 5, 6]
+[1, [5, 6], 4].ensure_array(:flatten, :sort_desc) # => [6, 5, 4, 1]
 arr = ['some', nil, :value]
-arr.ensure_array(:ensure_symbol, compact: true) # => [:some, :value]
-arr.ensure_array(:ensure_symbol!, compact: true) # => raise on second element
+arr.ensure_array(:ensure_symbol, :compact) # => [:some, :value]
+arr.ensure_array(:ensure_symbol!, :compact) # => raise on second element
 arr = ['some', :value]
 arr.ensure_array(:to_s) # => ['some', 'value'] standard methods can be used
 arr.ensure_array(:ensure_string, :to_sym) # => [:some, :value] you can chain methods
@@ -372,6 +372,13 @@ thor ensure_it:benchmark:all -n 1000 -s
 
 ## Changelog
 
+`0.1.4`
+* name_of option added to `ensure_symbol` and `ensure_string`
+* string options added to `ensure_class`
+* code optimization
+* config_error configuration option added
+* `ensure_array` interface changed
+
 `0.1.3`
 * downcase option added to `ensure_symbol` and `ensure_string`
 

data/lib/ensure_it.rb

@@ -4,6 +4,12 @@ end
 
 defined?(ENSURE_IT_REFINED) || ENSURE_IT_REFINED = false
 
+module EnsureIt
+  module StringUtils
+    def self.ensure_name(*args); end
+  end
+end
+
 require File.join %w(ensure_it version)
 require File.join %w(ensure_it config)
 require File.join %w(ensure_it errors)
@@ -16,3 +22,4 @@ require File.join %w(ensure_it ensure_array)
 require File.join %w(ensure_it ensure_hash)
 require File.join %w(ensure_it ensure_instance_of)
 require File.join %w(ensure_it ensure_class)
+require File.join %w(ensure_it string_utils)

data/lib/ensure_it/config.rb

@@ -10,6 +10,15 @@ module EnsureIt
       value = value.to_sym if value.is_a?(String)
       @errors = ERRORS.include?(value) ? value : ERRORS.first
     end
+
+    def self.error_class(value = nil)
+      value.nil? ? @error_class ||= EnsureIt::Error : self.error_class = value
+    end
+
+    def self.error_class=(value)
+      return unless value.is_a?(Class) && value <= Exception
+      @error_class = value
+    end
   end
 
   def self.config

data/lib/ensure_it/ensure_array.rb

@@ -4,7 +4,7 @@ module EnsureIt
       default
     end
 
-    def ensure_array!(*args, default: nil, **opts)
+    def ensure_array!(*args, **opts)
       opts[:message] ||= '#{subject} should be an Array'
       EnsureIt.raise_error(:ensure_array!, **opts)
     end
@@ -13,55 +13,68 @@ module EnsureIt
   patch Array do
     using EnsureIt if ENSURE_IT_REFINED
 
+    ENSURES = %i(ensure_symbol ensure_symbol! ensure_string ensure_string!
+                 ensure_integer ensure_integer! ensure_float ensure_float!
+                 ensure_array ensure_array! ensure_class ensure_class!)
+
+    OPERATIONS = %i(compact flatten reverse rotate shuffle sort sort_desc uniq)
+
+
     if ENSURE_IT_REFINED
       def ensure_array(*args, values: nil, **opts)
         arr = self
         args.each do |arg|
+          if arg.is_a?(Proc)
+            arr = arr.map(arg)
+            next
+          end
           arg = arg.ensure_symbol || next
-          arr =
-            if arg.to_s.index('ensure_') == 0
-              case arg
-              when :ensure_symbol then map { |x| x.ensure_symbol }
-              when :ensure_symbol! then map { |x| x.ensure_symbol! }
-              when :ensure_string then map { |x| x.ensure_string }
-              when :ensure_string! then map { |x| x.ensure_string! }
-              when :ensure_integer then map { |x| x.ensure_integer }
-              when :ensure_integer! then map { |x| x.ensure_integer! }
-              when :ensure_float then map { |x| x.ensure_float }
-              when :ensure_float! then map { |x| x.ensure_float! }
-              when :ensure_array then map { |x| x.ensure_array }
-              when :ensure_array! then map { |x| x.ensure_array! }
-              end
-            else
-              arr.map(&arg)
+          case arg
+          when *ENSURES
+            arr = case arg
+            when :ensure_symbol then map { |x| x.ensure_symbol }
+            when :ensure_symbol! then map { |x| x.ensure_symbol! }
+            when :ensure_string then map { |x| x.ensure_string }
+            when :ensure_string! then map { |x| x.ensure_string! }
+            when :ensure_integer then map { |x| x.ensure_integer }
+            when :ensure_integer! then map { |x| x.ensure_integer! }
+            when :ensure_float then map { |x| x.ensure_float }
+            when :ensure_float! then map { |x| x.ensure_float! }
+            when :ensure_array then map { |x| x.ensure_array }
+            when :ensure_array! then map { |x| x.ensure_array! }
+            when :ensure_class then map { |x| x.ensure_class }
+            when :ensure_class! then map { |x| x.ensure_class! }
             end
+          when *OPERATIONS
+            op = arg == :sort_desc ? :sort : arg
+            arr = arr.send(op)
+            arr = arr.reverse if arg == :sort_desc
+          else
+            arr = arr.map { |x| x.respond_to?(arg) ? x.send(arg) : nil }
+          end
         end
-        return arr if opts.empty?
-        arr = arr.map { |x| x } if arr == self
-        arr.flatten! if opts[:flatten] == true
-        arr.select! { |x| values.include?(x) } if values.is_a?(Array)
-        opts[:sorted] ||= opts.delete(:ordered) if opts.key?(:ordered)
-        arr.sort! if opts.key?(:sorted)
-        arr.reverse! if opts[:sorted].ensure_symbol == :desc
-        arr.compact! if opts[:compact] == true
-        arr
+        values.is_a?(Array) ? arr & values : arr
       end
     else
       def ensure_array(*args, values: nil, **opts)
         arr = self
         args.each do |arg|
+          if arg.is_a?(Proc)
+            arr = arr.map(arg)
+            next
+          end
           arg = arg.ensure_symbol || next
-          arr = arr.map(&arg)
+          case arg
+          when *ENSURES then arr = arr.map(&arg)
+          when *OPERATIONS
+            op = arg == :sort_desc ? :sort : arg
+            arr = arr.send(op)
+            arr = arr.reverse if arg == :sort_desc
+          else
+            arr = arr.map { |x| x.respond_to?(arg) ? x.send(arg) : nil }
+          end
         end
-        return arr if opts.empty?
-        arr = arr.map { |x| x } if arr == self
-        arr.flatten! if opts[:flatten] == true
-        arr.select! { |x| values.include?(x) } if values.is_a?(Array)
-        opts[:sorted] ||= opts.delete(:ordered) if opts.key?(:ordered)
-        arr.sort! if opts.key?(:sorted)
-        arr.reverse! if opts[:sorted].ensure_symbol == :desc
-        arr.compact! if opts[:compact] == true
-        arr
+        values.is_a?(Array) ? arr & values : arr
       end
     end
     alias_method :ensure_array!, :ensure_array

data/lib/ensure_it/ensure_class.rb

@@ -4,33 +4,70 @@ module EnsureIt
       default
     end
 
-    def ensure_class!(*args, default: nil, **opts)
+    def ensure_class!(*args, **opts)
       opts[:message] ||= '#{subject} should be a class'
       EnsureIt.raise_error(:ensure_class!, **opts)
     end
   end
 
   patch Class do
-    def ensure_class(*args, default: nil, values: nil, **opts)
-      args.select! { |x| x.is_a?(Module) }
-      return default unless args.all? { |x| self <= x }
-      if values.nil? || values.is_a?(Array) && values.include?(self)
-        self
-      else
-        default
-      end
+    def ensure_class(*args, default: nil, **opts)
+      return self if args.empty? && opts.empty?
+      catch(:wrong) { return EnsureIt.ensure_class(self, *args, **opts) }
+      default
     end
 
-    def ensure_class!(*args, default: nil, values: nil, **opts)
-      args.select! { |x| x.is_a?(Module) }
-      if args.all? { |x| self <= x } &&
-         (values.nil? || values.is_a?(Array) && values.include?(self))
-        return self
-      end
+    def ensure_class!(*args, **opts)
+      return self if args.empty? && opts.empty?
+      catch(:wrong) { return EnsureIt.ensure_class(self, *args, **opts) }
       args = args.map!(&:name).join(', ')
       opts[:message] ||=
         "\#{subject} should subclass or extend all of ['#{args}']"
       EnsureIt.raise_error(:ensure_class!, **opts)
     end
   end
+
+  patch String do
+    using EnsureIt if ENSURE_IT_REFINED
+
+    def ensure_class(*args, default: nil, string: nil, **opts)
+      return default if string != true
+      catch :wrong do
+        return EnsureIt.ensure_class_string(self, *args, **opts)
+      end
+      default
+    end
+
+    def ensure_class!(*args, string: nil, **opts)
+      if string == true
+        catch :wrong do
+          return EnsureIt.ensure_class_string(self, *args, **opts)
+        end
+      end
+      args = args.map!(&:name).join(', ')
+      unless opts.key?(:message)
+        opts[:message] = '#{subject} should'
+        opts[:message] << ' be a class or a name of class,' if string == true
+        opts[:message] << " that subclass or extend all of ['#{args}']"
+      end
+      EnsureIt.raise_error(:ensure_class!, **opts)
+    end
+  end
+
+  def self.ensure_class_string(str, *args, **opts)
+    opts.delete(:name_of)
+    opts.delete(:exist)
+    name = EnsureIt::StringUtils.ensure_name(
+      str, name_of: :class, exist: true, **opts
+    )
+    throw :wrong if name.nil?
+    EnsureIt.ensure_class(Object.const_get(name), *args, **opts)
+  end
+
+  def self.ensure_class(klass, *args, values: nil, **opts)
+    args.select! { |x| x.is_a?(Module) }
+    throw :wrong unless args.all? { |x| klass <= x }
+    throw :wrong if values.is_a?(Array) && !values.include?(klass)
+    klass
+  end
 end

data/lib/ensure_it/ensure_float.rb

@@ -6,96 +6,79 @@ module EnsureIt
       default
     end
 
-    def ensure_float!(default: nil, **opts)
-      EnsureIt.raise_error(
-        :ensure_float!,
-        **EnsureIt::ensure_float_error_options(**opts)
-      )
+    def ensure_float!(**opts)
+      EnsureIt.raise_error(:ensure_float!,
+                           **EnsureIt::ensure_float_error(**opts))
     end
   end
 
   patch String do
-    def ensure_float(default: nil, values: nil, **opts)
+    def ensure_float(default: nil, **opts)
       return default unless self =~ FLOAT_REGEXP
-      value = to_f
-      if values.nil? || values.is_a?(Array) && values.include?(value)
-        value
-      else
-        default
-      end
+      catch(:wrong) { return EnsureIt.ensure_float(to_f, **opts) }
+      default
     end
 
-    def ensure_float!(default: nil, values: nil, **opts)
+    def ensure_float!(**opts)
       if self =~ FLOAT_REGEXP
-        value = to_f
-        if values.nil? || values.is_a?(Array) && values.include?(value)
-          return value
-        end
+        catch(:wrong) { return EnsureIt.ensure_float(to_f, **opts) }
       end
-      EnsureIt.raise_error(
-        :ensure_float!,
-        **EnsureIt::ensure_float_error_options(**opts)
-      )
+      EnsureIt.raise_error(:ensure_float!,
+                           **EnsureIt::ensure_float_error(**opts))
     end
   end
 
   patch Integer do
-    def ensure_float(default: nil, values: nil, **opts)
-      return to_f if values.nil?
-      value = to_f
-      values.is_a?(Array) && values.include?(value) ? value : default
+    def ensure_float(default: nil, **opts)
+      return to_f if opts.nil?
+      catch(:wrong) { return EnsureIt.ensure_float(to_f, **opts) }
+      default
     end
 
-    def ensure_float!(default: nil, values: nil, **opts)
-      return to_f if values.nil?
-      value = to_f
-      return values if values.is_a?(Array) && values.include?(value)
-      EnsureIt.raise_error(
-        :ensure_float!,
-        **EnsureIt::ensure_float_error_options(**opts)
-      )
+    def ensure_float!(**opts)
+      return to_f if opts.nil?
+      catch(:wrong) { return EnsureIt.ensure_float(to_f, **opts) }
+      EnsureIt.raise_error(:ensure_float!,
+                           **EnsureIt::ensure_float_error(**opts))
     end
   end
 
   patch Float do
-    def ensure_float(default: nil, values: nil, **opts)
-      if values.nil? || values.is_a?(Array) && values.include?(self)
-        self
-      else
-        default
-      end
+    def ensure_float(default: nil, **opts)
+      return self if opts.nil?
+      catch(:wrong) { return EnsureIt.ensure_float(self, **opts) }
+      default
     end
 
-    def ensure_float!(default: nil, values: nil, **opts)
-      if values.nil? || values.is_a?(Array) && values.include?(self)
-        return self
-      end
-      EnsureIt.raise_error(
-        :ensure_float!,
-        **EnsureIt::ensure_float_error_options(**opts)
-      )
+    def ensure_float!(**opts)
+      return self if opts.nil?
+      catch(:wrong) { return EnsureIt.ensure_float(self, **opts) }
+      EnsureIt.raise_error(:ensure_float!,
+                           **EnsureIt::ensure_float_error(**opts))
     end
   end
 
   patch Rational do
-    def ensure_float(default: nil, values: nil, **opts)
-      return to_f if values.nil?
-      value = to_f
-      values.is_a?(Array) && values.include?(value) ? value : default
+    def ensure_float(default: nil, **opts)
+      return to_f if opts.nil?
+      catch(:wrong) { return EnsureIt.ensure_float(to_f, **opts) }
+      default
     end
 
-    def ensure_float!(default: nil, values: nil, **opts)
-      return to_f if values.nil?
-      value = to_f
-      return values if values.is_a?(Array) && values.include?(value)
-      EnsureIt.raise_error(
-        :ensure_float!,
-        **EnsureIt::ensure_float_error_options(**opts)
-      )
+    def ensure_float!(**opts)
+      return to_f if opts.nil?
+      catch(:wrong) { return EnsureIt.ensure_float(to_f, **opts) }
+      EnsureIt.raise_error(:ensure_float!,
+                           **EnsureIt::ensure_float_error(**opts))
     end
   end
 
-  def self.ensure_float_error_options(**opts)
+  def self.ensure_float(float, values: nil, **opts)
+    throw :wrong if values.is_a?(Array) && !values.include?(float)
+    float
+  end
+
+  def self.ensure_float_error(**opts)
     unless opts.key?(:message)
       opts[:message] = '#{subject} should be a float or be able' \
                        ' to convert to it'