hobo-support 0.1

data/History.txt

@@ -0,0 +1,5 @@
+== 0.1
+
+* First release as a separate gem
+
+

data/Manifest.txt

@@ -0,0 +1,25 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/hobosupport.rb
+lib/hobosupport/array.rb
+lib/hobosupport/blankslate.rb
+lib/hobosupport/enumerable.rb
+lib/hobosupport/fixes.rb
+lib/hobosupport/fixes/chronic.rb
+lib/hobosupport/fixes/module.rb
+lib/hobosupport/fixes/pp.rb
+lib/hobosupport/hash.rb
+lib/hobosupport/implies.rb
+lib/hobosupport/metaid.rb
+lib/hobosupport/methodcall.rb
+lib/hobosupport/methodphitamine.rb
+lib/hobosupport/module.rb
+test/hobosupport.rdoctest
+test/hobosupport/enumerable.rdoctest
+test/hobosupport/hash.rdoctest
+test/hobosupport/implies.rdoctest
+test/hobosupport/metaid.rdoctest
+test/hobosupport/methodphitamine.rdoctest
+test/hobosupport/module.rdoctest

data/README.txt

@@ -0,0 +1,36 @@
+= hobosupport
+
+* http://hobocentral.net/hobosupport
+
+== DESCRIPTION:
+
+A mixed bag of core Ruby extenstion that have been extracted from the Hobo project.
+
+== INSTALL:
+
+* sudo gem install hobosupport
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 Tom Locke
+
+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/Rakefile

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'hoe'
+
+$: << "./lib" 
+
+require 'hobosupport'
+
+Hoe.new('hobo-support', HoboSupport::VERSION) do |p|
+  p.rubyforge_name = 'hobo'
+  p.author = 'Tom Locke'
+  p.email = 'tom@tomlocke.com'
+  p.url = "http://hobocentral.net/hobo-support"
+  p.summary = 'Core Ruby extensions from the Hobo project'
+  p.description = p.paragraphs_of('README.txt', 2..5).join("\n\n")
+  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+end
+

data/lib/hobosupport.rb

@@ -0,0 +1,41 @@
+require "hobosupport/fixes"
+require 'hobosupport/blankslate'
+require 'hobosupport/methodcall'
+require 'hobosupport/methodphitamine'
+require 'hobosupport/metaid'
+require 'hobosupport/implies'
+require 'hobosupport/enumerable'
+require 'hobosupport/array'
+require 'hobosupport/hash'
+require 'hobosupport/module'
+
+module HoboSupport
+  
+  VERSION = "0.1"
+  
+end
+
+
+# Some teeny fixes too diminutive to go elsewhere
+
+class Object
+
+  # Often nice to ask e.g. some_object.is_a?(Symbol, String)
+  alias_method :is_a_without_multiple_args?, :is_a?
+  def is_a?(*args)
+    args.any? {|a| is_a_without_multiple_args?(a) }
+  end
+  
+end
+
+
+# --- Rails extensions --- #
+
+# Nice tip from Jamis Buck
+if defined? ActiveRecord
+  class << ActiveRecord::Base
+    alias_method :[], :find
+  end
+end
+
+

data/lib/hobosupport/array.rb

@@ -0,0 +1,22 @@
+class Array
+  
+  alias_method :multiply, :*
+  
+  def *(rhs=nil)
+    if rhs
+      multiply(rhs)
+    else
+      Enumerable::MultiSender.new(self, :map)
+    end
+  end
+  
+  def drop_while!
+    drop = 0
+    drop += 1 while yield(self[drop])
+    self[0..drop-1] = []
+    self
+  end
+
+end
+
+

data/lib/hobosupport/blankslate.rb

@@ -0,0 +1,10 @@
+# Define BlankSlate in case ActiveSupport aint present
+unless defined? BlankSlate
+  class BlankSlate
+    instance_methods.reject { |m| m =~ /^__/ }.each { |m| undef_method m }
+    def initialize(me)
+      @me = me
+    end
+  end
+end
+

data/lib/hobosupport/enumerable.rb

@@ -0,0 +1,92 @@
+module Enumerable
+
+  def search(not_found=nil)
+    each do |x|
+      val = yield(x)
+      return val if val
+    end
+    not_found
+  end
+
+  def map_with_index
+    res = []
+    each_with_index {|x, i| res << yield(x, i)}
+    res
+  end
+  
+  def build_hash
+    res = {}
+    each do |x|
+      pair = yield x
+      res[pair.first] = pair.last if pair
+    end
+    res
+  end
+  
+  def map_hash
+    res = {}
+    each do |x|
+      v = yield x
+      res[x] = v
+    end
+    res
+  end
+  
+  def rest
+    self[1..-1]
+  end
+
+  class MultiSender
+ 
+    undef_method(*(instance_methods - %w*__id__ __send__*))
+
+    def initialize(enumerable, method)
+      @enumerable = enumerable
+      @method     = method
+    end
+
+    def method_missing(name, *args, &block)
+      @enumerable.send(@method) { |x| x.send(name, *args, &block) }
+    end
+    
+  end
+  
+  def *()
+    MultiSender.new(self, :map)
+  end
+  
+  def where
+    MultiSender.new(self, :select)
+  end
+  
+  def where_not
+    MultiSender.new(self, :reject)
+  end
+  
+  def drop_while
+    drop = 0
+    drop += 1 while yield(self[drop])
+    self[drop..-1] 
+  end
+  
+
+  def take_while
+    take = 0
+    take += 1 while yield(self[take])
+    self[0..take-1] 
+  end
+
+end
+
+
+class Object
+
+  def in?(enum)
+    enum.include?(self)
+  end
+
+  def not_in?(enum)
+    not enum.include?(self)
+  end
+  
+end

data/lib/hobosupport/fixes.rb

@@ -0,0 +1,3 @@
+require "hobosupport/fixes/chronic"
+require "hobosupport/fixes/pp"
+require "hobosupport/fixes/module"

data/lib/hobosupport/fixes/chronic.rb

@@ -0,0 +1,18 @@
+# --- Fix Chronic - can't parse '12th Jan' --- #
+begin
+  require 'chronic'
+  
+  module Chronic
+    
+    class << self
+      def parse_with_hobo_fix(s)
+        parse_without_hobo_fix(if s =~ /^\s*\d+\s*(st|nd|rd|th)\s+[a-zA-Z]+(\s+\d+)?\s*$/
+                                 s.sub(/\s*\d+(st|nd|rd|th)/) {|s| s[0..-3]}
+                               else
+                                 s
+                               end)
+      end
+      alias_method_chain :parse, :hobo_fix
+    end
+  end
+rescue LoadError; end

data/lib/hobosupport/fixes/module.rb

@@ -0,0 +1,37 @@
+class Module
+  
+  # Custom alias_method_chain that won't cause inifinite recursion if
+  # called twice.
+  # Calling alias_method_chain on alias_method_chain
+  # was just way to confusing, so I copied it :-/
+  def alias_method_chain(target, feature)
+    # Strip out punctuation on predicates or bang methods since
+    # e.g. target?_without_feature is not a valid method name.
+    aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
+    yield(aliased_target, punctuation) if block_given?
+    without = "#{aliased_target}_without_#{feature}#{punctuation}"
+    unless instance_methods.include?(without)
+      alias_method without, target
+      alias_method target, "#{aliased_target}_with_#{feature}#{punctuation}"
+    end
+  end
+
+  
+  # Fix delegate so it doesn't go bang if 'to' is nil
+  def delegate(*methods)
+    options = methods.pop
+    unless options.is_a?(Hash) && to = options[:to]
+      raise ArgumentError, ("Delegation needs a target. Supply an options hash with a :to key"  +
+                            "as the last argument (e.g. delegate :hello, :to => :greeter).")
+    end
+
+    methods.each do |method|
+      module_eval(<<-EOS, "(__DELEGATION__)", 1)
+        def #{method}(*args, &block)
+          (_to = #{to}) && _to.__send__(#{method.inspect}, *args, &block)
+        end
+      EOS
+    end
+  end
+    
+end

data/lib/hobosupport/fixes/pp.rb

@@ -0,0 +1,13 @@
+# --- Fix pp dumps - these break sometimes without this --- #
+require 'pp'
+module PP::ObjectMixin
+
+  alias_method :orig_pretty_print, :pretty_print
+  def pretty_print(q)
+    orig_pretty_print(q)
+  rescue
+    "[#PP-ERROR#]"
+  end
+
+end
+

data/lib/hobosupport/hash.rb

@@ -0,0 +1,100 @@
+class Hash
+
+  def select_hash(&b)
+    res = {}
+    each {|k,v| res[k] = v if (b.arity == 1 ? yield(v) : yield(k, v)) }
+    res
+  end
+  
+  
+  def map_hash(&b)
+    res = {}
+    each {|k,v| res[k] = b.arity == 1 ? yield(v) : yield(k, v) }
+    res
+  end
+
+  def partition_hash(keys=nil)
+    yes = {}
+    no = {}
+    each do |k,v|
+      if block_given? ? yield(k,v) : keys.include?(k)
+        yes[k] = v
+      else
+        no[k] = v
+      end
+    end
+    [yes, no]
+  end
+  
+  def recursive_update(hash)
+    hash.each_pair do |key, value|
+      current = self[key]
+      if current.is_a?(Hash) and value.is_a?(Hash)
+        current.recursive_update(value)
+      else
+        self[key] = value
+      end
+    end
+  end
+  
+  def -(keys)
+    res = {}
+    each_pair {|k, v| res[k] = v unless k.in?(keys)}
+    res
+  end
+  
+  def &(keys)
+    res = {}
+    keys.each {|k| res[k] = self[k] if has_key?(k)}
+    res    
+  end
+  
+  alias_method :| , :merge
+  
+  def get(*args)
+    args.map {|a| self[a] }
+  end
+  
+end
+
+
+# HashWithIndifferentAccess from ActiveSupport needs different
+# versions of these
+
+if defined? HashWithIndifferentAccess
+  
+  class HashWithIndifferentAccess
+    
+    def -(keys)
+      res = HashWithIndifferentAccess.new
+      keys = keys.map {|k| k.is_a?(Symbol) ? k.to_s : k }
+      each_pair { |k, v| res[k] = v unless k.in?(keys) }
+      res
+    end
+    
+    def &(keys)
+      res = HashWithIndifferentAccess.new
+      keys.each do |k|
+        k = k.to_s if k.is_a?(Symbol)
+        res[k] = self[k] if has_key?(k)
+      end
+      res    
+    end
+    
+    def partition_hash(keys=nil)
+      keys = keys._?.map {|k| k.is_a?(Symbol) ? k.to_s : k }
+      yes = HashWithIndifferentAccess.new
+      no = HashWithIndifferentAccess.new
+      each do |k,v|
+        if block_given? ? yield(k,v) : keys.include?(k)
+          yes[k] = v
+        else
+          no[k] = v
+        end
+      end
+      [yes, no]
+    end
+    
+  end
+
+end

data/lib/hobosupport/implies.rb

@@ -0,0 +1,15 @@
+class TrueClass
+  
+  def implies(x=nil)
+    block_given? ? yield : x 
+  end
+  
+end
+
+class FalseClass
+  
+  def implies(x)
+    true
+  end
+  
+end

data/lib/hobosupport/metaid.rb

@@ -0,0 +1,28 @@
+# Thanks to _why
+
+class Object
+
+  def metaclass; class << self; self; end; end
+  
+  def meta_eval(src=nil, &blk)
+    if src
+      metaclass.instance_eval(src)
+    else
+      metaclass.instance_eval &blk
+    end
+  end
+
+  def metaclass_eval(src=nil, &blk)
+    if src
+      metaclass.class_eval(src)
+    else
+      metaclass.class_eval &blk
+    end
+  end
+
+  # Adds methods to a metaclass
+  def meta_def(name, &blk)
+    meta_eval { define_method name, &blk }
+  end
+
+end

data/lib/hobosupport/methodcall.rb

@@ -0,0 +1,61 @@
+# The dot operator calls methods on objects. Power Dots are dots with extra features
+#
+#   .? calls a method if the reciever is not nil, returns nil
+#   otherwise. We have to write it ._?. in order to be valid Ruby
+#
+#   .try. calls a mehod only if the recipient resonds to that method 
+
+require 'delegate'
+require 'singleton'
+
+class Object
+
+  def _?()
+    self
+  end
+  
+  def try
+    CallIfAvailable.new(self)
+  end
+
+end
+
+  
+class NilClass
+  def _?()
+    SafeNil.instance
+  end
+end
+
+
+class SafeNil 
+  include Singleton
+  
+  def method_missing(method, *args, &b)
+    return nil unless nil.respond_to? method
+    nil.send(method, *args, &b) rescue nil
+  end
+end
+
+
+alias DelegateClass_without_safe_nil DelegateClass 
+def DelegateClass(klass)
+  c = DelegateClass_without_safe_nil(klass)
+  c.class_eval do 
+    def _?
+      self
+    end
+  end
+  c
+end
+
+
+class CallIfAvailable < BlankSlate
+  
+  def method_missing(name, *args, &b)
+    @me.send(name, *args, &b) if @me.respond_to?(name)
+  end
+  
+end
+
+

data/lib/hobosupport/methodphitamine.rb

@@ -0,0 +1,29 @@
+# From: http://jicksta.com/articles/2007/08/04/the-methodphitamine
+
+module Kernel
+
+  def it() It.new end
+  alias its it
+  
+end
+
+class It < BlankSlate
+
+  def initialize
+    @methods = []
+  end
+
+  def method_missing(*args, &block)
+    @methods << [args, block] unless args == [:respond_to?, :to_proc]
+    self
+  end
+
+  def to_proc
+    lambda do |obj|
+      @methods.inject(obj) do |current,(args,block)|
+        current.send(*args, &block)
+      end
+    end
+  end
+
+end

data/lib/hobosupport/module.rb

@@ -0,0 +1,67 @@
+class Module
+  
+  private
+  
+  # In a module definition you can include a call to
+  # included_in_class_callbacks(base) at the end of the
+  # self.included(base) callback. Any modules that your module includes
+  # will receive an included_in_class callback when your module is
+  # included in a class. Useful if the sub-module wants to do something
+  # like alias_method_chain on the class.
+  def included_in_class_callbacks(base)
+    if base.is_a?(Class)
+      included_modules.each { |m| m.included_in_class(base) if m.respond_to?(:included_in_class) }
+    end
+  end
+  
+  # An attr_accessor for classes that will delegate to the superclass
+  # if not defined on self
+  def inheriting_attr_reader(*names)
+    for name in names
+      class_eval %{
+        def #{name}
+          if defined? @#{name}
+            @#{name}
+          elsif superclass.respond_to?('#{name}')
+            superclass.#{name}
+          end
+        end
+      }
+    end
+  end
+  
+  # creates a #foo= and #foo? pair, with optional default values, e.g.
+  # bool_attr_accessor :happy => true
+  def bool_attr_accessor(*args)
+    options = args.extract_options!
+    (args + options.keys).each {|n| class_eval "def #{n}=(x); @#{n} = x; end" }
+    
+    args.each {|n| class_eval "def #{n}?; @#{n}; end" }
+
+    options.keys.each do |n|
+      class_eval %(def #{n}?
+                     if !defined? @#{n}
+                       @#{n} = #{options[n] ? 'true' : 'false'}
+                     else
+                       @#{n}
+                     end
+                   end)
+      set_field_type(n => TrueClass) if respond_to?(:set_field_type)
+    end
+  end
+
+end
+
+
+# classy_module lets you extract code from classes into modules, but
+# still write it the same way
+module Kernel
+  
+  def classy_module(&b)
+    m = Module.new
+    m.meta_def :included do |base|
+      base.class_eval &b
+    end
+  end
+  
+end

data/test/hobosupport.rdoctest

@@ -0,0 +1,53 @@
+# HoboSupport
+
+HoboSupport is a mixed bag of core ruby extensions that have been extracted from the [Hobo][] project
+
+[Hobo]: http://hobocentral.net
+
+    >> require 'hobosupport'
+    >> HoboSupport::VERSION
+    => "0.1"
+
+## Object extensions
+
+### Object#is_a?
+
+Extended to allow multiple types to be checked in one go
+
+    >> "foo".is_a?(String, Symbol)
+    => true
+    >> :foo.is_a?(String, Symbol)
+    => true
+    >> 1.is_a?(String, Symbol)
+    => false
+    
+Still works the old way
+
+    >> "foo".is_a?(String)
+    => true
+    >> :foo.is_a?(String)
+    => false
+    
+    
+## Method call extensions
+
+### Object#_?
+
+We have the "." operator to call methods on objects. These extensions introduce two "special dots". "`._?.`" only calls the method if the receiver is not `nil`.
+
+    >> "foo"._?.length
+    => 3
+    >> nil._?.length
+    => nil
+    
+
+### Object#try
+
+"`.try`" only calls the method if the receiver responds to that method.
+
+    >> "foo".try.length
+    => 3
+    >> :foo.try.length
+    => nil
+
+

data/test/hobosupport/enumerable.rdoctest

@@ -0,0 +1,120 @@
+# HoboSupport - Eumerable extensions
+
+    >> require 'hobosupport'
+    >> HoboSupport::VERSION
+    => "0.1"
+
+## Enumerable#search
+
+* `enum.search(not_found) { |element| block}`
+
+Iterates through an enumerable passing each element in turn to the block. Returns the first true value returned by the block, or `not_found` if the block never returns a true value.
+
+E.g. The length of the first word that starts with a capital letter
+
+    >> %w(my name is Fred).search { |s| s.length if s =~ /^[A-Z]/ }
+    => 4
+    
+## Enumerable#map_with_index
+
+* `enum.map_with_index { |element, index| block }`
+
+Just like #map but the block gets the element and the index.
+
+    >> %w(some short words).map_with_index { |s, i| s * i }
+    => ["", "short", "wordswords"]
+    
+## Enumerable#build_hash
+
+* `enum.build_hash { |element| block }`
+
+The block is passed each element in turn and should return a key/value pair. If the block returns nil, nothing is added to the hash.
+
+    >> %w(some short words).build_hash { |s| [s, s.length] unless s == "short" }
+    => {"some"=>4, "words"=>5}
+    
+
+## Enumerable#map_hash
+
+* `enum.map_hash { |element| block }`
+
+Each element is passed to the block. Returns a hash where the keys are the elements from the enumerable, and the values are those returned by the block for the given key.
+
+    >> %w(some short words).map_hash { |s| s.length }
+    => {"some"=>4, "short"=>5, "words"=>5}
+
+## Enumerable#rest
+
+Shorthand for `enum[1..-1]`
+
+    >> %w(some short words).rest
+    => ["short", "words"]
+    
+    
+## Enumerable#*
+
+Shorthand for `map` when you need to map a single method call on the elements.
+
+    >> %w(some short words).*.length
+    => [4, 5, 5]
+    
+## Enumerable#where
+
+Shorthand for `select` when you need to select on a single method call.
+
+    >> %w(some short words).where.include?("r")
+    => ["short", "words"]
+    
+## Enumerable#where_not
+
+Shorthand for `reject` when you need to reject on a single method call.
+
+    >> %w(some short words).where_not.include?("r")
+    => ["some"]
+    
+## Enumerable#drop_while
+
+* `enum.drop_while { |element| block }`
+
+Passes each element in turn to the block until the block returns false. Returns the remaining elements in a new array.
+
+    >> %w(this is a nice example).drop_while { |s| s.length > 1 }
+    => ["a", "nice", "example"]
+    
+There is also a destructive version for arrays
+
+    >> a = %w(this is a nice example)
+    >> a.drop_while! { |s| s.length > 1 }
+    >> a
+    => ["a", "nice", "example"]
+    
+
+## Enumerable#take_while
+
+* `enum.take_while { |element| block }`
+
+Passes each element in turn to the block until the block returns false. Returns a new with the elements for which the block returned true
+
+    >> %w(this is a nice example).take_while { |s| s.length > 1 }
+    => ["this", "is"]
+
+
+## Object#in?
+
+* `obj.in?(enum)`
+
+Shorthand for `enum.include?(obj)`
+
+    >> 3.in?(0..10)
+    => true
+    >> 300.in?(0..10)
+    => false
+
+## Object#not_in?
+
+* `obj.not_in?(enum)`
+
+    >> 3.not_in?(0..10)
+    => false
+    >> 300.not_in?(0..10)
+    => true

data/test/hobosupport/hash.rdoctest

@@ -0,0 +1,103 @@
+# HoboSupport - Hash extensions
+
+    >> require 'hobosupport'
+    >> HoboSupport::VERSION
+    => "0.1"
+    
+## Hash#select_hash
+
+* `hash.select_hash { |key, value| block } => hash`
+* `hash.select_hash { |value| block } => hash`
+
+This is the Hash version of `Enumerable#select`. i.e. a way to create a new hash with only some of the items still present. The block is passed each key value pair. The new hash only contains items for which the block returned true.
+
+    >> {1=>2, 3=>4, 6=>5}.select_hash { |key, value| key < value }
+    => {1=>2, 3=>4}
+    
+You can also give a block that takes one argument, in which case the block is given the value only
+
+    >> {1=>2, 3=>4, 6=>5}.select_hash { |value| value != 2 }
+    => {3=>4, 6=>5}
+    
+
+## Hash#map_hash
+
+* `hash.map_hash { |key, value| block } => hash`
+* `hash.map_hash { |value| block } => hash`
+
+Applies a function to each *value* in a Hash, resulting in a new hash with the same keys but new values. The block is passed each key, value pair and should return the new value
+
+    >> {1=>2, 3=>4, 6=>5}.map_hash { |key, value| key < value }
+    => {1=>true, 3=>true, 6=>false}
+    
+You can also give a block which takes one argument, in which case only the value is passed in
+
+    >> {1=>2, 3=>4, 6=>5}.map_hash { |value| value * 100 }
+    => {1=>200, 3=>400, 6=>500 }
+
+    
+## Hash#partition_hash
+
+* `hash.partition_hash(keys) => [hash1, hash2]`
+* `hash.partition_hash { |key, value| block } => hash`
+
+Returns an array of two hashes, the first with all the key/value pairs where the key was in passed Enumerable, the second with the remaining key/value pairs
+
+    >> {1=>2, 3=>4, 6=>5}.partition_hash([1, 3])
+    => [{1=>2, 3=>4}, {6=>5}]
+    
+When passed a block, each pair is passed to the block in turn. The result is two hashes, the first containing those pairs for which the block returned true, the second with the remaining pairs
+
+    >> {1=>2, 3=>4, 6=>5}.partition_hash { |key, value| key < value }
+    => [{1=>2, 3=>4}, {6=>5}]
+    
+## Hash.recursive_update
+
+* `hash.recursive_update(hash2)`
+
+Like `#update` but where a sub-hash would overwrite another sub-hash, they are instead also merged, recursively
+
+    >> h = { :a => 1, :b => { :x => 10 } }
+    >> h.recursive_update({ :c => 3, :b => { :y => 20 } })
+    >> h
+    => { :a => 1, :b => { :x => 10, :y => 20}, :c => 3 }
+
+
+## Hash#-
+
+* `hash - array => hash`
+
+Returns a new hash, the left-hand-side hash with all pairs removed where the key is present in the right-hand-side array.
+
+    >> {1=>2, 3=>4, 6=>5} - [1, 3]
+    => {6 => 5}
+    
+## Hash#&
+
+* `hash & array => array`
+
+Returns a new array, the left hand side hash restricted to pairs where the key is present in the right-hand-side array
+
+    >> {1=>2, 3=>4, 6=>5} & [1, 3]
+    => {1=>2, 3=>4}
+    
+## Hash#|
+
+* `hash | hash => hash`
+
+An alias for merge
+
+    >> {1 => 2} | {1 => 3, 2 => 4}
+    => {1 => 3, 2 => 4}
+    
+    
+## Hash#get
+
+* `hash.get(*args) => hash`
+
+Returns an array of values for the given keys. Useful for extracting a few options into local variables.
+
+    >> {1=>2, 3=>4, 6=>5}.get(1, 3)
+    => [2, 4]
+    
+

data/test/hobosupport/implies.rdoctest

@@ -0,0 +1,21 @@
+# HoboSupport - implies
+
+    >> require 'hobosupport'
+    >> HoboSupport::VERSION
+    => "0.1"
+
+The implies operator comes from Eiffel. Often comes in handy in Hobo's model-permission methods.
+
+## TrueClass#implies and FalseClass#implies
+
+    >> false.implies true
+    => true
+    
+    >> false.implies false
+    => true
+    
+    >> true.implies true
+    => true
+    
+    >> true.implies false
+    => false

data/test/hobosupport/metaid.rdoctest

@@ -0,0 +1,60 @@
+# HoboSupport - Metaid
+
+    >> require 'hobosupport'
+    >> HoboSupport::VERSION
+    => "0.1"
+
+Why the Luck Stiff's essential meta-programming additions to Object. These are probably distributed elsewhere, but they're small enough to throw them in to HoboSupport and remove an external dependency.
+
+## Object#metaclass
+
+Returns the "metaclass" (bad name) or "singleton class" of a given ruby Object
+
+    >> o = Object.new
+    >> def o.foo; ;123; end
+    >> o.foo
+    => 123
+    >> o.metaclass.instance_methods.grep "foo"
+    => ["foo"]
+
+## Object#meta_eval
+
+* `object.meta_eval(string)`
+* `object.meta_eval { block }`
+
+Evaluates ruby source or a block in the context of the metaclass.
+
+    >> File.meta_eval "alias_method :b, :basename"
+    >> File.b "a/b"
+    => "b"
+
+And with a block
+
+    >> File.meta_eval { alias_method :b2, :basename }
+    >> File.b2 "a/b"
+    => "b"
+
+## Object#metaclass_eval
+
+* `object.metaclass_eval(string)`
+* `object.metaclass_eval { block }`
+
+Like #meta_eval, but does a `class_eval` instead of an `instance_eval`
+
+    >> File.metaclass_eval "def b3(path); basename(path); end"
+    >> File.b3 "a/b"
+    => "b"
+
+And with a block
+
+    >> File.metaclass_eval { def b4(path); basename(path); end }
+    >> File.b4 "a/b"
+    => "b"
+    
+    
+## Object#meta_def
+
+    >> String.meta_def(:backwards_new) { |s| s.reverse }
+    >> String.backwards_new "strange"
+    => "egnarts"
+   

data/test/hobosupport/methodphitamine.rdoctest

@@ -0,0 +1,19 @@
+# HoboSupport - Methodphitamine
+
+    >> require 'hobosupport'
+    >> HoboSupport::VERSION
+    => "0.1"
+
+## Kernel#it and Kernel#its
+
+A nice hack from Jay Phillips, christened "Methodphitamine". The low-down is in the [original blog post][1].
+
+[1]: http://jicksta.com/articles/2007/08/04/the-methodphitamine
+
+    >> (1..10).select &it % 2 == 0
+    => [2, 4, 6, 8, 10]
+    >> %w(a few short words).map &its.length
+    => [1, 3, 5, 5]
+    
+Note that `it` and `its` are identical. They just read better in different contexts. Note that methodphitamine is also released directly by Jay (simply `gem install methodphitamine`) but it's small enough that it seemed easier to add it to HoboSupport and avoid an extra dependency. Thanks to Jay.
+

data/test/hobosupport/module.rdoctest

@@ -0,0 +1,72 @@
+# HoboSupport - Module extensions
+
+    >> require 'hobosupport'
+    >> HoboSupport::VERSION
+    => "0.1"
+
+## Module#included_in_class_callbacks
+
+Bit involved, this one :-)
+
+When a module is included in a class, it gets a callback on the `included` method, with the class passed as argument. However, if a module M2 is included in M1, and a class C includes M1, then M2 never gets to know about C. So, for example, M2 could not `alias_method_chain` a class method on C.
+
+`included_in_class_callbacks` makes it easy to implement a notification from M1 to M2, so that M2 does have full access to the class. All you do is insert a call to `included_in_class_callbacks(base)` as the end of the module's `self.included` method.
+
+(Note we're using the metaid extensions here too)
+
+    >>
+    module M2
+      def self.included_in_class(klass)
+        klass.metaclass_eval do
+          def name_with_shouting; name_without_shouting.upcase; end
+          alias_method_chain :name, :shouting
+        end
+      end
+    end
+    
+    module M1
+      def self.included(base)
+        included_in_class_callbacks(base)
+      end
+      include M2
+    end
+    
+    class C
+      def self.name
+        "my name is C"
+      end
+      include M1
+    end
+    
+    C.name
+    => "MY NAME IS C"
+    
+    
+## Module#interiting_attr_accessor
+
+Only for use on classes. Like `attr_accessor`, but the attribute is looked up on the superclass if not defined on the receiving class. In other words, the superclass defines a default that subclasses can override.
+
+    >>
+    class A
+      class << self
+        inheriting_attr_reader :name
+      end
+      @name = "Andy"
+    end
+    
+    class B < A; end
+    
+`B` has the same name as its superclass `A`
+    
+    >> A.name
+    => "Andy"
+    >> B.name
+    => "Andy"
+    
+Now we change the name of `B`. `A` retains it's existing name.
+    
+    >> class B; @name = "Bob"; end
+    >> B.name
+    => "Bob"
+    >> A.name
+    => "Andy"

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: hobo-support
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+date: 2008-02-09 00:00:00 +00:00
+summary: Core Ruby extensions from the Hobo project
+require_paths: 
+- lib
+email: tom@tomlocke.com
+homepage: http://hobocentral.net/hobo-support
+rubyforge_project: hobo
+description: "== DESCRIPTION:  A mixed bag of core Ruby extenstion that have been extracted from the Hobo project.  == INSTALL:  * sudo gem install hobosupport"
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Tom Locke
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- lib/hobosupport.rb
+- lib/hobosupport/array.rb
+- lib/hobosupport/blankslate.rb
+- lib/hobosupport/enumerable.rb
+- lib/hobosupport/fixes.rb
+- lib/hobosupport/fixes/chronic.rb
+- lib/hobosupport/fixes/module.rb
+- lib/hobosupport/fixes/pp.rb
+- lib/hobosupport/hash.rb
+- lib/hobosupport/implies.rb
+- lib/hobosupport/metaid.rb
+- lib/hobosupport/methodcall.rb
+- lib/hobosupport/methodphitamine.rb
+- lib/hobosupport/module.rb
+- test/hobosupport.rdoctest
+- test/hobosupport/enumerable.rdoctest
+- test/hobosupport/hash.rdoctest
+- test/hobosupport/implies.rdoctest
+- test/hobosupport/metaid.rdoctest
+- test/hobosupport/methodphitamine.rdoctest
+- test/hobosupport/module.rdoctest
+test_files: []
+
+rdoc_options: 
+- --main
+- README.txt
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.5.0
+    version: