crystal_goodies 1.0.0 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 100fad08a9578a26ae53785926cc01fc7d81735a7afe55c62d1a3d74d9312924
-  data.tar.gz: c0bf1b1c3d290359d270659de2e888fa9486473eae55e517af9c38358c4367af
+  metadata.gz: 1ea56dd113383c09a481ff17f3a762e3e7924a1b471404ab97cb3a86ea813cdd
+  data.tar.gz: 6306d0c2152e93bc8ac5bfc54c2936ddec63be85f2fc874cacd59e5b236ccf44
 SHA512:
-  metadata.gz: 1eebd55c21f807d34ae9be8bacd3c12d645ff9eacc721314bdd19cd3c880091a39d873dee0f3d5e1e5cbd407a0574a695cdc25d5da7ee4fda01f2c5d19c32122
-  data.tar.gz: f2d138d8a5b01fc8dc89e5913909e0c768332e43c9f1e07ffd2329b98238bc9f84b24316a270698ddff48f89bcd7b54ed2aeba32d334518ab4b253cc49510b69
+  metadata.gz: c7085bd6883530c41ed175e8c61ec906df0e082d455584c24f681a37a952427184fb4dd7f2deac06f7b280f63505fe6b0120535cf6b1f247858a631cea9c051a
+  data.tar.gz: bfa816894dc44a773cb94ab0e68f6906d30e296e7f2dd5379fef9cf62ab040c41637f3e859bd6fad36b2e87e357f32c4c7d80a8fbf14b5dcc6b6579d49ea8e6d

data/CHANGELOG.md

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

data/README.md

@@ -2,7 +2,7 @@
 
 ## 💡 About
 
-Class's methods port from Crystal.
+Class's methods convenient for scripting port from Crystal.
 
 ## 📥 Installation
 
@@ -25,10 +25,276 @@ In Ruby do:
 ```rb
 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
 
 - [**Crystal**](https://crystal-lang.org) by [it's contributors](https://github.com/crystal-lang/crystal/graphs/contributors)
+- [**Ruby on Rails**](https://rubyonrails.org) by [it's contributors](https://github.com/rails/rails/graphs/contributors)
 
 <a href="https://codeberg.org/NNB"><img width="100%" src="https://capsule-render.vercel.app/api?type=waving&section=footer&color=DC2626&fontColor=FEF2F2&height=128&desc=Made%20with%20%26lt;3%20by%20NNB&descAlignY=80" /></a>

data/lib/crystal_goodies/enumerable.rb

@@ -21,7 +21,6 @@ module CrystalGoodies
     # ["Alice", "Bob"].compact_map { |name| name.match(/^A./) } # => [#<MatchData "Al">]
     # ```
     def compact_map(&)
-      # FIXME
       map(&).compact
     end
 

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/string.rb

@@ -61,78 +61,9 @@ module CrystalGoodies
     # "3.14IsPi".underscore               # => "3.14_is_pi"
     # ```
     def underscore(*options)
-      <<-FIXME
-
-      string = ''
-      first = true
-      last_is_downcase = false
-      last_is_upcase = false
-      last_is_digit = false
-      mem = nil
-
-      each_char do |char|
-        if options.ascii?
-          digit = char.ascii_number?
-          downcase = digit || char.ascii_lowercase?
-          upcase = char.ascii_uppercase?
-        else
-          digit = char.number?
-          downcase = digit || char.lowercase?
-          upcase = char.uppercase?
-        end
-
-        if first
-          char.downcase(options) { |c| string << c }
-        elsif last_is_downcase && upcase
-          if mem
-            # This is the case of A1Bcd, we need to put 'mem' (not to need to convert as downcase
-            #                       ^
-            # because 'mem' is digit surely) before putting this char as downcase.
-            string << mem
-            mem = nil
-          end
-          # This is the case of AbcDe, we need to put an underscore before the 'D'
-          #                        ^
-          string << '_'
-          char.downcase(options) { |c| string << c }
-        elsif (last_is_upcase || last_is_digit) && (upcase || digit)
-          # This is the case of 1) A1Bcd, 2) A1BCd or 3) A1B_cd:if the next char is upcase (case 1) we need
-          #                          ^         ^           ^
-          # 1) we need to append this char as downcase
-          # 2) we need to append an underscore and then the char as downcase, so we save this char
-          #    in 'mem' and decide later
-          # 3) we need to append this char as downcase and then a single underscore
-          if mem
-            # case 2
-            mem.downcase(options) { |c| string << c }
-          end
-          mem = char
-        else
-          if mem
-            if char == '_'
-              # case 3
-            elsif last_is_upcase && downcase
-              # case 1
-              string << '_'
-            end
-            mem.downcase(options) { |c| string << c }
-            mem = nil
-          end
-
-          char.downcase(options) { |c| string << c }
-        end
-
-        last_is_downcase = downcase
-        last_is_upcase = upcase
-        last_is_digit = digit
-        first = false
-      end
-
-      mem&.downcase(options) { |c| string << c }
-
-      FIXME
-
-      self
+      gsub(/([A-Z])(?=[A-Z][a-z])|([a-z\d])(?=[A-Z])/) { (_1 || _2) << '_' }
+        .tr('-', '_')
+        .downcase(*options)
     end
 
     # Converts camelcase boundaries to kebabcase.
@@ -143,8 +74,8 @@ module CrystalGoodies
     # "HTTP_CLIENT".dasherize            # => "http-client"
     # "3.14IsPi".dasherize               # => "3.14-is-pi"
     # ```
-    def dasherize
-      underscore.tr('_', '-')
+    def dasherize(*options)
+      underscore(*options).tr('_', '-')
     end
 
     # Returns `true` if this string consists exclusively of unicode whitespace.

data/lib/crystal_goodies/version.rb

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

data/sig/enumerable.rbs

@@ -2,8 +2,7 @@ module CrystalGoodies
   module Enumerable
     def empty?: () -> bool
 
-    def compact_map: () -> Enumerator
-                   | () { () -> void } -> Array
+    def compact_map: () { () -> void } -> Array
 
     def in_groups_of: (Integer size, ?untyped? filled_up_with) -> Array
 

metadata

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