lite-ruby 1.0.0

data/docs/HASH.md

@@ -0,0 +1,282 @@
+# Hash
+
+`assert_valid_keys!`
+------
+Raises an error if key is not included in a list of keys.
+
+```ruby
+{}.assert_valid_keys(:foo)                   #=> {}
+{ foo: 'bar' }.assert_valid_keys(:foo)       #=> { foo: 'bar' }
+{ baz: 'boz' }.assert_valid_keys(:foo, :boo) #=> raises ArgumentError: 'Invalid key: ":baz". Allowed keys are: ":foo", ":boo"'
+```
+
+`assert_all_valid_keys!`
+------
+Raises like an error like `assert_valid_values!` but also on empty.
+
+```ruby
+{}.assert_all_valid_keys!(:foo) #=> raises ArgumentError: 'An empty hash is not allowed'
+```
+
+`assert_valid_values!`
+------
+Raises an error if value is not included in a list of values.
+
+```ruby
+{}.assert_valid_values(:foo)                   #=> {}
+{ foo: 'bar' }.assert_valid_values('bar')      #=> { foo: 'bar' }
+{ baz: 'boz' }.assert_valid_values(:foo, :boo) #=> raises ArgumentError: 'Invalid value: "boz". Allowed values are: ":foo", ":boo"'
+```
+
+`assert_all_valid_values!`
+------
+Raises like an error like `assert_valid_values!` but also on empty.
+
+```ruby
+{}.assert_all_valid_values!(:foo) #=> raises ArgumentError: 'An empty hash is not allowed'
+```
+
+`bury`
+------
+Updates a deeply nested value.
+
+```ruby
+{ foo: { baz: 'boo' } }.bury(:foo, :moo)       #=> { foo: :moo }
+{ foo: { baz: 'boo' } }.bury(:foo, :baz, :moo) #=> { foo: { baz: :moo } }
+{ foo: { baz: 'boo' } }.bury(:foo)             #=> raises ArgumentError: '2 or more arguments required'
+```
+
+`collect_keys`
+------
+Returns an array with all keys converted using the block operation.
+
+```ruby
+{ foo: 'bar', 'baz' => :boo }.collect_keys                       #=> [:foo, 'baz']
+{ foo: 'bar', 'baz' => :boo }.collect_keys { |k| k.to_s.upcase } #=> ['FOO', BAZ']
+```
+
+`collect_values`
+------
+Returns an array with all values converted using the block operation.
+
+```ruby
+{ foo: 'bar', baz: :boo }.collect_values                       #=> ['bar', :boo]
+{ foo: 'bar', baz: :boo }.collect_values { |k| k.to_s.upcase } #=> ['BAR', BOO']
+```
+
+`deep_merge(!)`
+------
+Returns a new hash with self and other_hash merged recursively.
+
+```ruby
+h1 = { a: true, b: { c: [1, 2, 3] } }
+h2 = { a: false, b: { x: [3, 4, 5] } }
+
+h1.deep_merge(h2) #=> { a: false, b: { c: [1, 2, 3], x: [3, 4, 5] } }
+```
+
+`demote(!)`
+------
+Moves a key value pair to the tail of the hash.
+
+```ruby
+{ a: 0, b: 1, c: 2 }.demote(:b)  #=> { a: 0, c: 2, b: 1 }
+{ a: 0, b: 1, c: 2 }.demote!(:d) #=> { a: 0, b: 1, c: 2 }
+```
+
+`denillify(!)`
+------
+Converts `nil` into a given value.
+
+```ruby
+{ abc: nil, xyz: 1 }.denillify     #=> { abc: 0, xyz: 1 }
+{ abc: nil, xyz: 1 }.denillify!(9) #=> { abc: 9, xyz: 1 }
+```
+
+`except(!)`
+------
+Returns a hash that includes everything but the given keys.
+
+```ruby
+{}.except(:foo)                                                    #=> {}
+{ foo: 'foo', baz: 'baz', bar: 'bar' }.except(:foo)                #=> { baz: 'baz', bar: 'bar' }
+{ :foo => 'foo', :baz => 'baz', :bar => 'bar' }.except(:baz, :bar) #=> { :foo => 'foo' }
+```
+
+`extract!`
+------
+Removes and returns the key value pairs matching the given keys.
+
+```ruby
+{}.extract!(:foo)                                     #=> {}
+{ foo: 'foo', baz: 'baz', bar: 'bar' }.extract!(:foo) #=> { foo: 'foo' }
+
+```
+
+`hmap(!)`
+------
+Returns a hash that is transformed in place.
+
+```ruby
+{ a: 1, b: 2, c: 3 }.hmap { |k, v| { k => v + 3 } } #=> { a: 4, b: 5, c: 6 }
+```
+
+`nillify(!)`
+------
+Transforms all blank values to `nil`.
+
+```ruby
+{ a: 1, b: 'test', c: nil, d: false, e: '', f: ' ' }.nillify #=> {a: 1, b: 'test', c: nil, d: nil, e: nil, f: nil}
+```
+
+`only_fill(!)`
+------
+Returns only key value pairs matching certain keys and any missing one.
+
+```ruby
+{}.only_fill(:foo)                                          #=> { foo: nil }
+{ :foo => 1, baz: 2 }.only_fill(:foo, :bar, placeholder: 0) #=> { foo: 1, bar: 0 }
+```
+
+`pair?`
+------
+Returns if the hash has a key with a matching value.
+
+```ruby
+{ a: 0 }.pair?(:a, 0) #=> true
+{ a: 0 }.pair?(:a, 2) #=> false
+```
+
+`promote(!)`
+------
+Moves a key value pair to the head of the hash.
+
+```ruby
+{ a: 0, b: 1, c: 2 }.promote(:b)  #=> { b: 1, a: 0, c: 2 }
+{ a: 0, b: 1, c: 2 }.promote!(:d) #=> { a: 0, b: 1, c: 2 }
+```
+
+`rename_keys(!)`
+------
+Rename the keys of a hash.
+
+```ruby
+{ foo: 'foo', baz: 'baz' }.rename_keys(foo: :bar)                      #=> { bar: 'foo', baz: 'baz' }
+{ foo: 'foo', 'baz' => 'baz' }.rename_keys(foo: :bar, 'baz' => 'tick') #=> { bar: 'foo', tick: 'baz' }
+```
+
+`reverse_merge(!)`
+------
+Merges one hash into other hash (merge but in reverse).
+
+```ruby
+{}.reverse_merge!(foo: 'bar')                         #=> { foo: 'bar' }
+{ foo: 'bar' }.reverse_merge!(baz: 'boo', boo: 'bam') #=> { foo: 'bar', baz: 'boo', boo: 'bam' }
+```
+
+`sample(!)`
+------
+Returns a random key-value pair.
+
+```ruby
+h = { a: 1, b: 2, c: 3, d: 4 }
+
+h.sample  #=> [:c, 3]
+h.sample! #=> [:a, 1]
+```
+
+`sample_key(!)`
+------
+Returns a random key.
+
+```ruby
+h = { a: 1, b: 2, c: 3, d: 4 }
+
+h.sample_key  #=> :b
+h.sample_key! #=> :d
+```
+
+`sample_value(!)`
+------
+Returns a random value.
+
+```ruby
+h = { a: 1, b: 2, c: 3, d: 4 }
+
+h.sample_value  #=> 1
+h.sample_value! #=> 3
+```
+
+`shuffle(!)`
+------
+Returns a hash with values arranged in new random order.
+
+```ruby
+h = { a: 1, b: 2, c: 3, d: 4 }
+
+h.shuffle  #=> { b: 2, c: 3, a: 1, d: 4 }
+h.shuffle! #=> { d: 4, b: 2, c: 3, a: 1 }
+```
+
+`slice(!)` aka `only(!)`
+------
+Returns a hash that includes only the given keys.
+
+```ruby
+h = { a: 1, b: 2, c: 3, d: 4 }
+
+h.slice(:a, :b)  #=> { a: 1, b: 2 }
+h.slice!(:a, :b) #=> { a: 1, b: 2 }
+```
+
+`stringify_keys(!)`
+------
+Converts the hash keys to strings.
+
+```ruby
+{ foo: 'foo', 'bar' => 'bar' }.stringify_keys #=> { 'foo' => 'foo', 'baz' => 'baz' }
+```
+
+`strip(!)`
+------
+Returns a hash with non `nil`, `false`, or blank values.
+
+```ruby
+{}.strip                                                      #=> {}
+{ foo: nil, baz: false, boo: '', faz: ' ' }.strip             #=> {}
+{ foo: 'bar', baz: false, boo: nil, boz: '', faz: ' ' }.strip #=> { foo: 'bar' }
+```
+
+`symbolize_keys(!)`
+------
+Converts the hash keys to symbols.
+
+```ruby
+{ foo: 'foo', 'bar' => 'bar' }.symbolize_keys #=> { foo: 'foo', baz: 'baz' }
+```
+
+`symbolize_and_underscore_keys(!)`
+------
+Symbolize and underscore hash keys.
+
+```ruby
+{ 'firstName' => 'foo', 'last Name' => 'test' }.symbolize_and_underscore_keys #=> { first_name: 'foo', last_name: 'test' }
+```
+
+`to_object` aka `to_o`
+------
+Converts an object to have an object like API.
+
+```ruby
+{ foo: { bar: true } }.to_object.foo.bar #=> true
+```
+
+`vacant?`
+------
+Returns if the value of a key is blank?.
+
+```ruby
+{}.vacant?(:foo)             #=> true
+{ foo: ' ' }.vacant?(:foo)   #=> true
+{ foo: 'bar' }.vacant?(:foo) #=> false
+```

data/docs/INTEGER.md

@@ -0,0 +1,43 @@
+# Integer
+
+`factorial`
+------
+Calculates the factorial of an integer.
+
+```ruby
+4.factorial #=> 24
+```
+
+`factors`
+------
+Calculates all the factors of an integer.
+
+```ruby
+24.factors #=> [1, 24, 2, 12, 3, 8, 4, 6]
+```
+
+`of`
+------
+Like `times` but returns a collection of the yield results.
+
+```ruby
+3.of { |i| i + 1 } #=> ['1', '2', '3']
+```
+
+`roman_numeral`
+------
+Converts an integer to a roman_numeral numeral.
+
+```ruby
+0.roman_numeral   #=> ''
+49.roman_numeral  #=> 'XLIX'
+-49.roman_numeral #=> '-XLIX'
+```
+
+`to_time` aka `to_t`
+------
+Returns a Time object for the given Integer.
+
+```ruby
+3.to_time #=> '1969-12-31 19:00:03.000000000 -0500'
+```

data/docs/KERNEL.md

@@ -0,0 +1,31 @@
+# Kernel
+
+`caller_name`
+------
+Returns the name of the method calling it.
+
+```ruby
+def sample_key
+  caller_name(0)
+end
+
+sample_key #=> 'sample_key'
+```
+
+`safe_eval`
+------
+Try's to evaluate or returns self.
+
+```ruby
+'[1,2,3]'.safe_eval  #=> [1,2,3]
+'[#1,2,3]'.safe_eval #=> '[#1,2,3]'
+```
+
+`try_eval`
+------
+Try's to evaluate or returns nil.
+
+```ruby
+'[1,2,3]'.try_eval  #=> [1,2,3]
+'[#1,2,3]'.try_eval #=> nil
+```

data/docs/NUMERIC.md

@@ -0,0 +1,302 @@
+# Numeric
+
+`add`
+------
+Returns the sum of two numbers.
+
+```ruby
+4.add(2) #=> 6
+```
+
+`clamp`
+------
+Returns the closest number outside of the lower and upper bound.
+
+```ruby
+1.clamp(3, 6) # => 3
+5.clamp(3..6) # => 5
+8.clamp(3, 6) # => 6
+```
+
+`decrement`
+------
+Returns the n decremented number.
+
+```ruby
+1.decrement      #=> 0
+1.decrement(0.5) #=> 0.5
+```
+
+`distance`
+------
+Returns the absolute difference between numbers.
+
+```ruby
+5.distance(3) #=> 2
+3.distance(5) #=> 2
+```
+
+`divide`
+------
+Returns the division of two numbers.
+
+```ruby
+4.divide(2) #=> 2
+0.divide(2) #=> 0
+4.divide(0) #=> 0
+```
+
+`equal_to?` aka `eq?`
+------
+Returns if matching equality using `==`.
+
+```ruby
+3.equal_to?(2) #=> false
+3.equal_to?(3) #=> true
+```
+
+`fraction`
+------
+Returns the numbers after '.' of a float.
+
+```ruby
+1.0.fraction      #=> 0.0
+12.2456.fraction  #=> 0.2456
+-12.2456.fraction #=> 0.2456
+```
+
+`fraction?`
+------
+Returns if its a fraction.
+
+```ruby
+1.0.fraction?      #=> false
+12.2456.fraction?  #=> true
+```
+
+`greater_than?` aka `gt?`
+------
+Returns if self is greater than n.
+
+```ruby
+3.greater_than?(2) #=> true
+3.greater_than?(3) #=> false
+3.greater_than?(4) #=> false
+```
+
+`greater_than_or_equal_to?` aka `gteq?`
+------
+Returns if self is greater than or equal to n.
+
+```ruby
+3.greater_than_or_equal_to?(2) #=> true
+3.greater_than_or_equal_to?(3) #=> true
+3.greater_than_or_equal_to?(4) #=> false
+```
+
+`increment`
+------
+Returns the n incremented number.
+
+```ruby
+1.increment      #=> 2
+1.increment(0.5) #=> 1.5
+```
+
+`inside?`
+------
+Returns if n is greater than start and less than finish.
+Similar to between but does not return true if equal to self.
+
+```ruby
+3.inside?(1, 5) #=> true
+3.inside?(3, 5) #=> false
+```
+
+`less_than?` aka `lt?`
+------
+Returns if self is less than n.
+
+```ruby
+3.less_than?(2) #=> false
+3.less_than?(3) #=> false
+3.less_than?(4) #=> true
+```
+
+`less_than_or_equal_to?` aka `lteq?`
+------
+Returns if self is less than or equal to n.
+
+```ruby
+3.less_than_or_equal_to?(2) #=> false
+3.less_than_or_equal_to?(3) #=> true
+3.less_than_or_equal_to?(4) #=> true
+```
+
+`multiply`
+------
+Returns the multiplication of two numbers.
+
+```ruby
+4.multiply(2) #=> 8
+```
+
+`multiple_of?`
+------
+Returns if a number can be evenly divided by n.
+
+```ruby
+9.multiple_of?(3) #=> true
+7.multiple_of?(3) #=> false
+```
+
+`not_equal_to?` aka `not_eq?` aka `inequal_to?` aka `ineq?`
+------
+Returns if not matching equality using `!=`.
+
+```ruby
+3.not_equal_to?(2) #=> true
+3.not_equal_to?(3) #=> false
+```
+
+`ordinal`
+------
+Returns the suffix that should be added to a number to denote the position in an ordered sequence such as 1st, 2nd, 3rd, 4th.
+
+```ruby
+'1'.ordinal  #=> 'th'
+'2'.ordinal  #=> 'nd'
+'3'.ordinal  #=> 'rd'
+'11'.ordinal #=> 'th'
+```
+
+`ordinalize`
+------
+transforms a number into an ordinal string used to denote the position in an ordered sequence such as 1st, 2nd, 3rd, 4th.
+
+```ruby
+'1'.ordinalize  #=> '1th'
+'2'.ordinalize  #=> '2nd'
+'3'.ordinalize  #=> '3rd'
+'11'.ordinalize #=> '4th'
+```
+
+`outside?`
+------
+Returns if n is less than start or greater than finish.
+
+```ruby
+3.outside?(4, 5) #=> true
+3.outside?(3, 5) #=> false
+```
+
+`pad`
+------
+Returns a string representation of the number padded with pad_num to a specified length.
+
+```ruby
+3.pad                #=> '003'
+3.pad(pad_number: 1) #=> '113'
+3.pad(precision: 4)  #=> '0003'
+```
+
+`pad_precision`
+------
+Returns a string of padded after the '.' to n amount.
+
+Option | Type | Default
+--- | --- | ---
+pad_number | integer | 0
+precision | integer | 2
+separator | string | '...'
+
+```ruby
+3.pad_precision                #=> '3.00'
+3.5.pad_precision              #=> '3.50'
+3.pad_precision(pad_number: 1) #=> '3.11'
+```
+
+`percentage_of`
+------
+Returns the percentage of a number in relation to another number.
+
+```ruby
+0.percentage_of(4) #=> 0
+2.percentage_of(0) #=> 0
+2.percentage_of(4) #=> 50.0
+```
+
+`power`
+------
+Returns the nth power of a number.
+
+```ruby
+4.power(2) #=> 16
+```
+
+`root`
+------
+Returns the nth root of a number.
+
+```ruby
+4.root(2) #=> 2
+```
+
+`subtract`
+------
+Returns the difference of two numbers.
+
+```ruby
+4.subtract(2) #=> 2
+```
+
+`to_currency`
+------
+Converts a number to currency string.
+
+Option | Type | Default
+--- | --- | ---
+precision | integer | 2
+unit | string | '$'
+
+```ruby
+3.to_currency            #=> '$3.00'
+3.1.to_currency          #=> '$3.10'
+3.11.to_currency         #=> '$3.11'
+3.11111.to_currency      #=> '$3.11'
+3.to_currency(unit: '@') #=> '@3.00'
+```
+
+`to_nearest value`
+------
+return the value in values that is nearest to the number.
+
+```ruby
+5.to_nearest_value([1, 3, 6, 9])           #=> 6
+3.5.to_nearest_value([3.0, 3.3, 3.6, 3.9]) #=> 3.6
+```
+
+`to_percentage`
+------
+Converts a number to percentage string.
+
+Option | Type | Default
+--- | --- | ---
+precision | integer | 2
+unit | string | '%'
+
+```ruby
+3.to_percentage            #=> '3.00%'
+3.1.to_percentage          #=> '3.10%'
+3.11.to_percentage         #=> '3.11%'
+3.11111.to_percentage      #=> '3.11%'
+3.to_percentage(unit: '@') #=> '3.00@'
+```
+
+`within?`
+------
+Returns if another number is approximately equal within a given epsilon
+
+```ruby
+10.006.within?(10, 0.1) #=>  true
+```