lite-ruby 1.0.1 → 1.0.2

data/docs/NUMERIC.md

@@ -18,6 +18,14 @@ Returns the closest number outside of the lower and upper bound.
 8.clamp(3, 6) # => 6
 ```
 
+`close?`
+------
+Returns if a number is within the degree of another.
+
+```ruby
+10.006.close?(10, 0.1) #=> true
+```
+
 `decrement`
 ------
 Returns the n decremented number.
@@ -27,13 +35,31 @@ Returns the n decremented number.
 1.decrement(0.5) #=> 0.5
 ```
 
-`distance`
+`delta`
 ------
 Returns the absolute difference between numbers.
 
+```ruby
+5.delta(3) #=> 2
+3.delta(5) #=> 2
+```
+
+`delimit`
+------
+Returns a string representation of the number.
+
+```ruby
+5.delimit                                 #=> "1,000,000.1234"
+3.delimit(delimiter: '.', separator: ',') #=> "1.000.000,1234"
+```
+
+`distance`
+------
+Returns the difference between numbers.
+
 ```ruby
 5.distance(3) #=> 2
-3.distance(5) #=> 2
+3.distance(5) #=> -2
 ```
 
 `divide`
@@ -234,6 +260,14 @@ Returns the nth power of a number.
 4.power(2) #=> 16
 ```
 
+`range` aka `plus_minus`
+------
+Returns a range from the number plus-or-minus a given value.
+
+```ruby
+4.range(2) #=> 2..6
+```
+
 `root`
 ------
 Returns the nth root of a number.

data/docs/OPEN_STRUCT.md

@@ -0,0 +1,51 @@
+# OpenStruct
+
+`Initialize`
+Allows the initialization of an OpenStruct with a setter block.
+
+```ruby
+OpenStruct.new(name: 'bob', age: 60) do |o|
+  o.gender = :M
+end
+```
+
+`[]`
+------
+Access a value in the OpenStruct by key, like a Hash.
+
+```ruby
+person = OpenStruct.new(name: 'bob', age: 60)
+
+person['name'] #=> 'bob'
+```
+
+`[]=`
+------
+Store a value in the OpenStruct by key, like a Hash.
+
+```ruby
+person = OpenStruct.new(name: 'bob', age: 60)
+
+person['name'] = 'tim'
+```
+
+`attributes`
+------
+Returns the key values of the assigned struct.
+
+```ruby
+person = OpenStruct.new(name: 'bob', age: 60)
+
+person.attributes #=> { name: 'bob', age: 60 }
+```
+
+`replace`
+------
+Replaces values provided within the hash.
+
+```ruby
+person = OpenStruct.new(name: 'bob', age: 60)
+
+person.replace(name: 'tom', age: 28)
+preson.name #=> 'tom'
+```

data/docs/STRING.md

@@ -17,6 +17,15 @@ Returns if a string includes a set of string(s).
 'example string'.any?('foo', 'string') #=> true
 ```
 
+`ascii_only(!)`
+------
+Replace non-ascii characters.
+
+```ruby
+'中文123'.ascii_only       #=> '123'
+'中文123'.ascii_only!('x') #=> 'xx123'
+```
+
 `at`
 ------
 Returns the characters at index position, matching string, or regex.
@@ -41,6 +50,17 @@ Transforms a string to camelcase.
 'example_String'.camecase(:lower) #=> 'exampleString'
 ```
 
+`capitalized?`
+------
+Returns true if the first character is capitalized.
+
+```ruby
+'Example string'.capitalized? #=> true
+'EXAMPLE STRING'.capitalized? #=> false
+'example string'.capitalized? #=> false
+'Example String'.capitalized? #=> false
+```
+
 `classify(!)`
 ------
 Transforms a string to a class name like Rails does for table names to models.
@@ -107,6 +127,23 @@ Returns true if all characters are lowercase.
 'EXAMPLE'.downcase? #=> false
 ```
 
+`each_word`
+------
+Splits a string into multiple words and yields its enumeration.
+
+```ruby
+'abc. 123'.each_word(&:campitalize!) #=> ['Abc.', '123']
+```
+
+`encode_only(!)`
+------
+Replace non-encode characters.
+
+```ruby
+'中文123'.encode_only('UTF-8')       #=> '123'
+'中文123'.encode_only!('ASCII', 'x') #=> 'xx123'
+```
+
 `ellipsize`
 ------
 Truncate a string in the middle.
@@ -217,6 +254,32 @@ than or equal to the string length, Returns a copy of self.
 'example'.first(3) #=> 'ple'
 ```
 
+`lchomp(!)`
+------
+Left chomp.
+
+```ruby
+'example'.lchomp('e')  #=> 'xample'
+'example'.lchomp!('z') #=> 'example'
+```
+
+`methodize(!)`
+------
+Translate a class or module name to a suitable method name.
+
+```ruby
+'Example::ClassString'.methodize #=> 'example__class_string'
+```
+
+`modulize(!)`
+------
+Converts a string to module name representation.
+
+```ruby
+'example_string'.modulize  #=> 'ExampleString'
+'example/string'.modulize! #=> 'Example::String'
+```
+
 `mixcase?`
 ------
 Returns true if characters are mixedcase.
@@ -258,6 +321,14 @@ Makes a string suitable for a dashed url parameter string.
 'example_string'.parameterize(separator: '?') #=> 'example?string'
 ```
 
+`pathize(!)`
+------
+Transforms a string to a suitable file path.
+
+```ruby
+'ExamplePathize::Example'.pathize! #=> 'example_string/class'
+```
+
 `pollute(!)`
 ------
 Pollutes the space between every letter in a string, so it will be exempt from any impending string searches.
@@ -283,6 +354,16 @@ Concats string to self.
 'test'.push('er') #=> 'tester'
 ```
 
+`quote(!)`
+------
+Adds a given quote type to the string.
+
+```ruby
+'example'.quote            #=> '"example"'
+'example'.quote!(1)        #=> "'example'"
+'example'.quote(:backtick) #=> '`example`'
+```
+
 `remove(!)`
 ------
 Removes every instance of a string.
@@ -304,6 +385,15 @@ Removes HTML tags from a string.
 'this is <b>bold</b> and <em>emphatic</em>'.remove_tags #=> 'this is bold and emphatic'
 ```
 
+`rotate(!)`
+------
+Rotate string to the left with count.
+
+```ruby
+'example'.rotate    #=> 'xamplee'
+'example'.rotate(2) #=> 'ampleex'
+```
+
 `sample(!)`
 ------
 Removes a random value and returns that value.
@@ -432,7 +522,7 @@ separator | string | ' '
 'And they found that many people were sleeping better.'.truncate_words(5, omission: '... (continued)') #=> 'And they found that many... (continued)'
 ```
 
-`underscore(!)`
+`underscore(!)` aka `snakecase(!)`
 ------
 Transforms a string to snake case.
 
@@ -469,3 +559,35 @@ Prepends string(s) to self.
 'this thing that thing'.unshift('thing ')         #=> 'thing this thing that thing'
 'this thing that thing'.unshift('this ', 'that ') #=> 'this that this thing that thing'
 ```
+
+`unquote(!)`
+------
+Removes any quote types from a given string.
+
+```ruby
+'`example`'.unquote #=> 'example'
+```
+
+`variablize(!)`
+------
+Prepend an "@" to the beginning of a string and replace non-valid characters with underscores.
+
+```ruby
+'example String'.variablize #=> '@example_String'
+```
+
+`words`
+------
+Splits a string into multiple words split by spaces.
+
+```ruby
+'abc. 123'.words #=> ['abc.', '123']
+```
+
+`words_without_punctuation`
+------
+Splits a string into multiple words without punctuation split by spaces.
+
+```ruby
+'Slowly, grudgingly he said: "This has to stop."'.words_without_punctuation #=> ['Slowly', 'grudgingly', 'he', 'said', 'This', 'has', 'to', 'stop']
+```

data/docs/STRUCT.md

@@ -1,5 +1,29 @@
 # Struct
 
+`[]`
+------
+Access a value in the Struct by key, like a Hash.
+
+```ruby
+person = Struct.new(:name, :age)
+person.new('bob', 60)
+
+person['name'] #=> 'bob'
+```
+
+`[]=`
+------
+Store a value in the Struct by key, like a Hash.
+
+```ruby
+person = Struct.new(:name, :age)
+person.new('bob', 60)
+
+person['name'] = 'tim'
+
+person['name'] #=> 'tim'
+```
+
 `attributes`
 ------
 Returns the key values of the assigned struct.

data/lib/generators/lite/ruby/templates/install.rb

@@ -2,6 +2,6 @@
 
 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

data/lib/lite/ruby/configuration.rb

@@ -9,7 +9,8 @@ module Lite
 
       def initialize
         @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
 

data/lib/lite/ruby/enumerable.rb

@@ -14,19 +14,15 @@ module Enumerable
     end
   end
 
-  def deduce(identity = 0, &block)
-    if block_given?
-      map(&block).deduce(identity)
-    else
-      inject { |key, val| key - val } || identity
-    end
+  def cluster_by(&block)
+    group_by(&block).sort.transpose.pop || []
   end
 
-  def divisible(identity = 0, &block)
+  def deduce(identity = 0, &block)
     if block_given?
-      map(&block).divisible(identity)
+      map(&block).deduce(identity)
     else
-      inject { |key, val| key / val } || identity
+      inject { |acc, val| acc - val } || identity
     end
   end
 
@@ -76,10 +72,16 @@ module Enumerable
     if block_given?
       map(&block).exponential(identity)
     else
-      inject { |key, val| key**val } || identity
+      inject { |acc, val| acc**val } || identity
     end
   end
 
+  def frequency
+    each_with_object(Hash.new(0)) { |val, hash| hash[val] += 1 }
+  end
+
+  alias occurrences frequency
+
   # rubocop:disable Style/CaseEquality
   def incase?(object)
     any? { |val| object === val }
@@ -125,16 +127,57 @@ module Enumerable
     end
   end
 
-  def multiple(identity = 0, &block)
+  def modulate(modulo)
+    if modulo == 1
+      to_a
+    elsif size % modulo != 0
+      raise ArgumentError, "Invalid modulo: #{modulo.inspect}"
+    else
+      (0...size).each_with_object(Array.new(modulo, [])) do |i, array|
+        array[i % modulo] += [self[i]]
+      end
+    end
+  end
+
+  # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+  def occur(amount = nil)
+    result = Hash.new { |hash, key| hash[key] = [] }
+
+    each do |item|
+      key = item
+      result[key] << item
+    end
+
+    if block_given?
+      result.select! { |_key, values| yield(values.size) }
+    else
+      raise ArgumentError, 'Invalid occur amount' unless amount
+
+      if amount.is_a?(Range)
+        result.select! { |_key, values| amount.include?(values.size) }
+      else
+        result.select! { |_key, values| values.size == amount }
+      end
+    end
+
+    result.values.flatten.uniq
+  end
+  # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+  def produce(identity = 0, &block)
     if block_given?
-      map(&block).multiple(identity)
+      map(&block).produce(identity)
     else
-      inject { |key, val| key * val } || identity
+      inject { |acc, val| acc * val } || identity
     end
   end
 
-  def occurrences
-    each_with_object(Hash.new(0)) { |key, hsh| hsh[key] += 1 }
+  def quotient(identity = 0, &block)
+    if block_given?
+      map(&block).quotient(identity)
+    else
+      inject { |acc, val| acc / val } || identity
+    end
   end
 
   def several?
@@ -149,6 +192,23 @@ module Enumerable
     found_count > 1
   end
 
+  # rubocop:disable Metrics/MethodLength
+  def squeeze(*limited_to)
+    first = true
+    current = nil
+
+    each_with_object([]) do |val, array|
+      if !limited_to.empty? && !limited_to.include?(val)
+        array << val
+      elsif first || current != val
+        array << val
+        first = false
+        current = val
+      end
+    end
+  end
+  # rubocop:enable Metrics/MethodLength
+
   def take_last(num)
     collection_size = to_a.size
     return self if num > collection_size