rafini 2.0.0 → 3.0.210112

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b81e63f8b4651660cd62560692546173a7ae971ce0a0a76b6bc772c573f2d181
-  data.tar.gz: 37146803ff33ddcf74da2cd90bb5ddd4a2b1da0fe2be0c55b1b5b984a14029ca
+  metadata.gz: df4dc73d0b92dcd762d1c741eb30f8dcfc56fdd84d18bfdbc2435290d9a3df97
+  data.tar.gz: c7764c8ae13bb99ff51977d7b52f926eee9083e5db6f75e43c860c2eb9557715
 SHA512:
-  metadata.gz: ecb3a3935d9892365a7568e304994605657b0ff0ed9c4e5adab0eee83c4d42d9584b0b6c6cdcd2d602f2817371d3a632f51396bf62b9ca134153c7eae926f22a
-  data.tar.gz: a1795c03155fbaa64fd90b4a5a8ab4ad033fa5489bb925168a765ab4be71b742cca5bc61d282c88c9c4af75c2b9c24feb8c2bd87f5d01189a5b32e34fd2a8c89
+  metadata.gz: eb0f6fcdf17d108b75ddd5af587ceb7fe2d6294e8134cfeae90807f62607d49e158754903526f49b22fb6522a4ded0cf2f1522ad9c1305f295b9bd858cad9714
+  data.tar.gz: 8b327f489cfa71d77eca28df39b4408fcf8c7c4c8e7ed233c10f05e242bcfee0936a96f97e5bb8eee0fa4f49a058bc7b754fc549ab47d8e70574e756ccdc1d93

data/README.md

@@ -1,101 +1,143 @@
-# rafini 2.0.0
+# Rafini
+
+* [VERSION 3.0.210112](https://github.com/carlosjhr64/rafini/releases)
+* [github](https://github.com/carlosjhr64/rafini)
+* [rubygems](https://rubygems.org/gems/rafini)
 
 ## DESCRIPTION:
 
 Just a collection of useful refinements.
 
+## INSTALL:
+
+```shell
+$ gem install rafini
+```
+
 ## SYNOPSIS:
 
 ### using Rafini::Array
 
-    # joins
-    ['a','b','c','d','e','f'].joins('-','-',' '){':'} #=> "a-b-c d:e:f"
+```ruby
+require 'rafini/array'
+using Rafini::Array
 
-    # per
-    h={}
-    ['a','b','c'].per(['A','B','C']){|l,u| h[l]=u}
-    h #=> {'a'=>'A','b'=>'B','c'=>'C'}
+# joins
+['Y','M','D','h','m','s'].joins('-','-',' '){':'}
+#=> "Y-M-D h:m:s"
+[1,9,2,8,3,7,4,6,5,5].joins{|a,b|a>b ? '>': a<b ? '<': '='}
+#=> "1<9>2<8>3<7>4<6>5=5"
 
-    # which
-    ['dog','cat','bunny'].which{|a|a=~/c/} #=> "cat"
+# is
+[:a,:b,:c].is(true) #=> {:a=>true, :b=>true, :c=>true}
+```
+### Rafini::Empty
 
-    # is
-    [:a,:b,:c].is(true) #=> {a: true, b: true, c: true}
+```ruby
+require 'rafini/empty'
+include Rafini::Empty
+s0 #=> ""
+a0 #=> []
+h0 #=> {}
+[s0,a0,h0].all?(&:frozen?) #=> true
+```
 
 ### using Rafini::Exception
 
-    # $!.puts
-    begin
-      raise 'Ugly Message'
-    rescue RuntimeError
-      $!.puts 'Nice Message'
-    end
-
-    # Rafini.bang!
-    value = Rafini.bang!('Nice Message') do
-      raise 'Ugly Message'
-    end
-    value #=> return value of block or error object
-
-    # Rafini.thread_bang!
-    Rafini.thread_bang!('Nice Message') do
-      # this is in a thread
-      raise 'Ugly Message'
-    end
+```ruby
+require 'rafini/exception'
+using Rafini::Exception
+
+# $!.puts
+# Normally stderr.puts your "Nice" message.
+# Additionally puts your "Ugly" message when $VERBOSE.
+# Additionally puts backtrace when $DEBUG
+# No output when $VERBOSE is nil.
+begin
+  raise 'Ugly Message'
+rescue RuntimeError
+  $!.puts 'Nice Message'
+end
+
+# Rafini.bang!
+error = Rafini.bang!('Nice Message') do
+  raise 'Ugly Message'
+  # Outputs as $!.puts "Nice Message"
+end
+error.class #=> RuntimeError
+error.to_s  #=> "Ugly Message"
+
+# Rafini.thread_bang!
+thread = Rafini.thread_bang!('Nice Message') do
+  # this is in a thread
+  raise 'Ugly Message' # outputs as $!.puts 'Nice Message'
+end
+# The returned value joined from the thread
+# will not re-raise the error(but gives the error).
+thread.value.class #=> RuntimeError
+```
 
 ### using Rafini::Hash
 
-    # to_struc
-    struct = {a:'A',b:'C',c:'C'}.to_struct
-    struct.a #=> 'A'
-
-    # modify
-    {a:'A',b:'B'}.modify({b:'X',c:'C'},{c:'Y',d:'D'}) #=> {a:'A',b:'X',c:'Y',d:'D'}
+```ruby
+require 'rafini/hash'
+using Rafini::Hash
 
-    # supplement
-    {a:'A',b:'B'}.supplement({b:'X',c:'C'},{c:'Y',d:'D'}) #=> {a:'A',b:'B',c:'C',d:'D'}
+# to_struc
+struct = {a:'A',b:'C',c:'C'}.to_struct{ def ok = "OK" }
+struct    #=> #<struct a="A", b="C", c="C">
+struct.a  #=> "A"
+struct.ok #=> "OK"
 
-    # amend
-    {a:'A',b:'B'}.amend({b:'X',c:'C'},{c:'Y',d:'D'}) #=> {a:'A',b:'X'}
+# supplement
+{a:'A',b:'B'}.supplement({b:'X',c:'C'},{c:'Y',d:'D'}) #=> {:a=>"A", :b=>"B", :c=>"C", :d=>"D"}
 
-    # maps
-    {a:'A',b:'B',c:'C',c:'D'}.maps(:c,:a,:b) #=> ['C','A','B']
+# amend
+{a:'A',b:'B'}.amend({b:'X',c:'C'},{c:'Y',d:'D'}) #=> {:a=>"A", :b=>"X"}
+```
 
 ### using Rafini::Integer
 
-    # odometer
-    123.odometer(10,10) #=> [3,2,1]
-    30.odometer(2,3,5) #=> [0,0,0,1]
+```ruby
+require 'rafini/integer'
+using Rafini::Integer
 
-### using Rafini::Odometers
+# odometer
+123.odometer(10,10) #=> [3, 2, 1]
+30.odometer(2,3,5)  #=> [0, 0, 0, 1]
+```
 
-    # sec2time
-    12501.sec2time.to_s #=> "3 hours and 28 minutes"
-
-    # illion
-    3_512_325.illion.to_s #=> "3.51M"
+### using Rafini::Odometers
 
-### using Rafini::String
+```ruby
+require 'rafini/odometers'
+using Rafini::Odometers
 
-    # camelize
-    'a_camel_kick'.camelize #=> "ACamelKick"
+# sec2time
+12501.sec2time.to_s #=> "3 hours and 28 minutes"
 
-    # semantic
-    '1.2.3'.semantic(0..1) #=> '1.2'
+# illion
+3_512_325.illion.to_s #=> "3.51M"
+```
 
-### Rafini::Empty
+### using Rafini::String
 
-    STRING, ARRAY, HASH = ''.frozen, [].frozen, {}.frozen
+```ruby
+require 'rafini/string'
+using Rafini::String
 
-## INSTALL:
+# camelize
+'a_camel_kick'.camelize #=> "ACamelKick"
 
-    $ gem install rafini
+# semantic
+'1.2.3'.semantic(0..1) #=> "1.2"
+```
 
 ## LICENSE:
 
 (The MIT License)
 
-Copyright (c) 2020 carlosjhr64
+Copyright (c) 2021 carlosjhr64
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/lib/rafini.rb

@@ -1,12 +1,12 @@
 module Rafini
-  VERSION = '2.0.0'
-  require 'rafini/array'
-  require 'rafini/exception'
-  require 'rafini/hash'
-  require 'rafini/integer'
-  require 'rafini/string'
-  require 'rafini/odometers'
-  require 'rafini/empty'
+  VERSION = '3.0.210112'
+  autoload :Array,     'rafini/array'
+  autoload :Exception, 'rafini/exception'
+  autoload :Hash,      'rafini/hash'
+  autoload :Integer,   'rafini/integer'
+  autoload :String,    'rafini/string'
+  autoload :Odometers, 'rafini/odometers'
+  autoload :Empty,     'rafini/empty'
 end
 # Requires:
 #`ruby`

data/lib/rafini/array.rb

@@ -1,52 +1,40 @@
 module Rafini
   module Array
     refine ::Array do
-      # string = array.joins(sep1,sep2,sep3,...){|i| sep[i]}
+      # type _AToS = ::Array[(_AToS|_ToS)]
+      # _AToS#joins(*_AToS seps)?{(_ToS,_ToS)->_ToS}
       #
-      # Returns a string created by converting each element of the array to
-      # a string, separated by the given separators.
+      # Returns a string created by joining the elements of the (flatten) array,
+      # separated by the given (flatten) separators.
       # If no separators are given or are used up,
-      # it uses the value of the executed block, which is passed an iteration number.
-      # Note that the iteration number starts at 1.
-      # Lastly it uses an empty string.
-      #    ['a','b','c','d','e','f'].joins('-', '-', ' '){':'} #=> 'a-b-c d:e:f'
-      #    ['a','b','c'].joins{','} #=> 'a,b,c'
-      #    ['1','2','3'].joins('.') #=> '1.23'
-      #    ['a','b','c'].joins{|i|i} #=> 'a1b2c'
-      def joins(*p, &block)
-        str = ''
-        if length > 0
-          str << self[0]
-          1.upto(length-1) do |i|
-            str << (p.empty? ? (block ? block.call(i).to_s : '') : p.shift.to_s)
-            str << self[i]
-          end
+      # it uses the value of the executed block, which is passed the next neigboring iteration items.
+      # Else, it just joins the items.
+      #    ['2021','Jan','09','07','29','05'].joins('-', '-', ' '){':'}
+      #    #=> "2021-Jan-09 07:29:05"
+      #    [:a,[1,2],:b].joins{','} #=> 'a,1,2,b'
+      #    [3,1,4,1,5,9].joins('.') #=> '3.14159'
+      #    [1,9,2,8,3,7,4,6,5,5].joins{|a,b|a>b ? '>': a<b ? '<': '='}
+      #    #=> "1<9>2<8>3<7>4<6>5=5"
+      def joins(*seps, &block)
+        return '' if length < 1
+        items = flatten
+        previous = items.shift
+        string = ::String.new previous.to_s
+        return string if items.empty?
+        seps.flatten!
+        while item = items.shift
+          sep = seps.shift&.to_s || block&.call(previous,item).to_s and string << sep
+          string << item.to_s
+          previous = item
         end
-        return str
+        return string
       end
 
-      # array1.per(array2){|obj1, obj2| ... }
-      #
-      # Gives the block each two elements of two array respectively.
-      # If the second array is not given, it passes the block the index number instead.
-      #   h={} # say you have a hash h, then
-      #   ['a','b','c'].per(['A','B','C']){|l,n| h[l]=n} # h=={'a'=>'A','b'=>'B','c'=>'C'}
-      #   ['a','b','c'].per{|l,i| h[l]=i} # h=={'a'=>0,'b'=>1,'c'=>2}
-      def per(b=nil)
-        0.upto(length-1){|i| yield self[i], (b)? b[i] : i}
-      end
-
-      # array.which{|a|...}
-      #
-      # Returns first object for which block is true.
-      # ['dog','cat','bunny'].which{|a|a=~/c/} #=> "cat"
-      alias which detect
-
       # [:a,:b,:c].is(true) #=> {:a=>true,:b=>true,:c=>true}
       #
       # Updates a hash with the keys given by the array to the given value.
       def is(value, hash={})
-        self.each{|key| hash[key]=value}
+        each{|key| hash[key]=value}
         return hash
       end
     end

data/lib/rafini/empty.rb

@@ -1,10 +1,11 @@
 module Rafini
-  # In a world where objects are allowed to represent infinities,
-  # Rafini dares to introduce empty sets.  But WHY!???
-  # Ta-ta-TUM...
   module Empty
-    ARRAY = [].freeze
-    HASH  = {}.freeze
+    ARRAY  = [].freeze
+    HASH   = {}.freeze
     STRING = ''.freeze
+
+    def a0 = ARRAY
+    def h0 = HASH
+    def s0 = STRING
   end
 end

data/lib/rafini/hash.rb

@@ -3,30 +3,16 @@ module Rafini
     refine ::Hash do
       # struct = hash.to_struct
       # Why not?
-      def to_struct
-        Struct.new(*self.keys).new(*self.values)
+      def to_struct(&blk)
+        Struct.new(*keys, &blk).new(*values)
       end
 
-      # hash0.modify(hash1,...) #=> hash
-      #
-      # Updates hash with hashes.
-      # Overwrites existing elements and adds elements.
-      #    {a:'A',b:'B'}.modify({b:'X',c:'C'},{c:'Y',d:'D'}) #=> {a:'A',b:'X',c:'Y',d:'D'}
-      def modify(*hashes)
-        hashes.each do |hash|
-          hash.each do |key, value|
-            self[key] = value
-          end
-        end
-        self
-      end
-
-      # hash0.supplement(hash1,...) #=> hash
+      # hash0.supplement!(hash1,...) #=> hash
       #
       # Supplements hash with hashes.
       # Adds missing elements only.
       #   {a:'A',b:'B'}.supplement({b:'X',c:'C'},{c:'Y',d:'D'}) #=> {a:'A',b:'B',c:'C',d:'D'}
-      def supplement(*hashes)
+      def supplement!(*hashes)
         hashes.each do |hash|
           hash.each do |key, value|
             self[key] = value unless self.has_key?(key)
@@ -34,30 +20,23 @@ module Rafini
         end
         self
       end
+      def supplement(...)
+        self.dup.supplement!(...)
+      end
 
-      # hash0.ammend(hash1,...)
+      # hash0.amend(hash1,...)
       #
       # Ammends hash with hashes.
-      # Overwrites existing elements only.
-      #   {a:'A',b:'B'}.supplement({b:'X',c:'C'},{c:'Y',d:'D'}) #=> {a:'A',b:'X'}
-      def amend(*hashes)
-        self.keys.each do |key|
-          hashes.each do |hash|
-            if hash.has_key?(key)
-              self[key] = hash[key]
-              break
-            end
-          end
+      # Overwrites existing keys only with first key value found in amending hashes.
+      #   {a:'A',b:'B'}.amend({b:'X',c:'C'},{c:'Y',d:'D'}) #=> {a:'A',b:'X'}
+      def amend!(*hashes)
+        self.each_key do |key|
+          value=hashes.find{_1.has_key? key}&.fetch(key) and self[key]=value
         end
         self
       end
-
-      # hash.maps(key1,...)
-      #
-      # Maps parameters list with hash.
-      #    {a:'A",b:'B',c:'C'}.maps(:c,:a,:b) #=> ['C','A','B']
-      def maps(*keys)
-        keys.map{|_|self[_]}
+      def amend(...)
+        self.dup.amend!(...)
       end
     end
   end

data/lib/rafini/integer.rb

@@ -7,19 +7,22 @@ module Rafini
       #   30.odometer(2,3,5) #=> [0,0,0,1]
       #   ((60*60*24)*3 + (60*60)*12 + 60*15 + 30).odometer(60,60,24) #=> [30, 15, 12, 3]
       # Useful for making clocks, number scales, mayan long count... etc.
-      def odometer(*p)
-        n = self
-        m = p.inject(1,:*)
-        r = []
+      def odometer(*levels, factors: true)
+        raise RangeError, 'negative odometer' if self < 0
+        readings, remainder = [], self
 
-        (p.length-1).downto(0) do |i|
-          y = n/m; r.unshift y
-          n = n%m
-          f = p[i]; m = m/f
+        levels = levels.inject([1]){|m, f| m.push(m.last*f)} if factors
+        levels.shift
+
+        levels.reverse_each do |level|
+          # in case of a float, floor
+          reading = (remainder/level).floor
+          readings.unshift reading
+          remainder = remainder%level
         end
-        r.unshift n
 
-        return r
+        # in case of a float, round
+        readings.unshift remainder.round
       end
     end
   end

data/lib/rafini/odometers.rb

@@ -1,78 +1,101 @@
+require 'rafini/integer'
+require 'rafini/hash'
+
 module Rafini
   module Odometers
-    SEC2TIME = {
-      second:     60,
+    # Sidereal Year: https://en.wikipedia.org/wiki/Year
+    year = 365*24*60*60 + 6*60*60 + 9*60 + 9.76
+    SEC2TIME = { # levels
+      second:     1,
       minute:     60,
-      hour:       24,
-      day:        7,
-      week:       4,
-      month:      13,
-      year:       10,
-      decade:     10,
-      centurie:   10,
-      millennium: 10,
-      age:        10,
-      epoch:      10,
-      era:        5,
-      eon:        2,
-      gigaannum:  nil,
+      hour:       60*60,
+      day:        24*60*60,
+      week:       7*24*60*60,
+      month:      year/12.0,
+      year:       year,
+      decade:     10*year,
+      centurie:   100*year,
+      millennium: 1_000*year,
+      age:        10_000*year,
+      epoch:      100_000*year,
+      era:        1_000_000*year,
+      eon:        5_000_000*year,
+      gigaannum:  10_000_000*year,
     }
 
-    SCALE = {
+    SCALE = { # levels
       base: {
-        ones:         10,
-        tens:         10,
-        hundreds:     10,
-        thousands:    1_000,
+        one:         1,
+        ten:         10,
+        hundred:     100,
+        thousand:    10**3,
+        million:     10**6,
       },
       short: {
-        millions:     1_000,
-        billions:     1_000,
-        trillions:    1_000,
-        quadrillions: nil,
+        billion:     10**9,
+        trillion:    10**12,
+        quadrillion: 10**15,
       },
       long: {
-        millions:     1_000_000,
-        billions:     1_000_000,
-        trillions:    1_000_000,
-        quadrillions: nil,
+        billion:     10**12,
+        trillion:    10**18,
+        quadrillion: 10**24,
       },
     }
 
-    refine ::Integer do
-      # Need Rafini::Integer for #odometer
-      # Need Rafini::Hash for #to_struct
-      # Need Rafini::Array for #per
-      [Rafini::Integer, Rafini::Hash, Rafini::Array].each{|mod| using mod}
-
-      def odoread(scale)
-        values = scale.values
-        keys = scale.keys;
-        counts = self.odometer(*values[0..-2])
-
-        string = "#{counts[0]} #{keys[0]}#{(counts[0]==1)? '' : 's'}"
-        (keys.length-1).downto(1) do |i|
-          if counts[i] > 0
-            string = "#{counts[i]} #{keys[i]}#{(counts[i]>1)? 's' : ''}"
-            string << " and #{counts[i-1]} #{keys[i-1]}#{(counts[i-1]>1)? 's' : ''}" if counts[i-1]>0
+    refine ::Hash do
+      def description
+        string = ''
+        reverse_each do |key, count|
+          s = (count==1)? '' : 's'
+          unless string.empty?
+            string << " and #{count} #{key}#{s}" if count > 0
             break
           end
+          next if count == 0
+          string << "#{count} #{key}#{s}"
         end
+        return string
+      end
+    end
 
-        hash = {}
-        keys.per(counts){|k,v| hash[k]=v}
-        hash[:to_s]=string
+    refine ::Integer do
+      using Rafini::Integer # Need Rafini::Integer for #odometer
+      using Rafini::Hash    # Need Rafini::Hash for #to_struct
 
-        return hash.to_struct
+      def odoread(scale, **kw, &blk)
+        counts = odometer(*scale.values, **kw)
+        ::Hash[scale.keys.zip(counts)].to_struct(&blk)
       end
 
       # Integer#sec2time
       # Returns a struct with the different time scales for number of seconds.
-      # Note that the month(4 weeks)/year(13 months) are not meant to be exact.
       #   10_000.sec2time.to_s #=> "2 hours and 46 minutes"
       #   10_000.sec2time.hour #=> 2
       def sec2time
-        self.odoread(SEC2TIME)
+        odoread(SEC2TIME, factors:false) do
+          def to_s
+            string = nil
+            SEC2TIME.keys.reverse_each do |key|
+              count=self[key]
+              if string
+                if count > 0
+                  string << " and #{count} #{key}"
+                  string << 's' if count > 1
+                end
+                break
+              end
+              next if count==0
+              string = "#{count} #{key}"
+              string << 's' if count > 1
+            end
+            string = "0 #{SEC2TIME.first[0]}s" unless string
+            string
+          end
+          def to_i
+            SEC2TIME.to_a.map{|k,v|v*self[k]}.sum.round
+          end
+        end
       end
 
       # 1_230.illion.to_s #=> "1.23k"
@@ -91,37 +114,42 @@ module Rafini
       #   m.quadrillions #=> 888
       #   m.to_s #=> "888Q" It rounds up 888.7!
       def illion(type=:short)
-        keys   = SCALE[:base].keys   + SCALE[type].keys
-        values = SCALE[:base].values + SCALE[type].values
-        counts = self.odometer(*values[0..-2])
-
-        string = nil
-        if self < 1_000
-          string = self.to_s
-        elsif self < 1_000_000
-          d = (self<10_000)? 2 : (self<100_000)? 1 : 0
-          m = (self/1000.0).round(d)
-          string = "#{m}k"
-        else
-          (keys.length-1).downto(4) do |i|
-            next unless counts[i]>0
-            n = counts[i]
-            if n < 1_000
-              d = (n<10)? 2 : (n<100)? 1 : 0
-              n = (n + counts[i-1]/values[i-1].to_f).round(d)
-            else
-              n = n.illion
+        scale = SCALE[:base].merge SCALE[type]
+        struct = odoread(scale, factors:false) do
+          def scale=(scale)
+            @scale=scale
+          end
+          def type=(type)
+            @type=type
+          end
+          def to_s
+            number = to_i
+            return number.to_s if number < 1_000
+            if number < 1_000_000
+              precision = (number<10_000)? 2 : (number<100_000)? 1 : 0
+              return "#{(number/1000.0).round(precision)}K"
             end
-            string = "#{n}#{keys[i][0].upcase}"
-            break
+            keys = @scale.keys.reverse_each
+            loop do
+              key = keys.next
+              n = self[key]
+              next if n == 0
+              if n < 1_000
+                precision = (n<10)? 2 : (n<100)? 1 : 0
+                scale = @scale[key].to_f
+                f = (number/scale).round(precision)
+                return "#{f}#{key[0].upcase}"
+              end
+              return "#{n.illion}#{key[0].upcase}"
+            end
+          end
+          def to_i
+            @scale.to_a.map{|k,v|v*self[k]}.sum
           end
         end
-
-        hash = {}
-        keys.per(counts){|k,v| hash[k]=v}
-        hash[:to_s] = string
-
-        return hash.to_struct
+        struct.type  = type
+        struct.scale = scale
+        return struct
       end
     end
   end

data/lib/rafini/string.rb

@@ -4,17 +4,17 @@ module Rafini
       # camelize:
       # 1) A camel kick, as in "I gotz camelized".
       # 2) "a_camel_kick" => "ACamelKick"
-      def camelize(sep=/_/)
-        self.split(sep).map{|word|word.capitalize }.join('')
+      def camelize(sep='_')
+        self.split(sep).map(&:capitalize).join
       end
 
       # semantic:
       # 'a.b.c'.semantic(1) #=> 'b'
       # 'a.b.c'.semantic(0..1) #=> 'a.b'
-      # 'a.b.c'.semantic(0..2, '/') #=> 'b/c'
-      # 'a/b/c'.semantic(0..2, '.', /\//) #=> 'a.b.c'
-      def semantic(v,s='.',sx=/\./)
-        [*self.split(sx)[v]].join(s)
+      # 'a.b.c'.semantic(0..2, join:'/') #=> 'b/c'
+      # 'a/b/c'.semantic(0..2, split:'/', join:'.') #=> 'a.b.c'
+      def semantic(v=(0..2), split:'.', join:'.')
+        [*self.split(split)[v]].join(join)
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rafini
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 3.0.210112
 platform: ruby
 authors:
 - carlosjhr64
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-08-15 00:00:00.000000000 Z
+date: 2021-01-12 00:00:00.000000000 Z
 dependencies: []
 description: 'Just a collection of useful refinements.
 
@@ -31,7 +31,7 @@ homepage: https://github.com/carlosjhr64/rafini
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -46,9 +46,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements:
-- 'ruby: ruby 2.7.1p83 (2020-03-31 revision a0c7c23c9c) [x86_64-linux]'
-rubygems_version: 3.1.2
-signing_key: 
+- 'ruby: ruby 3.0.0p0 (2020-12-25 revision 95aff21468) [x86_64-linux]'
+rubygems_version: 3.2.3
+signing_key:
 specification_version: 4
 summary: Just a collection of useful refinements.
 test_files: []