rafini 1.0.0 → 3.0.210112

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: bcf2292d9da70068c6595c31195265cacea43c9d
-  data.tar.gz: 9dcab18064c2eeb25340182f22e26632141f82f0
+SHA256:
+  metadata.gz: df4dc73d0b92dcd762d1c741eb30f8dcfc56fdd84d18bfdbc2435290d9a3df97
+  data.tar.gz: c7764c8ae13bb99ff51977d7b52f926eee9083e5db6f75e43c860c2eb9557715
 SHA512:
-  metadata.gz: 404b14d5065305fa3c792bb6f3b43af65f292e99d3a2b50c89db45fa2fa16bf9e8468af4f5c65e95de6e401a21c3d46a06d752e93e8b97d85c0ec81f6267739d
-  data.tar.gz: c41acda381c48132bee1dd21115db290059387f04d7c1b4ce914f2b780fc7de679a302d23a9c75a02e905f6856d4aba146d80cc9edc8e1465f54215c1ae95105
+  metadata.gz: eb0f6fcdf17d108b75ddd5af587ceb7fe2d6294e8134cfeae90807f62607d49e158754903526f49b22fb6522a4ded0cf2f1522ad9c1305f295b9bd858cad9714
+  data.tar.gz: 8b327f489cfa71d77eca28df39b4408fcf8c7c4c8e7ed233c10f05e242bcfee0936a96f97e5bb8eee0fa4f49a058bc7b754fc549ab47d8e70574e756ccdc1d93

data/README.md

@@ -0,0 +1,159 @@
+# 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
+
+```ruby
+require 'rafini/array'
+using Rafini::Array
+
+# 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"
+
+# is
+[:a,:b,:c].is(true) #=> {:a=>true, :b=>true, :c=>true}
+```
+### Rafini::Empty
+
+```ruby
+require 'rafini/empty'
+include Rafini::Empty
+s0 #=> ""
+a0 #=> []
+h0 #=> {}
+[s0,a0,h0].all?(&:frozen?) #=> true
+```
+
+### using Rafini::Exception
+
+```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
+
+```ruby
+require 'rafini/hash'
+using Rafini::Hash
+
+# 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"
+
+# supplement
+{a:'A',b:'B'}.supplement({b:'X',c:'C'},{c:'Y',d:'D'}) #=> {:a=>"A", :b=>"B", :c=>"C", :d=>"D"}
+
+# amend
+{a:'A',b:'B'}.amend({b:'X',c:'C'},{c:'Y',d:'D'}) #=> {:a=>"A", :b=>"X"}
+```
+
+### using Rafini::Integer
+
+```ruby
+require 'rafini/integer'
+using Rafini::Integer
+
+# odometer
+123.odometer(10,10) #=> [3, 2, 1]
+30.odometer(2,3,5)  #=> [0, 0, 0, 1]
+```
+
+### using Rafini::Odometers
+
+```ruby
+require 'rafini/odometers'
+using Rafini::Odometers
+
+# sec2time
+12501.sec2time.to_s #=> "3 hours and 28 minutes"
+
+# illion
+3_512_325.illion.to_s #=> "3.51M"
+```
+
+### using Rafini::String
+
+```ruby
+require 'rafini/string'
+using Rafini::String
+
+# camelize
+'a_camel_kick'.camelize #=> "ACamelKick"
+
+# semantic
+'1.2.3'.semantic(0..1) #=> "1.2"
+```
+
+## LICENSE:
+
+(The MIT License)
+
+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
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/rafini.rb

@@ -1,13 +1,12 @@
-require 'rafini/version'
-
-require 'rafini/array'
-require 'rafini/exception'
-require 'rafini/hash'
-require 'rafini/integer'
-require 'rafini/string'
-
-require 'rafini/odometers'
-require 'rafini/empty'
-
+module Rafini
+  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,59 +1,42 @@
 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 > 1
-          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
-      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"
-      def which
-        self.each{|obj| return obj if yield(obj)}
-        return nil
+        return string
       end
 
       # [: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
   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/exception.rb

@@ -1,7 +1,6 @@
 module Rafini
   module Exception
     refine ::Exception do
-
       # $!.puts outputs to standard error what went bang!
       # The given message is what you normally want to see.
       # The exeption message is also shown if in verbose mode.

data/lib/rafini/hash.rb

@@ -1,33 +1,18 @@
 module Rafini
   module Hash
     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)
@@ -35,24 +20,24 @@ 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
-
+      def amend(...)
+        self.dup.amend!(...)
+      end
     end
   end
 end

data/lib/rafini/integer.rb

@@ -1,26 +1,28 @@
 module Rafini
   module Integer
     refine ::Integer do
-
       # odometer
       # Kinda hard to explain...
       #   123.odometer(10,10) #=> [3,2,1]
       #   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
+
+        levels = levels.inject([1]){|m, f| m.push(m.last*f)} if factors
+        levels.shift
 
-        (p.length-1).downto(0) do |i|
-          y = n/m; r.unshift y
-          n = n%m
-          f = p[i]; m = m/f
+        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,80 +1,103 @@
+require 'rafini/integer'
+require 'rafini/hash'
+
 module Rafini
   module Odometers
-    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}
+    # 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:       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,
+    }
 
-      def odoread(scale)
-        values = scale.values
-        keys = scale.keys;
-        counts = self.odometer(*values[0..-2])
+    SCALE = { # levels
+      base: {
+        one:         1,
+        ten:         10,
+        hundred:     100,
+        thousand:    10**3,
+        million:     10**6,
+      },
+      short: {
+        billion:     10**9,
+        trillion:    10**12,
+        quadrillion: 10**15,
+      },
+      long: {
+        billion:     10**12,
+        trillion:    10**18,
+        quadrillion: 10**24,
+      },
+    }
 
-        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
 
-      SEC2TIME = {
-          second:     60,
-          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,
-      }
-
       # 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
 
-      SCALE = {
-        base: {
-          ones:         10,
-          tens:         10,
-          hundreds:     10,
-          thousands:    1_000,
-        },
-        short: {
-          millions:     1_000,
-          billions:     1_000,
-          trillions:    1_000,
-          quadrillions: nil,
-        },
-        long: {
-          millions:     1_000_000,
-          billions:     1_000_000,
-          trillions:    1_000_000,
-          quadrillions: nil,
-        },
-      }
-
       # 1_230.illion.to_s #=> "1.23k"
       # 1_230_000.illion.to_s #=> "1.23M"
       # ...etc
@@ -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,8 +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, 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,24 +1,24 @@
 --- !ruby/object:Gem::Specification
 name: rafini
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 3.0.210112
 platform: ruby
 authors:
 - carlosjhr64
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-12-25 00:00:00.000000000 Z
+date: 2021-01-12 00:00:00.000000000 Z
 dependencies: []
-description: |
-  Just a collection of useful refinements.
+description: 'Just a collection of useful refinements.
+
+  '
 email: carlosjhr64@gmail.com
 executables: []
 extensions: []
-extra_rdoc_files:
-- README.rdoc
+extra_rdoc_files: []
 files:
-- README.rdoc
+- README.md
 - lib/rafini.rb
 - lib/rafini/array.rb
 - lib/rafini/empty.rb
@@ -27,15 +27,12 @@ files:
 - lib/rafini/integer.rb
 - lib/rafini/odometers.rb
 - lib/rafini/string.rb
-- lib/rafini/version.rb
 homepage: https://github.com/carlosjhr64/rafini
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
-rdoc_options:
-- "--main"
-- README.rdoc
+post_install_message:
+rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
@@ -49,11 +46,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements:
-- 'ruby: ruby 2.1.3p242 (2014-09-19 revision 47630) [x86_64-linux]'
-rubyforge_project: 
-rubygems_version: 2.4.1
-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: []
-has_rdoc: 

data/README.rdoc

@@ -1,114 +0,0 @@
-= rafini
-
-== DESCRIPTION:
-
-Just a collection of useful refinements.
-
-== SYNOPSIS:
-
-=== using Rafini::Array
-
-   # joins
-   ['a','b','c','d','e','f'].joins('-','-',' '){':'} #=> "a-b-c d:e:f"
-
-   # per
-   h={}
-   ['a','b','c'].per(['A','B','C']){|l,u| h[l]=u}
-   h #=> {'a'=>'A','b'=>'B','c'=>'C'}
-
-   # which
-   ['dog','cat','bunny'].which{|a|a=~/c/} #=> "cat"
-
-   # is
-   [:a,:b,:c].is(true) #=> {a: true, b: true, c: true}
-
-   # any?
-   [:a,:b,:c].any?(:b,:d) #=> 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
-
-=== 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'}
-
-   # supplement
-   {a:'A',b:'B'}.supplement({b:'X',c:'C'},{c:'Y',d:'D'}) #=> {a:'A',b:'B',c:'C',d:'D'}
-
-   # 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]
-
-=== using Rafini::Odometers
-
-   # sec2time
-   12501.sec2time.to_s #=> "3 hours and 28 minutes"
-
-   # illion
-   3_512_325.illion.to_s #=> "3.51M"
-
-=== using Rafini::String
-
-   # camelize
-   'a_camel_kick'.camelize #=> "ACamelKick"
-
-=== Rafini::Empty
-
-   STRING, ARRAY, HASH = ''.frozen, [].frozen, {}.frozen
-
-== INSTALL:
-
-  $ sudo gem install rafini
-
-== LICENSE:
-
-(The MIT License)
-
-Copyright (c) 2014 carlosjhr64
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-'Software'), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/rafini/version.rb

@@ -1,3 +0,0 @@
-module Rafini
-  VERSION = '1.0.0'
-end