ensure_it 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b5f9d6674b5751ec725332d84f6a9527d1824efa
-  data.tar.gz: b5b0fbe8eec8d2ddd7e35b8a79c5560e7541868f
+  metadata.gz: a99f1a9c837f0279fd4e71b337e15e8449618dc0
+  data.tar.gz: ae1caca2ca9c85198c5c7a1f149d18ce8ef18741
 SHA512:
-  metadata.gz: 77f9808d8d5ede9eea61208535bec4e3b8609b3a9a254cba63203b29fb8fe34ab8f970fca2b341ce9cc3512e4f10d0e0ac7538ac80e2d6189d343d01cf59dd52
-  data.tar.gz: 34765d4a0fd5e73c2e9bd2b33b2d931ad55983004bd126a083704402a34478f0cf38dfc207adb47dbcf0a9af3814c80af326ba439d81806eaff27509e9047e64
+  metadata.gz: a037de6ea3e3260557b445ca8bfa051410e9a67a92c3ac35d61befc6ad51eaf0d84082cb85920f549fccd8e633837d3bb21cab1d1065dd463ec63580b5f7bef3
+  data.tar.gz: 30c3e01829b7099823ee817ac69030d53eeb788531f5d1d106127e6fe782b58f549771fc402d7a574a7ff7e05361a2db0c4ac40b6d7a9371e3ef31713b277e5c

data/README.md

@@ -186,12 +186,14 @@ true.ensure_float # => nil
 
 ### ensure_array, ensure_array!
 
-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:
+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. Also you can use `make: true` option to make array with object as single element if object is not an array (for `nil` empty array created). Examples:
 
 ```ruby
 [1, nil, 2].ensure_array # => [1, nil, 2]
-true.ensure_array # => []
-true.ensure_array(default: nil) # => nil
+10.ensure_array # => []
+10.ensure_array(default: nil) # => nil
+10.ensure_array(make: true) # => [10]
+nil.ensure_array(make: true) # => []
 [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]
@@ -372,6 +374,10 @@ thor ensure_it:benchmark:all -n 1000 -s
 
 ## Changelog
 
+`0.1.5`
+* added `EnsureIt.refined?`
+* `ensure_array` `make` option added
+
 `0.1.4`
 * name_of option added to `ensure_symbol` and `ensure_string`
 * string options added to `ensure_class`

data/lib/ensure_it/ensure_array.rb

@@ -1,82 +1,106 @@
+#
 module EnsureIt
   patch Object do
-    def ensure_array(*args, default: [], **opts)
-      default
+    def ensure_array(*args, default: [], make: false, **opts)
+      return default if make != true
+      EnsureIt.ensure_array([self], *args, **opts)
     end
 
-    def ensure_array!(*args, **opts)
-      opts[:message] ||= '#{subject} should be an Array'
-      EnsureIt.raise_error(:ensure_array!, **opts)
+    def ensure_array!(*args, make: false, **opts)
+      return EnsureIt.ensure_array([self], *args, **opts) if make == true
+      EnsureIt.raise_error(:ensure_array!,
+                           **EnsureIt.ensure_array_error(**opts))
+    end
+  end
+
+  patch NilClass do
+    def ensure_array(*args, default: [], make: false, **opts)
+      make == true ? [] : default
+    end
+
+    def ensure_array!(*args, make: false, **opts)
+      return [] if make == true
+      EnsureIt.raise_error(:ensure_array!,
+                           **EnsureIt.ensure_array_error(**opts))
     end
   end
 
   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!)
+    def ensure_array(*args, **opts)
+      EnsureIt.ensure_array(self, *args, **opts)
+    end
+    alias_method :ensure_array!, :ensure_array
+  end
 
-    OPERATIONS = %i(compact flatten reverse rotate shuffle sort sort_desc uniq)
+  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
-          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! }
+  if ENSURE_IT_REFINED
+    using EnsureIt
+
+    def self.ensure_array(arr, *args, values: nil, **opts)
+      args.each do |arg|
+        if arg.is_a?(Proc)
+          arr = arr.map(arg)
+          next
+        end
+        arg = arg.ensure_symbol || next
+        case arg
+        when *ENSURES
+          arr =
+            case arg
+            when :ensure_symbol then arr.map { |x| x.ensure_symbol }
+            when :ensure_symbol! then arr.map { |x| x.ensure_symbol! }
+            when :ensure_string then arr.map { |x| x.ensure_string }
+            when :ensure_string! then arr.map { |x| x.ensure_string! }
+            when :ensure_integer then arr.map { |x| x.ensure_integer }
+            when :ensure_integer! then arr.map { |x| x.ensure_integer! }
+            when :ensure_float then arr.map { |x| x.ensure_float }
+            when :ensure_float! then arr.map { |x| x.ensure_float! }
+            when :ensure_array then arr.map { |x| x.ensure_array }
+            when :ensure_array! then arr.map { |x| x.ensure_array! }
+            when :ensure_class then arr.map { |x| x.ensure_class }
+            when :ensure_class! then arr.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
+        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
-        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
-          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
+      values.is_a?(Array) ? arr & values : arr
+    end
+  else
+    def self.ensure_array(arr, *args, values: nil, **opts)
+      args.each do |arg|
+        if arg.is_a?(Proc)
+          arr = arr.map(arg)
+          next
+        end
+        arg = arg.ensure_symbol || next
+        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
-        values.is_a?(Array) ? arr & values : arr
       end
+      values.is_a?(Array) ? arr & values : arr
     end
-    alias_method :ensure_array!, :ensure_array
+  end
+
+  def self.ensure_array_error(**opts)
+    opts[:message] ||= '#{subject} should be an Array'
+    opts
   end
 end

data/lib/ensure_it/version.rb

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

data/lib/ensure_it.rb

@@ -1,13 +1,19 @@
 if RUBY_VERSION < '2.0.0'
-  fail %q{EnsureIt: library doesn't support ruby < 2.0.0}
+  fail %q(EnsureIt: library doesn't support ruby < 2.0.0)
 end
 
 defined?(ENSURE_IT_REFINED) || ENSURE_IT_REFINED = false
 
+#
 module EnsureIt
+  # dummy module for eager usage
   module StringUtils
     def self.ensure_name(*args); end
   end
+
+  def self.refined?
+    ENSURE_IT_REFINED == true
+  end
 end
 
 require File.join %w(ensure_it version)

data/spec/lib/ensure_array_spec.rb

@@ -44,7 +44,7 @@ describe EnsureIt do
 
     it 'calls standard method for each element' do
       arr = ['s', :v]
-      expect(call_for(arr, :to_s)).to eq ['s', 'v']
+      expect(call_for(arr, :to_s)).to eq %w(s v)
     end
 
     it 'chains methods for each element' do
@@ -57,6 +57,11 @@ describe EnsureIt do
         call_for([1, 5, 6, 4], values: [1, 6, 8])
       ).to eq [1, 6]
     end
+
+    it 'creates array with make option' do
+      expect(call_for(1, make: true)).to eq [1]
+      expect(call_for(nil, make: true)).to eq []
+    end
   end
 
   describe '#ensure_array' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ensure_it
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Alexey Ovchinnikov