lite-ruby 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ebfe63ca0039bd6f048350883e4561c313c846cdd223bcb1bc08e19d3203c8ff
-  data.tar.gz: 2b0cec21a13746667b3afaba2936f33928b8d9c368efd13a88312de8c54f2341
+  metadata.gz: 19db11fb7da5ef86006b94cc266336955175013164f4f631cf207c607d4286e8
+  data.tar.gz: fbe955d7730e10acafb3d288e577e2cfcdf065426543a573fe331427bcb414fc
 SHA512:
-  metadata.gz: 26e0c61e5539fd9b9691c62ec69bf942e79f08a2cc3d571a09ad337572c406637098ad0f86b50aaf5a40c138109c1898134c2a206cb09e1039c559a932c97b67
-  data.tar.gz: 47643cd5b5026e8e8edad9291d4528dc4739ffb1be2406713eb0b384f95e9bf39f0701540b74033067dbf8db77b24e5c02bcae8dbe639c956e77cbcaa35e3528
+  metadata.gz: 6af442178978f4528406e0ce3d219157cebbd75a70ca2575dadbf03ae58a87ce71d9e1285127422172e536620fad132951d73cd3b173112563bce7b50a5761c6
+  data.tar.gz: 56307ba25fe5b2d7d523ca9b3fba1908ec30443ce25547fcacc28361674f53bd9ef2ef6874957e4932cf66a62b3815e440a3c2f12ba069b42c00830bc67e096b

data/.rubocop.yml

@@ -30,3 +30,5 @@ Style/Documentation:
   Enabled: false
 Style/ExpandPathArguments:
   Enabled: false
+Style/PerlBackrefs:
+  Enabled: false

data/CHANGELOG.md

@@ -6,12 +6,66 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.0.2] - 2019-07-21
+### Added
+- Added Enumerable => `cluster_by`
+- Added Enumerable => `frequency`
+- Added Enumerable => `occur`
+- Added Enumerable => `squeeze`
+- Added Hash => `alias`
+- Added Hash => `collate`
+- Added Hash => `dearray_values`
+- Added Hash => `dearray_singular_values`
+- Added Hash => `delete_unless`
+- Added Hash => `delete_values`
+- Added Hash => `diff`
+- Added Hash => `insert`
+- Added Hash => `invert`
+- Added Hash => `keys?`
+- Added Hash => `only_keys?`
+- Added Hash => `update_each`
+- Added Hash => `update_keys`
+- Added Hash => `update_values`
+- Added Hash => `zip`
+- Added Integer => `bit`
+- Added Integer => `bit?`
+- Added Integer => `bit_clear`
+- Added Integer => `bitmask`
+- Added Integer => `bitmask?`
+- Added Numeric => `at_least?`
+- Added Numeric => `at_most?`
+- Added Numeric => `close?`
+- Added Numeric => `delimit`
+- Added Numeric => `delta`
+- Added Numeric => `range`
+- Added OpenStruct extensions
+- Added String => `ascii_only`
+- Added String => `capitalized?`
+- Added String => `each_word`
+- Added String => `encode_only`
+- Added String => `lchomp`
+- Added String => `methodize`
+- Added String => `modulize`
+- Added String => `pathize`
+- Added String => `quote`
+- Added String => `rotate`
+- Added String => `unquote`
+- Added String => `variablize`
+- Added String => `words`
+- Added String => `words_without_punctuation`
+- Added Struct => `[]`
+- Added Struct => `[]=`
+### Changed
+- Rename Time => `emperical => imperical`
+- Rename Enumerable => `multiply => produce`
+- Rename Enumerable => `divisible => quotient`
+
 ## [1.0.1] - 2019-07-12
 ### Added
 - Added String => `acronym`
 - Added Struct extensions
 - Added Time => `elapse`
-# Changed
+### Changed
 - Configuration
 
 ## [1.0.0] - 2019-07-12

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    lite-ruby (1.0.1)
+    lite-ruby (1.0.2)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -38,7 +38,7 @@ Or install it yourself as:
 ```ruby
 Lite::Ruby.configure do |config|
   config.monkey_patches = %w[
-    array date enumerable hash integer kernel numeric object range string struct time
+    array date enumerable hash integer kernel numeric object open_struct range string struct time
   ]
 end
 ```
@@ -53,6 +53,7 @@ end
 * [Kernel](https://github.com/drexed/lite-ruby/blob/master/docs/KERNEL.md)
 * [Numeric](https://github.com/drexed/lite-ruby/blob/master/docs/NUMERIC.md)
 * [Object](https://github.com/drexed/lite-ruby/blob/master/docs/OBJECT.md)
+* [Open Struct](https://github.com/drexed/lite-ruby/blob/master/docs/OPEN_STRUCT.md)
 * [Range](https://github.com/drexed/lite-ruby/blob/master/docs/RANGE.md)
 * [String](https://github.com/drexed/lite-ruby/blob/master/docs/STRING.md)
 * [Struct](https://github.com/drexed/lite-ruby/blob/master/docs/STRUCT.md)

data/docs/ARRAY.md

@@ -176,7 +176,7 @@ Converts blank values into `nil`.
 Generates a hash mapping each unique element in the array to the relative frequency, i.e. the probability, of it appearance.
 
 ```ruby
-[:a,:b,:c,:c].probability #=> { a: 0.25,b: 0.25,c: 0.5 }
+[:a,:b,:c,:c].probability #=> { a: 0.25, b: 0.25, c: 0.5 }
 ```
 
 `promote(!)`

data/docs/ENUMERABLE.md

@@ -5,27 +5,25 @@
 Groups together adjacent elements into a list of sub-arrays.
 
 ```ruby
-[2,2,2,3,3,4,2,2,1].cluster { |x| x } #=> [[2,2,2],[3,3],[4],[2,2],[1]]
+[2, 2, 2, 3, 3, 4, 2, 2, 1].cluster { |x| x } #=> [[2, 2, 2], [3, 3], [4], [2, 2], [1]]
 ```
 
-`deduce`
+`cluster_by`
 ------
-Returns the difference of a collection of numbers.
+Similar to `group_by` but returns an array of the groups.
 
 ```ruby
-[].deduce      #=> 0
-[].deduce(nil) #=> nil
-[1,2,3].deduce #=> -4
+%w[this is a test].cluster_by { |x| x[0] } #=> [['a'], ['is'], ['this', 'test']]
 ```
 
-`divisible`
+`deduce`
 ------
-Returns the division of a collection of numbers.
+Returns the difference of a collection of numbers.
 
 ```ruby
-[].divisible       #=> 0
-[].divisible(nil)  #=> nil
-[16,4,2].divisible #=> 2
+[].deduce      #=> 0
+[].deduce(nil) #=> nil
+[1,2,3].deduce #=> -4
 ```
 
 `drop_last`
@@ -94,6 +92,14 @@ Returns the exponential of a collection of numbers.
 [2,3,4].exponential #=> 4096
 ```
 
+`frequency` aka `occurrences`
+------
+Generates a hash mapping each unique symbol in the array to the absolute frequency it appears.
+
+```ruby
+%i[a a b c c c].frequency #=> { a: 2, b: 1, c: 3 }
+```
+
 `incase?`
 ------
 The same as `include?` but tested using `===` instead of `==`.
@@ -123,23 +129,36 @@ Returns if a collection has more than one element while respecting `nil` and `fa
 
 ```
 
-`multiple`
+`occur`
+------
+Returns an array of elements for the elements that occur n times.
+
+```ruby
+a1 = [1, 1, 2, 3, 3, 4, 5, 5]
+
+a1.occur(2)            #=> [1, 3, 5]
+a1.occur(2..3)         #=> [1, 3, 5]
+a1.occur { |n| n > 1 } #=> [1, 3, 5]
+```
+
+`produce`
 ------
 Returns the multiplication of a collection of numbers.
 
 ```ruby
-[].multiple      #=> 0
-[].multiple(nil) #=> nil
-[1,2,3].multiple #=> 6
+[].produce      #=> 0
+[].produce(nil) #=> nil
+[1,2,3].produce #=> 6
 ```
 
-`occurrences`
+`quotient`
 ------
-Returns a hash of the number of times a value appears in an array.
+Returns the division of a collection of numbers.
 
 ```ruby
-[].occurrences                               #=> {}
-[1,:symbol,'string',3,:symbol,1].occurrences #=> { 1 => 2,:symbol => 2,'string' => 1,3 => 1 }
+[].quotient       #=> 0
+[].quotient(nil)  #=> nil
+[16,4,2].quotient #=> 2
 ```
 
 `several?`
@@ -153,6 +172,18 @@ Returns if collection has more than one element while not respecting `nil` and `
 [1,1,3,3].several?(&:even?) #=> false
 ```
 
+`squeeze`
+------
+Squeeze out the same elements.
+
+```ruby
+a1 = [1, 2, 2, 3, 3, 2, 1]
+
+a1.squeeze      #=> [1, 2, 3, 2, 1]
+a1.sort.squeeze #=> [1, 2, 3]
+a1.squeeze(3)   #=> [1, 2, 2, 3, 2, 1]
+```
+
 `take_last`
 ------
 Returns the last number of elements of a collection.
@@ -160,7 +191,7 @@ Returns the last number of elements of a collection.
 ```ruby
 [].take_last(1)      #=> []
 [1,2,3].take_last(1) #=> [3]
-[1,2,3].take_last(2) #=> [2,3]
+[1,2,3].take_last(2) #=> [2, 3]
 ```
 
 `take_last_if`

data/docs/HASH.md

@@ -1,5 +1,24 @@
 # Hash
 
+`zip`
+------
+Creates a new hash from two separate arrays.
+
+```ruby
+Hash.zip(%i[a b c], [1, 2, 3]) #=> { a: 1, b: 2, c: 3 }
+```
+
+`alias`
+------
+Adds a key/value pair from an existing key/value pair.
+
+```ruby
+h1 = { foo: 'bar', baz: 'boo' }
+h1.alias('boo', :foo)
+
+h1['boo'] #=> 'bar'
+```
+
 `assert_valid_keys!`
 ------
 Raises an error if key is not included in a list of keys.
@@ -46,6 +65,14 @@ Updates a deeply nested value.
 { foo: { baz: 'boo' } }.bury(:foo)             #=> raises ArgumentError: '2 or more arguments required'
 ```
 
+`collate(!)`
+------
+Merge the values of this hash with those from another, setting all values to be arrays representing the values from both hashes.
+
+```ruby
+{ a: 1, b: 2 }.collate(a: 3, b: 4, c: 5) #=> { a: [1, 3], b: [2, 4], c: [5] }
+```
+
 `collect_keys`
 ------
 Returns an array with all keys converted using the block operation.
@@ -64,6 +91,27 @@ Returns an array with all values converted using the block operation.
 { foo: 'bar', baz: :boo }.collect_values { |k| k.to_s.upcase } #=> ['BAR', BOO']
 ```
 
+`dearray_values(!)`
+------
+Any array values will be replaced with the first element of the array and arrays with no elements will be set to `nil`.
+
+```ruby
+h1 = { a: [1], b: [1, 2], c: 3, d: [] }
+
+h1.dearray_values     #=> { a: 1, b: 1, c: 3, d: nil }
+h1.dearray_values!(1) #=> { a: 1, b: 2, c: 3, d: nil }
+```
+
+`dearray_singular_values(!)`
+------
+Any array values with one or no elements will be set to the element or `nil`.
+
+```ruby
+h1 = { a: [1], b: [1, 2], c: 3, d: [] }
+
+h1.dearray_singular_values #=> { a: 1, b: [1, 2], c: 3, d: nil }
+```
+
 `deep_merge(!)`
 ------
 Returns a new hash with self and other_hash merged recursively.
@@ -75,6 +123,28 @@ h2 = { a: false, b: { x: [3, 4, 5] } }
 h1.deep_merge(h2) #=> { a: false, b: { c: [1, 2, 3], x: [3, 4, 5] } }
 ```
 
+`delete_unless`
+------
+Inverse of `delete_if`.
+
+```ruby
+h1 = { a: 1, b: 2, c: 3 }
+h1.delete_unless { |_, v| v == 1 }
+
+h1 #=> { a: 1 }
+```
+
+`delete_values`
+------
+Delete key/value pairs by value.
+
+```ruby
+h1 = { a: 1, b: 2 }
+h1.delete_values(1)
+
+h1 #=> { b: 2 }
+```
+
 `demote(!)`
 ------
 Moves a key value pair to the tail of the hash.
@@ -93,6 +163,18 @@ Converts `nil` into a given value.
 { abc: nil, xyz: 1 }.denillify!(9) #=> { abc: 9, xyz: 1 }
 ```
 
+`diff`
+------
+Difference comparison of two hashes.
+
+```ruby
+h1 = { a: 1, b: 2 }
+h2 = { a: 1, b: 3 }
+
+h1.diff(h2) #=> { b: 2 }
+h2.diff(h1) #=> { b: 3 }
+```
+
 `except(!)`
 ------
 Returns a hash that includes everything but the given keys.
@@ -121,6 +203,38 @@ Returns a hash that is transformed in place.
 { a: 1, b: 2, c: 3 }.hmap { |k, v| { k => v + 3 } } #=> { a: 4, b: 5, c: 6 }
 ```
 
+`insert`
+------
+As with `store` but only if the key isn't already in the hash.
+
+```ruby
+h1 = { a: 1, b: 2 }
+
+h1.insert(:c, 3) #=> true
+h1.insert(:b, 3) #=> false
+```
+
+`invert`
+------
+Create an inverse hash by storing multiple values in arrays.
+
+```ruby
+h1 = { a: 3, b: 3, c: 3, d: 2, e: 9, f: 3, g: 9 }
+
+h1.invert #=> { 2 => :d, 3 => %i[f c b a], 9 => %i[g e] }
+```
+
+`keys?` aka `has_keys?`
+------
+Returns if hash contains the given keys.
+
+```ruby
+h1 = { a: 0, b: 1 }
+
+h1.keys?(:a, :b) #=> true
+h1.keys?(:z)     #=> false
+```
+
 `nillify(!)`
 ------
 Transforms all blank values to `nil`.
@@ -138,6 +252,17 @@ Returns only key value pairs matching certain keys and any missing one.
 { :foo => 1, baz: 2 }.only_fill(:foo, :bar, placeholder: 0) #=> { foo: 1, bar: 0 }
 ```
 
+`only_keys?` aka `has_only_keys?`
+------
+Returns if hash contains only the given keys.
+
+```ruby
+h1 = { a: 0, b: 1 }
+
+h1.only_keys?(:a, :b) #=> true
+h1.only_keys?(:a)     #=> false
+```
+
 `pair?`
 ------
 Returns if the hash has a key with a matching value.
@@ -271,6 +396,30 @@ Converts an object to have an object like API.
 { foo: { bar: true } }.to_object.foo.bar #=> true
 ```
 
+`update_each`
+------
+Iterate over hash updating the key/value pair.
+
+```ruby
+{ a: 1, b: 2 }.update_each { |k, v| { "#{k}!" => v + 1 } } #=> { 'a!' => 2, 'b!' => 3 }
+```
+
+`update_keys`
+------
+Iterate over hash updating just the keys.
+
+```ruby
+{ a: 1, b: 2 }.update_keys { |k| "#{k}!" } #=> { 'a!' => 1, 'b!' => 2 }
+```
+
+`update_values`
+------
+Iterate over hash updating just the values.
+
+```ruby
+{ a: 1, b: 2 }.update_values { |v| v + 1 } #=> { a: 2, b: 3 }
+```
+
 `vacant?`
 ------
 Returns if the value of a key is blank?.

data/docs/INTEGER.md

@@ -1,5 +1,50 @@
 # Integer
 
+`bit`
+------
+Calculates the bit of an integer.
+
+```ruby
+0.bit(4)       #=> 16
+10.bit(-4)     #=> 2
+0b0100.bit(-3) #=> 0
+```
+
+`bit?`
+------
+Returns if it is a bit set.
+
+```ruby
+8.bit?(3) #=> true
+8.bit?(2) #=> false
+```
+
+`bit_clear`
+------
+Clears a bit.
+
+```ruby
+4.bit_clear(2) #=> 0
+```
+
+`bitmask`
+------
+Calculates a bitmask of an integer.
+
+```ruby
+1.bitmask(6)  #=> 7
+7.bitmask(~2) #=> 5
+```
+
+`bitmask?`
+------
+Returns if it is a bitmask set.
+
+```ruby
+8.bitmask?(3) #=> true
+8.bitmask?(2) #=> false
+```
+
 `factorial`
 ------
 Calculates the factorial of an integer.