epitools 0.5.1 → 0.5.2

data/lib/epitools/core_ext/numbers.rb

@@ -0,0 +1,254 @@
+class Numeric
+
+  def integer?; true; end
+
+  def truthy?; self > 0; end
+
+  def commatize  
+    to_s.gsub(/(\d)(?=\d{3}+(?:\.|$))(\d{3}\..*)?/,'\1,\2')
+  end
+
+  #
+  # Time methods
+  #
+  {
+  
+    'second'  => 1,
+    'minute'  => 60,
+    'hour'    => 60 * 60,
+    'day'     => 60 * 60 * 24,
+    'week'    => 60 * 60 * 24 * 7,
+    'month'   => 60 * 60 * 24 * 30,
+    'year'    => 60 * 60 * 24 * 365,
+    
+  }.each do |unit, scale|
+    define_method(unit)     { self * scale }
+    define_method(unit+'s') { self * scale }
+  end
+  
+  def ago
+    Time.now - self
+  end
+  
+  def from_now
+    Time.now + self
+  end
+
+  #
+  # If `n.times` is like `each`, `n.things` is like `map`. Return 
+  #  
+  def things(&block)
+    if block_given?
+      Array.new(self, &block)
+    else
+      Array.new(self)
+    end
+  end
+
+  [:cos,
+   :sin,
+   :tan,
+   :acos,
+   :asin,
+   :atan,
+   :cosh,
+   :sinh,
+   :tanh,
+   :acosh,
+   :asinh,
+   :atanh,
+   :exp,
+   :log2,
+   :log10,
+   :sqrt,
+   :cbrt,
+   :frexp,
+   :erf,
+   :erfc,
+   :gamma,
+   :lgamma
+  ].each do |meth|
+
+    class_eval %{
+      def #{meth}
+        Math.#{meth}(self)
+      end
+    }
+
+  end
+
+  def log(n)
+    Math.log(self, n)
+  end
+
+end
+
+
+class Integer
+  
+  #
+  # 'true' if the integer is 0
+  #
+  def blank?; self == 0; end
+
+  #
+  # Convert the number into a hexadecimal string representation.
+  # (Identical to to_s(16), except that numbers < 16 will have a 0 in front of them.)
+  #
+  def to_hex
+    "%0.2x" % self
+  end
+    
+  #
+  # Convert the number to an array of bits (least significant digit first, or little-endian).
+  #
+  def to_bits
+    # TODO: Why does thos go into an infinite loop in 1.8.7?
+    ("%b" % self).chars.to_a.reverse.map(&:to_i)
+  end
+  alias_method :bits, :to_bits
+  
+  #
+  # Cached constants for base62 encoding
+  #
+  BASE62_DIGITS   = ['0'..'9', 'A'..'Z', 'a'..'z'].map(&:to_a).flatten 
+  BASE62_BASE     = BASE62_DIGITS.size
+
+  #
+  # Convert a number to a string representation (in "base62" encoding).
+  # 
+  # Base62 encoding represents the number using the characters: 0..9, A..Z, a..z
+  #
+  # It's the same scheme that url shorteners and YouTube uses for their
+  # ID strings. (eg: http://www.youtube.com/watch?v=dQw4w9WgXcQ)
+  #
+  def to_base62
+    result = []
+    remainder = self
+    max_power = ( Math.log(self) / Math.log(BASE62_BASE) ).floor
+    
+    max_power.downto(0) do |power|
+      divisor = BASE62_BASE**power
+      #p [:div, divisor, :rem, remainder]      
+      digit, remainder = remainder.divmod(divisor)
+      result << digit
+    end
+    
+    result << remainder if remainder > 0
+    
+    result.map{|digit| BASE62_DIGITS[digit]}.join ''
+  end
+
+  #
+  # Returns the all the prime factors of a number.
+  #
+  def factors
+    Prime # autoload the prime module
+    prime_division.map { |n,count| [n]*count }.flatten 
+  end
+
+  #
+  # Factorial (iterated style)
+  #
+  def fact
+    total = 1
+    self.downto(2) { |x| total *= x }
+    total
+  end
+  alias_method :factorial, :fact
+
+  #
+  # Fibonacci (recursive style)
+  #
+  def fib
+    self < 2 ? self : (self-1).fib + (self-2).fib
+  end
+  alias_method :fibonacci, :fib
+
+  #
+  # Convert seconds to hours:minutes:seconds (hours is dropped if it's zero)
+  #
+  def to_hms
+    seconds = self
+
+    days, seconds    = seconds.divmod(86400)
+    hours, seconds   = seconds.divmod(3600)
+    minutes, seconds = seconds.divmod(60)
+
+    result = "%0.2d:%0.2d" % [minutes,seconds]
+    result = ("%0.2d:" % hours) + result   if hours > 0 or days > 0
+    result = ("%0.2d:" % days) + result    if days > 0
+
+    result
+  end
+
+end
+
+#
+# Monkeypatch [] into Bignum and Fixnum using class_eval.
+#
+# (This is necessary because [] is defined directly on the classes, and a mixin
+#  module will still be overridden by Big/Fixnum's native [] method.)
+#
+[Bignum, Fixnum].each do |klass|
+  
+  klass.class_eval do
+    
+    alias_method :bit, :"[]"
+    
+    #
+    # Extends [] so that Integers can be sliced as if they were arrays.
+    #
+    def [](arg)
+      case arg
+      when Integer
+        self.bit(arg)
+      when Range
+        self.bits[arg]
+      end
+    end
+    
+  end
+  
+end
+
+class Time
+
+  #
+  # Relative time, in words. (eg: "1 second ago", "2 weeks from now", etc.)
+  #
+  def in_words
+    delta   = (Time.now-self).to_i
+    a       = delta.abs
+    
+    amount  = case a
+      when 0
+        'just now'
+      when 1
+        '1 second'
+      when 2..59
+        "second".amount(a)
+      when 1.minute...1.hour
+        "minute".amount(a/1.minute)
+      when 1.hour...1.day
+        "hour".amount(a/1.hour)
+      when 1.day...7.days
+        "day".amount(a/1.day)
+      when 1.week...1.month
+        "week".amount(a/1.week)
+      when 1.month...12.months
+        "month".amount(a/1.month)
+      else
+        "year".amount(a/1.year)
+    end
+    
+    if delta < 0
+      amount += " from now"
+    elsif delta > 0
+      amount += " ago"
+    end
+    
+    amount
+  end
+  
+end

data/lib/epitools/core_ext/object.rb

@@ -0,0 +1,195 @@
+class Object
+
+  #
+  # Return a hash of local variables in the caller's scope: {:variable_name=>value} 
+  #
+  def locals
+    require 'binding_of_caller'
+    caller = binding.of_caller(1)
+    vars = caller.eval("local_variables").reject{|e| e[/^_/]}
+    vals = caller.eval("[ #{vars.join(",")} ]")
+    Hash[ vars.zip(vals) ]
+  end
+  
+
+  #
+  # Gives you a copy of the object with its attributes changed to whatever was
+  # passed in the options hash.
+  #
+  # Example:
+  #   >> cookie = Cookie.new(:size=>10, :chips=>200)
+  #   => #<Cookie:0xffffffe @size=10, @chips=200>
+  #   >> cookie.with(:chips=>50)
+  #   => #<Cookie:0xfffffff @size=10, @chips=50>
+  #
+  # (All this method does is dup the object, then call "key=(value)" for each
+  # key/value in the options hash.)
+  #  
+  def with(options={})
+    obj = dup
+    options.each { |key, value| obj.send "#{key}=", value }
+    obj
+  end
+  
+  #
+  # Return a copy of the class with modules mixed into it.
+  #
+  def self.using(*args)
+    if block_given?
+      yield using(*args)
+    else
+      copy = self.dup
+      args.each { |arg| copy.send(:include, arg) }
+      copy
+    end
+  end
+  
+  #
+  # Turns block-accepting iterator methods (eg: each) into methods that return an
+  # Enumerator when they're called called without a block.
+  #
+  # It can transform many methods at once (eg: `enumerable :each, :all_people`).
+  #
+  # Example:
+  #
+  #   def lots_of_stuff
+  #     @stuff.each { |thing| yield thing }
+  #   end
+  #
+  #   enumerable :lots_of_stuff
+  #
+  # Now you can use it like an Enumerator: object.lots_of_stuff.with_index.sort.zip(99..1000)
+  #
+  def self.enumerable *meths
+    meths.each do |meth|
+      alias_method "#{meth}_without_enumerator", meth
+      class_eval %{
+        def #{meth}(*args, &block)
+          return Enum.new(self, #{meth.inspect}, *args, &block) unless block_given?
+          #{meth}_without_enumerator(*args, &block)
+        end
+      }
+    end
+  end
+  alias_class_method :enumerator, :enumerable
+
+  #
+  # Instead of:
+  #   if cookie_jar.include? cookie
+  # Now you can do:
+  #   if cookie.in? cookie_jar
+  #
+  def in?(enum)
+    enum.include? self
+  end
+
+  #
+  # Instead of:
+  #   @person ? @person.name : nil
+  # Now you can do:
+  #   @person.try(:name)
+  #
+  def try(method, *args, &block)
+    send(method, *args, &block) if respond_to? method
+  end
+
+  #
+  # Serialize this object to a binary String, using Marshal.dump.
+  #
+  def marshal
+    Marshal.dump self
+  end
+  alias_method :to_marshal, :marshal
+
+  #
+  # Serialize this object to YAML.
+  #  
+  def to_yaml
+    YAML::dump(self)
+  end
+  
+  #
+  # Serialize this object to JSON (defaults to "pretty" indented JSON).
+  #  
+  def to_json(pretty=true)
+    pretty ? JSON::pretty_generate(self) : JSON.dump(self)
+  end
+
+  #
+  # Proper grammar.
+  #  
+  alias_method :is_an?, :is_a?
+  alias_method :responds_to?, :respond_to?
+
+  #
+  # Emit a quick debug message (only if $DEBUG is true)
+  #
+  def dmsg(msg)
+    if $DEBUG
+      case msg
+      when String
+        puts msg
+      else
+        puts msg.inspect
+      end
+    end
+  end
+  
+  #
+  # Time a block.
+  #
+  def time(message=nil)
+    start = Time.now
+    result = yield
+    elapsed = Time.now - start
+    
+    print "[#{message}] " if message
+    puts "elapsed time: %0.5fs" % elapsed
+    result
+  end
+  
+  #
+  # Quick and easy benchmark.
+  #
+  # Examples:
+  #   bench { something }
+  #   bench(90000000) { something }
+  #   bench :fast => proc { fast_method }, :slow => proc { slow_method }
+  #
+  # In Ruby 1.9:
+  #   bench fast: ->{ fast_method }, slow: ->{ slow_method }
+  #
+  def bench(*args, &block)
+      
+    # Shitty perl-esque hack to let the method take all the different kind of arguments.
+    opts  = Hash === args.last ? args.pop : {}
+    n     = args.first || 100
+  
+    if opts.any?
+    
+      raise "Error: Supply either a do/end block, or procs as options. Not both." if block_given?
+      raise "Error: Options must be procs." unless opts.all? { |k, v| v.is_a?(Proc) }
+
+      benchblock = proc do |bm|
+        opts.each do |name, blk|
+          bm.report(name.to_s) { n.times &blk }
+        end
+      end
+      
+    elsif block_given?
+    
+      benchblock = proc do |bm|
+        bm.report { n.times &block }
+      end
+      
+    else
+      raise "Error: Must supply some code to benchmark."
+    end
+    
+    puts "* Benchmarking #{n} iterations..."
+    Benchmark.bmbm(&benchblock)
+  end
+  
+end
+
+

data/lib/epitools/core_ext/string.rb

@@ -0,0 +1,338 @@
+require 'epitools/core_ext/numbers'
+
+class String
+  
+  #
+  # Could this string be cast to an integer?
+  #
+  def integer?
+    strip.match(/^\d+$/) ? true : false
+  end
+
+  #
+  # 'true' if the string's length is 0 (after whitespace has been stripped from the ends)
+  #
+  def blank?
+    strip.size == 0
+  end
+
+  #
+  # Does this string contain something that means roughly "true"?
+  #
+  def truthy?
+    case strip.downcase
+    when "1", "true", "yes", "on", "enabled", "affirmative"
+      true
+    else
+      false
+    end
+  end
+
+  #
+  # Convert \r\n to \n
+  #
+  def to_unix
+    gsub("\r\n", "\n")
+  end
+  
+  #
+  # Remove redundant whitespaces (not including newlines).
+  #
+  def tighten
+    gsub(/[\t ]+/,' ').strip
+  end
+
+  #
+  # Remove redundant whitespace AND newlines.
+  #
+  def dewhitespace
+    gsub(/\s+/,' ').strip
+  end
+
+  #
+  # Remove ANSI color codes.
+  #
+  def strip_color
+    gsub(/\e\[.*?(\d)+m/, '')
+  end
+  alias_method :strip_ansi, :strip_color 
+
+  #
+  # Like #lines, but skips empty lines and removes \n's.
+  #
+  def nice_lines
+    # note: $/ is the platform's newline separator
+    split($/).select{|l| not l.blank? }
+  end
+  
+  alias_method :nicelines,   :nice_lines
+  alias_method :clean_lines, :nice_lines
+
+  #
+  # The Infamous Caesar-Cipher. Unbreakable to this day.
+  #
+  def rot13
+    tr('n-za-mN-ZA-M', 'a-zA-Z')
+  end
+  
+  #
+  # Convert non-URI characters into %XXes.
+  #
+  def urlencode
+    URI.escape(self)
+  end
+  
+  #
+  # Convert an URI's %XXes into regular characters.
+  #
+  def urldecode
+    URI.unescape(self)
+  end
+
+  #
+  # Convert a query string to a hash of params
+  #
+  def to_params
+    CGI.parse(self).map_values do |v|
+      # CGI.parse wraps every value in an array. Unwrap them!
+      if v.is_a?(Array) and v.size == 1
+        v.first
+      else
+        v 
+      end
+    end      
+  end
+  
+
+  #
+  # Cached constants for base62 decoding.
+  #  
+  BASE62_DIGITS  = Hash[ Integer::BASE62_DIGITS.zip((0...Integer::BASE62_DIGITS.size).to_a) ]
+  BASE62_BASE    = Integer::BASE62_BASE
+  
+  #
+  # Convert a string (encoded in base16 "hex" -- for example, an MD5 or SHA1 hash)
+  # into "base62" format. (See Integer#to_base62 for more info.)  
+  #
+  def to_base62
+    to_i(16).to_base62
+  end
+  
+  #
+  # Convert a string encoded in base62 into an integer.
+  # (See Integer#to_base62 for more info.)
+  #
+  def from_base62
+    accumulator = 0
+    digits = chars.map { |c| BASE62_DIGITS[c] }.reverse
+    digits.each_with_index do |digit, power|
+      accumulator += (BASE62_BASE**power) * digit if digit > 0
+    end
+    accumulator
+  end
+
+  #
+  # Decode a mime64/base64 encoded string
+  #
+  def from_base64
+    Base64.decode64 self
+  end
+  alias_method :decode64, :from_base64 
+  
+  #
+  # Encode into a mime64/base64 string
+  #
+  def to_base64
+    Base64.encode64 self
+  end
+  alias_method :base64,   :to_base64
+  alias_method :encode64, :to_base64
+
+  #
+  # MD5 the string
+  #  
+  def md5
+    Digest::MD5.hexdigest self
+  end
+  
+  #
+  # SHA1 the string
+  #  
+  def sha1
+    Digest::SHA1.hexdigest self
+  end
+  
+  #
+  # gzip the string
+  #
+  def gzip(level=nil)
+    zipped = StringIO.new
+    Zlib::GzipWriter.wrap(zipped, level) { |io| io.write(self) }
+    zipped.string
+  end
+  
+  #
+  # gunzip the string
+  #
+  def gunzip
+    data = StringIO.new(self)
+    Zlib::GzipReader.new(data).read
+  end
+  
+  #
+  # deflate the string
+  #
+  def deflate(level=nil)
+    Zlib::Deflate.deflate(self, level)
+  end
+  
+  #
+  # inflate the string
+  #
+  def inflate
+    Zlib::Inflate.inflate(self)
+  end
+  
+  # `true` if this string starts with the substring 
+  #  
+  def startswith(substring)
+    self[0...substring.size] == substring
+  end
+  
+  #
+  # `true` if this string ends with the substring 
+  #  
+  def endswith(substring)
+    self[-substring.size..-1] == substring
+  end
+
+  #
+  # Parse this string as JSON
+  #
+  def from_json
+    JSON.parse(self)
+  end
+  
+  #
+  # Parse this string as YAML
+  #
+  def from_yaml
+    YAML.parse(self).to_ruby
+  end
+
+  #
+  # Unmarshal the string (transform it into Ruby datatypes).
+  #  
+  def unmarshal
+    Marshal.restore self
+  end
+  alias_method :from_marshal, :unmarshal
+
+  #
+  # Convert the string to a Path object.
+  #
+  def as_path
+    Path[self]
+  end
+  alias_method :to_p, :as_path
+  
+  #
+  # Convert this string into a string describing this many of the string.
+  # (Note: Doesn't know anything about proper grammar.)
+  #
+  # Example:
+  #   "cookie".amount(0)    #=> "0 cookies"
+  #   "shirt".amount(17)    #=> "17 shirts"
+  #   "dollar".amount(-10)  #=> "-10 dollars"
+  #   "love".amount(1)      #=> "1 love"
+  #
+  def amount(n)
+    case n
+    when 0 
+      "0 #{self}s"
+    when 1, -1
+      "#{n} #{self}"
+    else
+      "#{n} #{self}s"
+    end
+  end
+  
+  
+  unless public_method_defined? :to_proc
+  
+    #  
+    # String#to_proc
+    #
+    # See http://weblog.raganwald.com/2007/10/stringtoproc.html
+    #
+    # Ported from the String Lambdas in Oliver Steele's Functional Javascript
+    # http://osteele.com/sources/javascript/functional/
+    #
+    # This work is licensed under the MIT License:
+    #
+    # (c) 2007 Reginald Braithwaite
+    # Portions Copyright (c) 2006 Oliver Steele
+    # 
+    # 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.
+    #
+    def to_proc &block
+      params = []
+      expr = self
+      sections = expr.split(/\s*->\s*/m)
+      if sections.length > 1 then
+          eval_block(sections.reverse!.inject { |e, p| "(Proc.new { |#{p.split(/\s/).join(', ')}| #{e} })" }, block)
+      elsif expr.match(/\b_\b/)
+          eval_block("Proc.new { |_| #{expr} }", block)
+      else
+          leftSection = expr.match(/^\s*(?:[+*\/%&|\^\.=<>\[]|!=)/m)
+          rightSection = expr.match(/[+\-*\/%&|\^\.=<>!]\s*$/m)
+          if leftSection || rightSection then
+              if (leftSection) then
+                  params.push('$left')
+                  expr = '$left' + expr
+              end
+              if (rightSection) then
+                  params.push('$right')
+                  expr = expr + '$right'
+              end
+          else
+              self.gsub(
+                  /(?:\b[A-Z]|\.[a-zA-Z_$])[a-zA-Z_$\d]*|[a-zA-Z_$][a-zA-Z_$\d]*:|self|arguments|'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"/, ''
+              ).scan(
+                /([a-z_$][a-z_$\d]*)/i
+              ) do |v|  
+                params.push(v) unless params.include?(v)
+              end
+          end
+          eval_block("Proc.new { |#{params.join(', ')}| #{expr} }", block)
+      end
+    end
+    
+    private
+    
+    def eval_block(code, block)
+      eval code, block && block.binding
+    end
+    
+  end # unless public_method_defined? :to_proc
+  
+end
+
+