lite-ruby 1.0.0

data/_config.yml

@@ -0,0 +1 @@
+theme: jekyll-theme-leap-day

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'lite/ruby'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/docs/ARRAY.md

@@ -0,0 +1,284 @@
+# Array
+
+`assert_valid_values!`
+------
+Raises an error if key is not included in a list of values.
+
+```ruby
+{}.assert_valid_values!(:foo)                   #=> {}
+{ foo: 'bar' }.assert_valid_values!(:foo)       #=> { foo: 'bar' }
+{ baz: 'boz' }.assert_valid_values!(:foo, :boo) #=> raises ArgumentError: 'Invalid value: ":baz". 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 array is not allowed'
+```
+
+`after`
+------
+Returns the value after a given value.
+
+```ruby
+['1', '2', '3'].after('2') #=> '3'
+['1', '2', '3'].after('3') #=> '1'
+['1', '2', '3'].after('4') #=> nil
+```
+
+`bury`
+------
+Updates a deeply nested value.
+
+```ruby
+['1', ['2']].bury(1, '3')    #=> ['1', '3']
+['1', ['2']].bury(1, 0, '3') #=> ['1', ['3']]
+['1', ['2']].bury(1)         #=> raises ArgumentError: '2 or more arguments required'
+```
+
+`before`
+------
+Returns the value before a given value.
+
+```ruby
+['1', '2', '3'].before('2') #=> '1'
+['1', '2', '3'].before('1') #=> '3'
+['1', '2', '3'].before('4') #=> nil
+```
+
+`delete_first(!)`
+------
+Removes the first element from an array. Like `shift`, but returns the array instead of the removed element.
+
+```ruby
+['1', '2', '3'].delete_first #=> ['2', '3']
+```
+
+`delete_last(!)`
+------
+Removes the last element from an array. Like `pop`, but returns the array instead of the removed element.
+
+```ruby
+['1', '2', '3'].delete_last #=> ['1', '2']
+```
+
+`delete_values`
+------
+Delete multiple values from array.
+
+```ruby
+[1, 2, 3, 4].delete_values(1, 3) #=> [2, 4]
+```
+
+`demote(!)`
+------
+Moves a given value to the tail of array.
+
+```ruby
+[1, 2, 2, 3].demote(2)  #=> [1, 3, 2, 2]
+[1, 2, 2, 3].demote!(4) #=> [1, 2, 2, 3]
+```
+
+`denillify(!)`
+------
+Converts `nil` into a given value.
+
+```ruby
+[nil, 3, 4].denillify     #=> [0, 3, 4]
+[nil, 3, 4].denillify!(9) #=> [9, 3, 4]
+```
+
+`duplicates`
+------
+Returns a list of duplicate elements.
+
+```ruby
+[1, 1, 2, 2, 2, 3].duplicates    #=> [1, 2]
+[1, 1, 2, 2, 2, 3].duplicates(3) #=> [2]
+```
+
+`from`
+------
+Returns the tail of the array from a given position.
+
+```ruby
+['1', '2', '3'].from(0)  #=> ['1', '2', '3']
+['1', '2', '3'].from(1)  #=> ['2', '3']
+['1', '2', '3'].from(-1) #=> ['3']
+```
+
+`fulfill`
+------
+Returns an array filled to given size.
+
+```ruby
+['1', '2'].fulfill('x', 4) #=> ['1', '2', 'x', 'x']
+```
+
+`groups`
+------
+Splits or iterates over the array to a given number of groups.
+
+```ruby
+%w(1 2 3 4 5 6 7 8 9 10).groups(3) #=> [['1', '2', '3', '4'], ['5', '6', '7'], ['8', '9', '10']]
+```
+
+`in_groups`
+------
+Splits or iterates over the array to a given number of groups, padding any remaining slots with filler unless it is `false`.
+
+```ruby
+%w(1 2 3 4 5 6 7 8 9 10).in_groups(3)           #=> [['1', '2', '3', '4'], ['5', '6', '7', nil], ['8', '9', '10', nil]]
+%w(1 2 3 4 5 6 7 8 9 10).in_groups(3, ' ') #=> [['1', '2', '3', '4'], ['5', '6', '7', ' '], ['8', '9', '10', ' ']]
+%w(1 2 3 4 5 6 7 8 9 10).in_groups(3, false)    #=> [['1', '2', '3', '4'], ['5', '6', '7'], ['8', '9', '10']]
+```
+
+`in_groups_of`
+------
+Splits or iterates over the array in groups of a given size number, padding any remaining slots with filler unless it is `false`.
+
+```ruby
+%w(1 2 3 4 5 6 7 8 9 10).in_groups_of(3)           #=> [['1', '2', '3'], ['4', '5', '6'], ['7', '8', '9'], ['10', nil, nil]]
+%w(1 2 3 4 5 6 7 8 9 10).in_groups_of(3, ' ') #=> [['1', '2', '3'], ['4', '5', '6'], ['7', '8', '9'], ['10', ' ', ' ']]
+%w(1 2 3 4 5 6 7 8 9 10).in_groups_of(3, false)    #=> [['1', '2', '3'], ['4', '5', '6'], ['7', '8', '9'], ['10']]
+```
+
+`indexes` aka `indicies`
+------
+Returns all indexes of the matching value.
+
+```ruby
+[:a,:b,:a,:c].indexes(:a) #=> [0, 2]
+```
+
+`merge(!)`
+------
+Concats multiple arrays.
+
+```ruby
+[1, 2].merge([3, 4], [5, 6]) #=> [1, 2, 3, 4, 5, 6]
+```
+
+`nillify(!)`
+------
+Converts blank values into `nil`.
+
+```ruby
+[nil, 3, 4].nillify #=> [nil, 3, 4]
+[' ', 3, 4].nillify #=> [nil, 3, 4]
+['', 3, 4].nillify! #=> [nil, 3, 4]
+```
+
+`probability`
+------
+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 }
+```
+
+`promote(!)`
+------
+Moves a given value to head of array.
+
+```ruby
+[1, 2, 2, 3].promote(2)  #=> [2, 2, 1, 3]
+[1, 2, 2, 3].promote!(4) #=> [1, 2, 2, 3]
+```
+
+`position`
+------
+Returns the position of the first matching value.
+
+```ruby
+[:a,:b,:a,:c].position(:a) #=> 1
+```
+
+`positions`
+------
+Returns all of the positions of the matching value.
+
+```ruby
+[:a,:b,:a,:c].positions(:a) #=> [1, 3]
+```
+
+`reject_values`
+------
+Delete multiple values from a `dup` copy of the original array.
+
+```ruby
+[1, 2, 3, 4, 5].reject_values(2, 4) #=> [1, 3, 5]
+```
+
+`rposition`
+------
+Returns the position of the last matching value.
+
+```ruby
+[:a,:b,:a,:c].rposition(:a) #=> 3
+```
+
+`sample!`
+------
+Deletes a random value and returns that value.
+
+```ruby
+[1, 2, 3, 4, 5].sample! #=> 2
+```
+
+`split`
+------
+Divides the array into one or more subarrays based on a delimiting value or the result of an optional block.
+
+```ruby
+[1, 2, 3, 4, 5].split(3)              # => [[1, 2], [4, 5]]
+(1..10).to_a.split { |i| i % 3 == 0 } # => [[1, 2], [4, 5], [7, 8], [10]]
+```
+
+`strip(!)`
+------
+Removes blank elements from an array.
+
+```ruby
+['this', '', 'that', nil, false].strip  #=> ['this', 'that']
+'this    is   a  test'.split(' ').strip #=> ['this', 'is', 'a', 'test']
+```
+
+`swap`
+------
+Switches the places of two elements.
+
+```ruby
+[1, 2, 3].swap(0, 2) #=> [3, 2, 1]
+```
+
+`to`
+------
+Returns the beginning of the array up to a given position.
+
+```ruby
+['1', '2', '3'].to(0)  #=> ['1']
+['1', '2', '3'].to(1)  #=> ['1', '2']
+['1', '2', '3'].to(-1) #=> ['3']
+```
+
+`to_sentence`
+------
+Converts the array to a comma-separated sentence where the last element is joined by the connector word.
+
+Option | Type | Default
+--- | --- | ---
+words_connector | string | ', '
+two_words_connector | string | ' and '
+last_word_connector | string | ', and '
+
+```ruby
+[].to_sentence                                                                                    #=> ''
+['one'].to_sentence                                                                               #=> 'one'
+['one', 'two'].to_sentence                                                                        #=> 'one and two'
+['one', 'two', 'three'].to_sentence                                                               #=> 'one,two,and three'
+['one', 'two'].to_sentence(two_words_connector: '-')                                              #=> 'one-two'
+['one', 'two', 'three'].to_sentence(words_connector: ' or ',last_word_connector: ' or at least ') #=> 'one or two or at least three'
+```

data/docs/DATE.md

@@ -0,0 +1,78 @@
+# Date
+
+`format`
+------
+Converts a `date` object to `strftime` it using a human readable string.
+
+| Directive | Type | Key | `strftime` | Result |
+| --- | --- | --- | --- | --- |
+| Weekday | Monday | `w`, `weekday` | %u | (1..7) |
+| Weekday | Sunday | `ww`, `weekday_offset` | %w | (0..6) |
+| Weekday | Name | `www`, `weekday_name` | %A | Sunday |
+| Weekday | Name abbr | `wwww`, `weekday_name_abbr` | %a | Sun |
+| Day | Zero-padded | `d`, `day`, `day_padded` | %d | (01..31) |
+| Day | Unpadded | `dd`, `Day`, `day_unpadded` | %-d | (1..31) |
+| Day | Blank-padded | `ddd`, `DAY`, `day_blank` | %_d | ( 1..31) |
+| Day | Day of the year | `dddd`, `day_of_the_year` | %j | (001..366) |
+| Month | Zero-padded | `m`, `month`, `month_padded` | %m | (01..12) |
+| Month | Unpadded | `mm`, `Month`, `month_unpadded` | %-m | (1..12) |
+| Month | Blank-padded | `mmm`, `MONTH`, `day_blank` | %_m | ( 1..12) |
+| Month | Name | `mmmm`, `month_name` | %B | January |
+| Month | Name abbr | `mmmmm`, `month_name_abbr` | %b | Jan |
+| Week | ISO | `we`, `week` | %V | (00..53) |
+| Week | Monday | `mwe`, `monday_week` | %W | (00..53) |
+| Week | Sunday | `swe`, `sunday_week` | %U | (00..53) |
+| Year | 2 Digits | `yy`, `yr` | %y | (00..99) |
+| Year | 4 Digits | `yyyy`, `year` | %Y | 1999 |
+
+```ruby
+Date.today.format('month_name day, year') #=> 'May 05, 2000'
+```
+
+`stamp` aka `to_format`
+------
+Converts a `date` object to a predefined format.
+
+#### Base
+
+| Directive | Type | Key | `strftime` | Result |
+| --- | --- | --- | --- | --- |
+| Weekday | Zero-padded | `weekday`, `:weekday_padded` | %d | (01..31) |
+| Weekday | Blank-padded | `:weekday_blank` | %_d | ( 1..31) |
+| Weekday | Unpadded | `:weekday_unpadded` | %-d | (1..31) |
+| Weekday | Name | `:weekday_name` | %A | Sunday |
+| Weekday | Name abbr | `:weekday_name_abbr` | %a | Sun |
+| Month | Zero-padded | `:month`, `:month_padded` | %m | (01..12) |
+| Month | Unpadded | `:month_unpadded` | %-m | (1..12) |
+| Month | Blank-padded | `:month_blank` | %_m | ( 1..12) |
+| Month | Name | `:month_name` | %B | January |
+| Month | Name abbr | `:month_name_abbr` | %b | Jan |
+| Week | ISO | `:week_iso` | %V | (00..53) |
+| Week | Sunday | `:week_sunday` | %U | (00..53) |
+| Week | Monday | `:week_monday` | %W | (00..53) |
+| Year | 2 Digits | `:yr`, `:year_abbr` | %y | (00..99) |
+| Year | 4 Digits | `:year` | %Y | 1999 |
+
+#### Combinations
+
+| Directive | Type | Key | `strftime` | Result |
+| --- | --- | --- | --- | --- |
+| Combo | Month day | `:day` | %B %-d | January 9 |
+| Combo | Month day | `:day_abbr` | %b %-d | Jan 9 |
+| Combo | Month day | `:day_iso` | %m-%d | 01-09 |
+| Combo | Month year | `:month_year`, `:month_padded_year` | %m %Y | (01..12) 2015 |
+| Combo | Month year | `:month_blank_year` | %_m %Y | ( 1..12) 2015 |
+| Combo | Month year | `:month_unpadded_year` | %-m %Y | (1..12) 2015 |
+| Combo | Month year | `:month_name_year` | %B %Y | January 2015 |
+| Combo | Month year | `:month_name_abbr_year` | %b %Y | Jan 2015 |
+| Combo | Week year | `:week_year_iso` | %V-%G | 04-2014 |
+| Combo | Year day | `:year_day` | %Y-%m-%d | 1999-01-21 |
+| Combo | Year week | `:year_week` | %G-%V | 1999-52 |
+| Combo | Year month | `:year_month` | %Y-%m | 1999-01 |
+| Combo | Date | `:date` | %B %-d, %Y | January 9, 2014 |
+| Combo | Date | `:date_abbr` | %b %-d, %Y | Jan 9, 2014 |
+| Combo | Date | `:date_iso` | %Y-%m-%d | 2014-01-09 |
+
+```ruby
+Date.today.to_format(:year) #=> '2014'
+```

data/docs/ENUMERABLE.md

@@ -0,0 +1,174 @@
+# Enumerable
+
+`cluster`
+------
+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]]
+```
+
+`deduce`
+------
+Returns the difference of a collection of numbers.
+
+```ruby
+[].deduce      #=> 0
+[].deduce(nil) #=> nil
+[1,2,3].deduce #=> -4
+```
+
+`divisible`
+------
+Returns the division of a collection of numbers.
+
+```ruby
+[].divisible       #=> 0
+[].divisible(nil)  #=> nil
+[16,4,2].divisible #=> 2
+```
+
+`drop_last`
+------
+Drops the last number of elements in a collection.
+
+```ruby
+[].drop_last(1)      #=> []
+[1,2,3].drop_last(1) #=> [1,2]
+[1,2,3].drop_last(2) #=> [1]
+```
+
+`drop_last_if`
+------
+Drops the last number of elements in a collection while it meets a criteria.
+
+```ruby
+[].drop_last_if(&:odd?)        #=> []
+[1,2,3].drop_last_if(&:odd?)   #=> [1,2]
+[1,2,3,4].drop_last_if(&:odd?) #=> [1,2,3,4]
+```
+
+`exactly?`
+------
+Returns if there are exactly the number of an element type.
+
+```ruby
+[].exactly?(1)                 #=> false
+[1,2,3].exactly?(3)            #=> true
+[1,1,3,3].exactly?(2, &:even?) #=> false
+```
+
+`excase?`
+------
+The same as `exclude?` but tested using `===` instead of `==`.
+
+```ruby
+[1,2,'a'].excase?(String) #=> false
+[1,2,'a'].excase?(3)      #=> true
+```
+
+`exclude?`
+------
+Returns if the collection does not include an object.
+
+```ruby
+[1,2,3].exclude?(4) #=> true
+[1,2,3].exclude?(3) #=> false
+```
+
+`expand`
+------
+Expand all elements of an Enumerable object.
+
+```ruby
+[0,2..3,5..7].expand #=> [0,[2,3],[5,6,7]]
+```
+
+`exponential`
+------
+Returns the exponential of a collection of numbers.
+
+```ruby
+[].exponential      #=> 0
+[].exponential(nil) #=> nil
+[2,3,4].exponential #=> 4096
+```
+
+`incase?`
+------
+The same as `include?` but tested using `===` instead of `==`.
+
+```ruby
+[1,2,'a'].incase?(String) #=> true
+[1,2,'a'].incase?(3)      #=> false
+```
+
+`interpose`
+------
+Returns an Enumerator to add seperators.
+
+```ruby
+[1,2,'a'].interpose(:sep).to_a #=> [1,:sep,2,:sep,'a']
+```
+
+`many?`
+------
+Returns if a collection has more than one element while respecting `nil` and `false` as an element.
+
+```ruby
+[].many?                 #=> false
+[1,2,3].many?            #=> true
+[1,false,nil].many?      #=> true
+[1,1,3,3].many?(&:even?) #=> false
+
+```
+
+`multiple`
+------
+Returns the multiplication of a collection of numbers.
+
+```ruby
+[].multiple      #=> 0
+[].multiple(nil) #=> nil
+[1,2,3].multiple #=> 6
+```
+
+`occurrences`
+------
+Returns a hash of the number of times a value appears in an array.
+
+```ruby
+[].occurrences                               #=> {}
+[1,:symbol,'string',3,:symbol,1].occurrences #=> { 1 => 2,:symbol => 2,'string' => 1,3 => 1 }
+```
+
+`several?`
+------
+Returns if collection has more than one element while not respecting `nil` and `false` as an element.
+
+```ruby
+[].several?                 #=> false
+[1,2,3].several?            #=> true
+[1,false,nil].several?      #=> false
+[1,1,3,3].several?(&:even?) #=> false
+```
+
+`take_last`
+------
+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]
+```
+
+`take_last_if`
+------
+Returns the last number of elements of a collection while it meets a criteria.
+
+```ruby
+[].take_last_if(&:odd?)        #=> []
+[1,2,3].take_last_if(&:odd?)   #=> [3]
+[1,2,3,4].take_last_if(&:odd?) #=> []
+```