crystal_goodies 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d4b7ae551c485c71237af166ebd2290d65f1f2773aba36879c7f8ea26cdf2146
-  data.tar.gz: 10760bdbd7c24e1eb6f7fed9a44179fd747487e8962730f34f1afe8c12e2ec25
+  metadata.gz: 1ea56dd113383c09a481ff17f3a762e3e7924a1b471404ab97cb3a86ea813cdd
+  data.tar.gz: 6306d0c2152e93bc8ac5bfc54c2936ddec63be85f2fc874cacd59e5b236ccf44
 SHA512:
-  metadata.gz: da29836bb1d4979e3f1e57d83c4c9c00297fcba47bd5160ebf987cc0ed29178ad0da84048bc504a169c2d6d737ce5bd93d5ca7a2c8e1276da522e342fc2627a0
-  data.tar.gz: 1658a8a130350d2cd70cffff5924f7a7ec122f238ec055601e1dacb3ca551e8367bf19319172bde7d4b8b9ba851928afdece04063060ce0ccde5ee1214a04a4f
+  metadata.gz: c7085bd6883530c41ed175e8c61ec906df0e082d455584c24f681a37a952427184fb4dd7f2deac06f7b280f63505fe6b0120535cf6b1f247858a631cea9c051a
+  data.tar.gz: bfa816894dc44a773cb94ab0e68f6906d30e296e7f2dd5379fef9cf62ab040c41637f3e859bd6fad36b2e87e357f32c4c7d80a8fbf14b5dcc6b6579d49ea8e6d

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## [1.0.2] - 2023-08-16
+
+- Added API documents.
+
 ## [1.0.1] - 2023-08-16
 
 - Fixed `String#underscore`.

data/README.md

@@ -2,7 +2,7 @@
 
 ## 💡 About
 
-Class's methods inspired/port from Crystal.
+Class's methods convenient for scripting port from Crystal.
 
 ## 📥 Installation
 
@@ -26,7 +26,271 @@ In Ruby do:
 require 'crystal_goodies'
 ```
 
-TODO
+Only require methods to access through module `CrystalGoodies`.
+
+```rb
+require 'crystal_goodies/object'
+require 'crystal_goodies/integer'
+require 'crystal_goodies/string'
+require 'crystal_goodies/array'
+require 'crystal_goodies/enumerable'
+```
+
+Only require class extensions.
+
+```rb
+require 'crystal_goodies/object/extensions'
+require 'crystal_goodies/integer/extensions'
+require 'crystal_goodies/string/extensions'
+require 'crystal_goodies/array/extensions'
+require 'crystal_goodies/enumerable/extensions'
+```
+
+### Object
+
+#### in?(*collection) -> true, false
+
+Returns `true` if `self` is included in the *collection* argument.
+
+```
+10.in?(0..100)     # => true
+10.in?(0, 1, 10)   # => true
+10.in?(:foo, :bar) # => false
+```
+
+### Integer
+
+#### divisible_by?(num) -> true, false
+
+Returns `true` if `self` is divisible by *num*.
+
+```
+6.divisible_by? 3 # => true
+6.divisible_by? 2 # => true
+5.divisible_by? 3 # => false
+```
+
+#### to(limit) { |i| ... } -> self
+
+Call `upto` or `downto` depend on the *limit*.
+
+### String
+
+#### camelcase(options, lower: false) -> String
+
+Converts underscores to camelcase boundaries.
+
+If *lower* is true, lower camelcase will be returned (the first letter is downcased).
+
+```
+"eiffel_tower".camelcase                       # => "EiffelTower"
+"empire_state_building".camelcase(lower: true) # => "empireStateBuilding"
+```
+
+#### titleize(options) -> String
+
+Returns a new `String` with the first letter after any space converted to uppercase and every
+other letter converted to lowercase.
+
+```
+"hEllO tAb\tworld".titleize      # => "Hello Tab\tWorld"
+"  spaces before".titleize       # => "  Spaces Before"
+"x-men: the last stand".titleize # => "X-men: The Last Stand"
+```
+
+#### underscore(options) -> String
+
+Converts camelcase boundaries to underscores.
+
+```
+"DoesWhatItSaysOnTheTin".underscore # => "does_what_it_says_on_the_tin"
+"PartyInTheUSA".underscore          # => "party_in_the_usa"
+"HTTP_CLIENT".underscore            # => "http_client"
+"3.14IsPi".underscore               # => "3.14_is_pi"
+```
+
+#### dasherize(options) -> String
+
+Converts camelcase boundaries to kebabcase.
+
+```
+"DoesWhatItSaysOnTheTin".dasherize # => "does-what-it-says-on-the-tin"
+"PartyInTheUSA".dasherize          # => "party-in-the-usa"
+"HTTP_CLIENT".dasherize            # => "http-client"
+"3.14IsPi".dasherize               # => "3.14-is-pi"
+```
+
+#### blank? -> true, false
+
+Returns `true` if this string consists exclusively of unicode whitespace.
+
+```
+"".blank?        # => true
+"   ".blank?     # => true
+"   a   ".blank? # => false
+```
+
+#### presence -> self, nil
+
+Returns `self` unless `#blank?` is `true` in which case it returns `nil`.
+
+```
+"a".presence         # => "a"
+"".presence          # => nil
+"   ".presence       # => nil
+"    a    ".presence # => "    a    "
+```
+
+#### delete_at(...) -> String
+
+Returns a new string that results from deleting characters with `slice`.
+
+#### to(limit, exclusive = false) -> self
+
+Call `upto` or `downto` depend on the *limit*.
+
+### Array
+
+#### skip(count) -> Array
+
+Returns an `Array` with the first *count* elements removed
+from the original array.
+
+If *count* is bigger than the number of elements in the array, returns an empty array.
+
+```
+[1, 2, 3, 4, 5, 6].skip(3) # => [4, 5, 6]
+```
+
+#### truncate(...) -> elements
+
+Removes all elements except the *count* or less (if there aren't enough)
+elements starting at the given *start* index. Returns `self`.
+
+Negative values of *start* count from the end of the array.
+
+Raises `IndexError` if the *start* index is out of range.
+
+Raises `ArgumentError` if *count* is negative.
+
+```
+a = [0, 1, 4, 9, 16, 25]
+a.truncate(2, 3) # => [4, 9, 16]
+a                # => [4, 9, 16]
+```
+
+Or removes all elements except those within the given *range*. Returns `self`.
+
+```
+a = [0, 1, 4, 9, 16, 25]
+a.truncate(1..-3) # => [1, 4, 9]
+a                 # => [1, 4, 9]
+```
+
+### Enumerable
+
+#### empty? -> true, false
+
+Returns `true` if `self` is empty, `false` otherwise.
+
+```
+[].empty?  # => true
+[1].empty? # => false
+```
+
+#### compact_map { ... } -> Array
+
+Returns an `Array` with the results of running the block against each element
+of the collection, removing `nil` values.
+
+```
+["Alice", "Bob"].map { |name| name.match(/^A./) }         # => [#<MatchData "Al">, nil]
+["Alice", "Bob"].compact_map { |name| name.match(/^A./) } # => [#<MatchData "Al">]
+```
+
+#### in_groups_of(size, filled_up_with = nil) -> Array
+
+Returns an `Array` with chunks in the given size, eventually filled up
+with given value or `nil`.
+
+```
+[1, 2, 3].in_groups_of(2, 0) # => [[1, 2], [3, 0]]
+[1, 2, 3].in_groups_of(2)    # => [[1, 2], [3, nil]]
+```
+
+#### skip_while { ... } -> Array
+
+Skips elements up to, but not including, the first element for which
+the block is falsey, and returns an `Array`
+containing the remaining elements.
+
+```
+[1, 2, 3, 4, 5, 0].skip_while { _1 < 3 } # => [3, 4, 5, 0]
+```
+
+#### index_by { ... } -> Hash
+
+Converts an `Enumerable` to a `Hash` by using the value returned by the block
+as the hash key.
+Be aware, if two elements return the same value as a key one will override
+the other. If you want to keep all values, then you should probably use
+`group_by` instead.
+
+```
+["Anna", "Ary", "Alice"].index_by(&:size)
+# => {4 => "Anna", 3 => "Ary", 5 => "Alice"}
+["Anna", "Ary", "Alice", "Bob"].index_by(&:size)
+# => {4 => "Anna", 3 => "Bob", 5 => "Alice"}
+```
+
+#### tally_by(hash = {}) { ... } -> Hash
+
+Tallies the collection. Accepts a *hash* to count occurrences.
+The value corresponding to each element must be an integer.
+Returns *hash* where the keys are the
+elements and the values are numbers of elements in the collection
+that correspond to the key after transformation by the given block.
+
+```
+hash = {}
+words = ["Crystal", "Ruby"]
+words.each { |word| word.chars.tally_by(hash, &:downcase) }
+hash # => {"c" => 1, "r" => 2, "y" => 2, "s" => 1, "t" => 1, "a" => 1, "l" => 1, "u" => 1, "b" => 1}
+```
+
+#### min_of? { ... } -> min_element
+
+Returns the element for which the passed block returns with the maximum value.
+
+It compares using `>` so the block must return a type that supports that method
+
+```
+["Alice", "Bob"].max_by(&:size) # => "Alice"
+```
+
+Return `nil` if the collection is empty.
+
+#### max_of? { ... } -> max_element
+
+Returns the element for which the passed block returns with the minimum value.
+
+It compares using `<` so the block must return a type that supports that method
+
+```
+["Alice", "Bob"].min_by(&:size) # => "Bob"
+```
+
+Return `nil` if the collection is empty.
+
+#### minmax_of? { ... } -> [min_element, max_element]
+
+Returns a `Array` with both the minimum and maximum values according to the passed block.
+
+```
+["Alice", "Bob", "Carl"].minmax_by(&:size) # => ["Bob", "Alice"]
+```
+
+Return `[nil, nil]` if the collection is empty.
 
 ## 💌 Credits
 

data/lib/crystal_goodies/object.rb

@@ -2,13 +2,13 @@
 
 module CrystalGoodies
   class Object
-      # Returns `true` if `self` is included in the *collection* argument.
-      #
-      # ```
-      # 10.in?(0..100)     # => true
-      # 10.in?(0, 1, 10)   # => true
-      # 10.in?(:foo, :bar) # => false
-      # ```
+    # Returns `true` if `self` is included in the *collection* argument.
+    #
+    # ```
+    # 10.in?(0..100)     # => true
+    # 10.in?(0, 1, 10)   # => true
+    # 10.in?(:foo, :bar) # => false
+    # ```
     def in?(*collection)
       (collection.one? ? collection.first : collection).include? self
     end

data/lib/crystal_goodies/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CrystalGoodies
-  VERSION = '1.0.1'
+  VERSION = '1.0.2'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: crystal_goodies
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - NNB
@@ -10,7 +10,7 @@ bindir: bin
 cert_chain: []
 date: 2023-08-16 00:00:00.000000000 Z
 dependencies: []
-description: Class's methods inspired/port from Crystal.
+description: Class's methods convenient for scripting port from Crystal.
 email:
 - nnbnh@protonmail.com
 executables: []