rext 0.3.4

data/lib/rext/date.rb

@@ -0,0 +1,6 @@
+
+#--
+# Load Date specific rext extensions.
+#++
+
+require 'rext/date/helpers'

data/lib/rext/date/helpers.rb

@@ -0,0 +1,11 @@
+
+class Date
+  
+  ##
+  # Convert Date to a Time instance.
+  
+  def to_time form = :utc
+    Time.send form, year, month, day
+  end
+  
+end

data/lib/rext/enumerable.rb

@@ -0,0 +1,6 @@
+
+#--
+# Load Enumerable specific rext extensions.
+#++
+
+require 'rext/enumerable/helpers'

data/lib/rext/enumerable/helpers.rb

@@ -0,0 +1,88 @@
+
+require 'rext/module/helpers'
+require 'rext/proc/helpers'
+
+module Enumerable
+  
+  ##
+  # Proxy
+  #
+  # The enumerable proxy class is utilized to
+  # allow methods such as #group_by, #map, and others
+  # to provide a method call alternative to a block.
+  #
+  # For example words.group_by { |word| word.length } can
+  # be replaced by words.group_by_.length
+  #
+  # === See
+  #
+  # * Enumerable#proxy
+  #
+  
+  class Proxy 
+    instance_methods.each { |m| undef_method m unless m.match(/^__/) }
+    
+    def initialize object, meth
+      @object, @method = object, meth
+    end
+
+    def method_missing meth, *args, &block
+      @object.__send__(@method) { |o| o.__send__(meth, *args, &block) }
+    end
+  end
+  
+  ##
+  # Shortcut for Proxy.new self, +meth+.
+  
+  def proxy meth
+    Proxy.new self, meth
+  end
+    
+  ##
+  # Return a hash grouped by +block+.
+  #
+  # === Examples
+  #
+  #   words = %w( just some foo bar )
+  #   words.group_by { |word| word.length }  # => {3=>["foo", "bar"], 4=>["just", "some"]}
+  #   words.group_by { length }              # => {3=>["foo", "bar"], 4=>["just", "some"]}
+  #   words.group_by.length                  # => {3=>["foo", "bar"], 4=>["just", "some"]}
+  #
+
+  def group_by &block
+    return proxy(:group_by) unless block
+    inject({}) do |hash, value|
+      (hash[block.yield_or_eval(value)] ||= []) << value
+      hash
+    end
+  end
+  
+  ##
+  # Sexy Symbol#to_proc replacement for mapping enums.
+  #
+  # === Examples
+  #    
+  #   names = %w( tj scott joe bob )
+  #   names.every.length.join          # => 2533
+  #   names.every.empty?.any?          # => false
+  #   names.every { length > 4 }.all?  # => true
+  #
+  
+  def every &block
+    block ? proxy(:map).instance_eval(&block) : proxy(:map)
+  end
+  
+  ##
+  # Check if all +args+ are included.
+  #
+  # === Examples
+  #    
+  #   permissions = 'save', 'edit', 'delete'
+  #   permissions.includes_all? 'save', 'edit'    # => true
+  #
+  
+  def includes_all? *args
+    args.all? { |arg| include? arg }
+  end
+  
+end

data/lib/rext/hash.rb

@@ -0,0 +1,6 @@
+
+#--
+# Load Hash specific rext extensions.
+#++
+
+require 'rext/hash/helpers'

data/lib/rext/hash/helpers.rb

@@ -0,0 +1,42 @@
+
+class Hash
+  
+  ##
+  # Delete key-value pairs, returning the values found
+  # using the +keys+ passed. Aliased as extract!
+  #
+  # === Examples
+  #
+  #   options = { :width => 25, :height => 100 }
+  #   width, height = options.delete_at :width, :height  
+  #
+  #   width   # => 25
+  #   height  # => 100
+  #   options # => {}
+  #
+  
+  def delete_at *keys
+    keys.map { |key| delete key }
+  end
+  alias :extract! :delete_at
+  
+  ##
+  # Return an array of switches and their arguments.
+  #
+  # === Examples
+  #
+  #   { :use_foobar => true }.switchify   # => ['--use-foobar']
+  #   { :use_foobar => false }.switchify  # => []
+  #   { :interval => 15, :icon => :jpeg } # => ['--interval', '15', '--icon', 'jpeg']
+  #
+  
+  def switchify
+    inject [] do |args, (key, value)|
+      next args unless value
+      args << key.to_s.switchify
+      args << (String === value ? value.inspect : value.to_s) unless value === true
+      args
+    end
+  end
+  
+end

data/lib/rext/integer.rb

@@ -0,0 +1,6 @@
+
+#--
+# Load Integer specific rext extensions.
+#++
+
+require 'rext/integer/helpers'

data/lib/rext/integer/helpers.rb

@@ -0,0 +1,29 @@
+
+class Integer
+  
+  ##
+  # Ordinalize turns a number into an ordinal string used to denote the
+  # position in an ordered sequence such as 1st, 2nd, 3rd, 4th.
+  #
+  # === Examples
+  #
+  #   1.ordinalize     # => "1st"
+  #   2.ordinalize     # => "2nd"
+  #   1002.ordinalize  # => "1002nd"
+  #   1003.ordinalize  # => "1003rd"
+  #
+  
+  def ordinalize
+    if (11..13).include? self % 100
+      "#{self}th"
+    else
+      case self % 10
+      when 1 ; "#{self}st"
+      when 2 ; "#{self}nd"
+      when 3 ; "#{self}rd"
+      else     "#{self}th"
+      end
+    end
+  end
+  
+end

data/lib/rext/module.rb

@@ -0,0 +1,6 @@
+
+#--
+# Load Module specific rext extensions.
+#++
+
+require 'rext/module/helpers'

data/lib/rext/module/helpers.rb

@@ -0,0 +1,85 @@
+
+require 'rext/object/metaclass'
+
+class Module
+  
+  ##
+  # Shortcut for including an anonymous module.
+  
+  def chainable &block
+    include Module.new(&block)
+  end
+  
+  ##
+  # Shortcut for extending with an anonymous module.
+  
+  def extendable &block
+    extend Module.new(&block)
+  end
+  
+  ##
+  # Call +method+ when conditions are met.
+  #
+  # This method provides a simple means of 
+  # utilizing method_missing, and should
+  # be used in most cases.
+  #
+  # When using a regular expression with
+  # the :if option, all captures are passed
+  # to the handling method.
+  #
+  # === Examples
+  #    
+  #   class Foo
+  #     call_method :find_by, :if => /^find_by_(\w+)/
+  #     def find_by attr, *args
+  #       "finding by #{attr} with #{args.join(', ')}"
+  #     end
+  #   end
+  #
+  #   foo = Foo.new
+  #   foo.find_by_name('bar') # => "finding by name with bar"
+  #
+  # === Options
+  #
+  #   :if   regexp or proc
+  #
+  
+  def call_method method, options = {}
+    chainable {
+      define_method :method_missing do |meth, *args|
+        if options[:if].is_a?(Regexp) && meth.to_s =~ options[:if]
+          send method, *($~.captures + args)
+        elsif options[:if].respond_to?(:call) && options[:if].call(meth, *args)
+          send method, *args
+        else
+          super
+        end
+      end
+    }
+  end
+  
+  ##
+  # Equivalent to defining self.included and
+  # instance evaluating the module passed.
+  #
+  # === Examples
+  #
+  #   def self.included mod
+  #     mod.instance_eval do
+  #       include InstanceMethods
+  #     end
+  #   end
+  #   
+  #   setup do 
+  #     include InstanceMethods
+  #   end
+  #
+  
+  def setup &block
+    meta_def :included do |mod|
+      mod.instance_eval &block
+    end
+  end
+  
+end

data/lib/rext/numeric.rb

@@ -0,0 +1,7 @@
+
+#--
+# Load Numeric specific rext extensions.
+#++
+
+require 'rext/numeric/time'
+require 'rext/numeric/bytes'

data/lib/rext/numeric/bytes.rb

@@ -0,0 +1,16 @@
+
+class Numeric
+  
+  def bytes;     self       end
+  def kilobytes; self << 10 end
+  def megabytes; self << 20 end
+  def gigabytes; self << 30 end
+  def terabytes; self << 40 end
+  
+  alias :byte :bytes
+  alias :kilobyte :kilobytes
+  alias :megabyte :megabytes
+  alias :gigabyte :gigabytes
+  alias :terabyte :terabytes
+  
+end

data/lib/rext/numeric/time.rb

@@ -0,0 +1,57 @@
+
+class Numeric
+  
+  def seconds; self            end
+  def minutes; self * 60       end
+  def hours;   self * 3600     end
+  def days;    self * 86400    end
+  def weeks;   self * 604800   end
+  def months;  self * 2592000  end
+  def years;   self * 31471200 end
+
+  alias :second :seconds
+  alias :minute :minutes
+  alias :hour :hours
+  alias :day :days
+  alias :week :weeks
+  alias :month :months
+  alias :year :years
+
+  def to_minutes; self / 1.minute end
+  def to_hours;   self / 1.hour   end
+  def to_days;    self / 1.day    end
+  def to_weeks;   self / 1.week   end
+  def to_months;  self / 1.month  end
+  def to_years;   self / 1.year   end
+
+  ##
+  # Time before specified +time+, which defaults to now.
+  #
+  # === Examples
+  #
+  #   event = 10.days.ago
+  #   15.minutes.before event
+  #
+
+  def ago time = ::Time.now
+    time - self
+  end
+  alias :before :ago
+
+  ##
+  # Time since specified +time+, which defaults to now.
+  #
+  # === Examples
+  #
+  #   event = 1.year.ago
+  #   3.months.since event
+  # 
+  #   4.days.from_now
+  #
+
+  def since time = ::Time.now
+    time + self
+  end
+  alias :from_now :since
+  
+end

data/lib/rext/object.rb

@@ -0,0 +1,7 @@
+
+#--
+# Load Object specific rext extensions.
+#++
+
+require 'rext/object/helpers'
+require 'rext/object/metaclass'

data/lib/rext/object/helpers.rb

@@ -0,0 +1,62 @@
+
+class Object
+  
+  ##
+  # Returns a hash indifferent to symbols or strings for 
+  # accessor keys.
+  #
+  # === Examples
+  #
+  #   hash = indifferent_hash
+  #   hash['foo'] = 'bar'
+  #
+  #   hash[:foo]  #=> 'bar'
+  #   hash['foo'] #=> 'bar'
+  #
+  
+  def indifferent_hash
+    Hash.new { |hash, key| hash[key.to_s] if key.is_a? Symbol }
+  end
+  
+  ##
+  # Yield and return +value+.
+  #
+  # === Examples
+  #
+  #   people = []
+  #   people << 'tj'
+  #   people << 'foo'
+  #
+  #   returning [] do |people|
+  #     people << 'tj'
+  #     people << 'foo'
+  #   end
+  #
+  
+  def returning value, &block
+    yield value
+    value
+  end
+  
+  ##
+  # Retry a _block_ of statements upto a number of _times_.
+  # When no error is raised the value returned by _block_ is 
+  # simply returned.
+  #
+  # === Examples
+  #
+  #   try 3 do
+  #     open 'http://vision-media.ca'
+  #   end
+  #   # => allows 3 tries to fetch the response
+  #
+  
+  def try times = 1, options = {}, &block
+    value = yield
+  rescue options[:on] || Exception
+    retry if (times -= 1) > 0
+  else
+    value
+  end
+  
+end