rafini 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e7c87ce3266c62021f2ab485feacfcd7f6a612fa
+  data.tar.gz: d743b0e9354aca2a885d9c3fd4d472df72d66da5
+SHA512:
+  metadata.gz: 10909f1435a0dcf339c1f47fbd955fe39497834e65a9bd5e31166b9d3ace6505cd4d6291c37c0a471f49f40f3a152b26625891944143a9cbdb77e709d71d8420
+  data.tar.gz: 299b09b91808ff9219d27f61ebbc3a3a28b14a6b574e4729421cc47e700372481cee73d191662a40ebe5285db0a2ef11f4974665ba27fc0b99190a289a454ef8

data/README.rdoc

@@ -0,0 +1,92 @@
+= 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'}
+
+=== 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'
+
+=== 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"
+
+== 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/array.rb

@@ -0,0 +1,42 @@
+module Rafini
+  module Array
+    refine ::Array do
+
+      # string = array.joins(sep1,sep2,sep3,...){|i| sep[i]}
+      #
+      # Returns a string created by converting each element of the array to
+      # a string, separated by the given 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
+        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
+
+    end
+  end
+end

data/lib/rafini/exception.rb

@@ -0,0 +1,58 @@
+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.
+      # Backtrace is shown if in debug mode.
+      #   begin
+      #     raise 'Ugly message'
+      #   rescue RuntimeError
+      #     # exact output depends on $VERBOSE and $DEBUG
+      #     $!.puts('Nice message')
+      #   end
+      def puts(message=nil)
+        unless $VERBOSE.nil? then
+          $stderr.puts message if message
+          $stderr.puts self.message if $VERBOSE or !message
+          $stderr.puts self.backtrace.to_s if $DEBUG
+        end
+      end
+    end
+  end
+end
+
+using Rafini::Exception
+
+# Module version of puts bang!
+# Returns either the value or error of the block.
+#   value = Rafini.bang!('Ooops! Not perfect?') do
+#     # Perfect code here...
+#   end
+def Rafini.bang!(message=nil, bang=Exception, &block)
+  value = nil
+  begin
+    value = block.call
+  rescue bang => value
+    value.puts(message)
+  end
+  return value
+end
+
+# The Thread wrapped version of bang!
+# I often do
+#  Thread.new do
+#    begin
+#      ... stuff ..
+#    rescue Exception
+#      puts 'blah blah...'
+#      puts $!.message if $VERBOSE
+#      puts $!.backtrace if $DEBUG
+#    end
+#  end
+# With the following below, I'll be able to say
+# Rafini.thread_bang!('blah blah...'){ ...stuff... }
+def Rafini.thread_bang!(header=nil, bang=Exception, &block)
+  Thread.new{Rafini.bang!(header, bang, &block)}
+end

data/lib/rafini/hash.rb

@@ -0,0 +1,12 @@
+module Rafini
+  module Hash
+    refine ::Hash do
+
+      # struct = hash.to_struct
+      # Why not?
+      def to_struct
+        Struct.new(*self.keys).new(*self.values)
+      end
+    end
+  end
+end

data/lib/rafini/integer.rb

@@ -0,0 +1,27 @@
+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 = []
+
+        (p.length-1).downto(0) do |i|
+          y = n/m; r.unshift y
+          n = n%m
+          f = p[i]; m = m/f
+        end
+        r.unshift n
+
+        return r
+      end
+    end
+  end
+end

data/lib/rafini/odometers.rb

@@ -0,0 +1,128 @@
+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}
+
+      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
+            break
+          end
+        end
+
+        hash = {}
+        keys.per(counts){|k,v| hash[k]=v}
+        hash[:to_s]=string
+
+        return hash.to_struct
+      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)
+      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
+      # Does both short and long scales, short by default.
+      # Returns a struct with the different scales of the number
+      #   m = 888_777_666_555_444_321.illion
+      #   m.ones #=> 1
+      #   m.tens #=> 2
+      #   m.hundreds #=> 3
+      #   m.thousands #=> 444
+      #   m.millions #=> 555
+      #   m.billions #=> 666
+      #   m.trillions #=> 777
+      #   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
+            end
+            string = "#{n}#{keys[i][0].upcase}"
+            break
+          end
+        end
+
+        hash = {}
+        keys.per(counts){|k,v| hash[k]=v}
+        hash[:to_s] = string
+
+        return hash.to_struct
+      end
+    end
+  end
+end

data/lib/rafini/string.rb

@@ -0,0 +1,12 @@
+module Rafini
+  module String
+    refine ::String do
+      # 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('')
+      end
+    end
+  end
+end

data/lib/rafini/version.rb

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

data/lib/rafini.rb

@@ -0,0 +1,12 @@
+require 'rafini/version'
+
+require 'rafini/array'
+require 'rafini/exception'
+require 'rafini/hash'
+require 'rafini/integer'
+require 'rafini/string'
+
+require 'rafini/odometers'
+
+# Requires:
+#`ruby`

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: rafini
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- carlosjhr64
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-11 00:00:00.000000000 Z
+dependencies: []
+description: |
+  Just a collection of useful refinements.
+email: carlosjhr64@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.rdoc
+files:
+- README.rdoc
+- lib/rafini.rb
+- lib/rafini/array.rb
+- lib/rafini/exception.rb
+- lib/rafini/hash.rb
+- 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
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !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: 
+specification_version: 4
+summary: Just a collection of useful refinements.
+test_files: []
+has_rdoc: