gorillib 0.1.11 → 0.4.0pre

data/lib/gorillib/string/simple_inflector.rb

@@ -0,0 +1,267 @@
+module Gorillib ; end
+
+# String inflections define new methods on the String class to transform names for different purposes.
+#
+#   "ScaleScore".underscore # => "scale_score"
+#
+# This doesn't define the full set of inflections -- only
+#
+# * camelize
+# * snakeize
+# * underscore
+# * demodulize
+#
+module Gorillib::Inflector
+  extend self
+
+  def self.pluralizations
+    @pluralizations ||= {}
+  end
+
+  def pluralize(str)
+    Gorillib::Inflector.pluralizations.fetch(str){ "#{str}s" }
+  end
+
+  # The reverse of +pluralize+, returns the singular form of a word in a string.
+  #
+  # Examples:
+  #   "posts".singularize            # => "post"
+  #   # it's not very smart
+  #   "octopi".singularize           # => "octopi"
+  #   "bonus".singularize            # => "bonu"
+  #   "boxes".singularize            # => "boxe"
+  #   "CamelOctopi".singularize      # => "CamelOctopi"
+  def singularize(str)
+    Gorillib::Inflector.pluralizations.invert.fetch(str){ str.gsub(/s$/, '') }
+  end
+
+  # Capitalizes the first word and turns underscores into spaces and strips a
+  # trailing "_id", if any. Like +titleize+, this is meant for creating pretty output.
+  #
+  # Examples:
+  #   "employee_salary" # => "Employee salary"
+  #   "author_id"       # => "Author"
+  def humanize(lower_case_and_underscored_word)
+    result = lower_case_and_underscored_word.to_s.dup
+    result.gsub!(/_id$/, "")
+    result.gsub(/(_)?([a-z\d]*)/i){ "#{ $1 && ' ' }#{ $2.downcase}" }.gsub(/^\w/){ $&.upcase }
+  end
+
+  # Capitalizes all the words and replaces some characters in the string to create
+  # a nicer looking title. +titleize+ is meant for creating pretty output. It is not
+  # used in the Rails internals.
+  #
+  # +titleize+ is also aliased as as +titlecase+.
+  #
+  # Examples:
+  #   "man from the boondocks".titleize   # => "Man From The Boondocks"
+  #   "x-men: the last stand".titleize    # => "X Men: The Last Stand"
+  #   "TheManWithoutAPast".titleize       # => "The Man Without A Past"
+  #   "raiders_of_the_lost_ark".titleize  # => "Raiders Of The Lost Ark"
+  def titleize(word)
+    humanize(underscore(word)).gsub(/\b('?[a-z])/){ $1.capitalize }
+  end
+
+  # Create the name of a table like Rails does for models to table names. This method
+  # uses the +pluralize+ method on the last word in the string.
+  #
+  # Examples
+  #   "RawScaledScorer".tableize # => "raw_scaled_scorers"
+  #   "egg_and_ham".tableize     # => "egg_and_hams"
+  #   "fancyCategory".tableize   # => "fancy_categories"
+  def tableize(class_name)
+    pluralize(underscore(class_name))
+  end
+
+  # Create a class name from a plural table name like Rails does for table names to models.
+  # Note that this returns a string and not a Class. (To convert to an actual class
+  # follow +classify+ with +constantize+.)
+  #
+  # Examples:
+  #   "egg_and_hams".classify # => "EggAndHam"
+  #   "posts".classify        # => "Post"
+  #
+  # Singular names are not handled correctly:
+  #   "business".classify     # => "Busines"
+  def classify(table_name)
+    # strip out any leading schema name
+    camelize(singularize(table_name.to_s.sub(/.*\./, '')))
+  end
+
+private
+
+  # def uncountable_words #:doc
+  #   %w( equipment information rice money species series fish )
+  # end
+  #
+  # def plural_rules #:doc:
+  #   [
+  #     [/(x|ch|ss|sh)$/i,         '\1es'],      # search, switch, fix, box, process, address
+  #     [/([^aeiouy]|qu)y$/i,      '\1ies'],     # query, ability, agency
+  #     [/(p)erson$/i,             '\1eople'],   # person, salesperson
+  #     [/(m)an$/i,                '\1en'],      # man, woman, spokesman
+  #     [/(c)hild$/i,              '\1hildren'], # child
+  #     [/s$/i,                    's'],         # no change (compatibility)
+  #     [/$/,                      's']
+  #   ]
+  # end
+  #
+  # def singular_rules
+  #   [
+  #     [/(x|ch|ss|sh)es$/i,       '\1'],
+  #     [/([^aeiouy]|qu)ies$/i,    '\1y'],
+  #     [/(p)eople$/i,             '\1\2erson'],
+  #     [/(m)en$/i,                '\1an'],
+  #     [/(c)hildren$/i,           '\1\2hild'],
+  #     [/s$/i,                    '']
+  #   ]
+  # end
+
+  #   %w[
+  #         equipment    equipment
+  #         information  information
+  #         rice         rice
+  #         money        money
+  #         species      species
+  #         series       series
+  #         fish         fish
+  # ]
+
+  # def uncountable_words #:doc
+  #   %w( equipment information rice money species series fish )
+  # end
+  #
+  # def plural_rules #:doc:
+  #   [
+  #     [/^(ox)$/i,                '\1\2en'],    # ox
+  #     [/([m|l])ouse$/i,          '\1ice'],     # mouse, louse
+  #     [/(matr|vert|ind)ix|ex$/i, '\1ices'],    # matrix, vertex, index
+  #     [/(x|ch|ss|sh)$/i,         '\1es'],      # search, switch, fix, box, process, address
+  #     [/([^aeiouy]|qu)ies$/i,    '\1y'],
+  #     [/([^aeiouy]|qu)y$/i,      '\1ies'],     # query, ability, agency
+  #     [/(hive)$/i,               '\1s'],       # archive, hive
+  #     [/(?:([^f])fe|([lr])f)$/i, '\1\2ves'],   # half, safe, wife
+  #     [/sis$/i,                  'ses'],       # basis, diagnosis
+  #     [/([ti])um$/i,             '\1a'],       # datum, medium
+  #     [/(p)erson$/i,             '\1eople'],   # person, salesperson
+  #     [/(m)an$/i,                '\1en'],      # man, woman, spokesman
+  #     [/(c)hild$/i,              '\1hildren'], # child
+  #     [/(buffal|tomat)o$/i,      '\1\2oes'],   # buffalo, tomato
+  #     [/(bu)s$/i,                '\1\2ses'],   # bus
+  #     [/(alias)/i,               '\1es'],      # alias
+  #     [/(octop|vir)us$/i,        '\1i'],       # octopus, virus - virus has no defined plural (according to Latin/dictionary.com), but viri is better than viruses/viruss
+  #     [/(ax|cri|test)is$/i,      '\1es'],      # axis, crisis
+  #     [/s$/i,                    's'],         # no change (compatibility)
+  #     [/$/,                      's']
+  #   ]
+  # end
+  #
+  # def singular_rules
+  #   [
+  #     [/(matr)ices$/i,           '\1ix'],
+  #     [/(vert|ind)ices$/i,       '\1ex'],
+  #     [/^(ox)en/i,               '\1'],
+  #     [/(alias)es$/i,            '\1'],
+  #     [/([octop|vir])i$/i,       '\1us'],
+  #     [/(cris|ax|test)es$/i,     '\1is'],
+  #     [/(shoe)s$/i,              '\1'],
+  #     [/(o)es$/i,                '\1'],
+  #     [/(bus)es$/i,              '\1'],
+  #     [/([m|l])ice$/i,           '\1ouse'],
+  #     [/(x|ch|ss|sh)es$/i,       '\1'],
+  #     [/(m)ovies$/i,             '\1\2ovie'],
+  #     [/(s)eries$/i,             '\1\2eries'],
+  #     [/([^aeiouy]|qu)ies$/i,    '\1y'],
+  #     [/([lr])ves$/i,            '\1f'],
+  #     [/(tive)s$/i,              '\1'],
+  #     [/(hive)s$/i,              '\1'],
+  #     [/([^f])ves$/i,            '\1fe'],
+  #     [/([ti])a$/i,              '\1um'],
+  #     [/(p)eople$/i,             '\1\2erson'],
+  #     [/(m)en$/i,                '\1an'],
+  #     [/(s)tatus$/i,             '\1\2tatus'],
+  #     [/(c)hildren$/i,           '\1\2hild'],
+  #     [/(n)ews$/i,               '\1\2ews'],
+  #     [/s$/i,                    '']
+  #   ]
+  # end
+
+  # inflect.plural(/$/, 's')
+  # inflect.plural(/s$/i, 's')
+  # inflect.plural(/^(ax|test)is$/i, '\1es')
+  # inflect.plural(/(octop|vir)us$/i, '\1i')
+  # inflect.plural(/(octop|vir)i$/i, '\1i')
+  # inflect.plural(/(alias|status)$/i, '\1es')
+  # inflect.plural(/(bu)s$/i, '\1ses')
+  # inflect.plural(/(buffal|tomat)o$/i, '\1oes')
+  # inflect.plural(/([ti])um$/i, '\1a')
+  # inflect.plural(/([ti])a$/i, '\1a')
+  # inflect.plural(/sis$/i, 'ses')
+  # inflect.plural(/(?:([^f])fe|([lr])f)$/i, '\1\2ves')
+  # inflect.plural(/(hive)$/i, '\1s')
+  # inflect.plural(/([^aeiouy]|qu)y$/i, '\1ies')
+  # inflect.plural(/(x|ch|ss|sh)$/i, '\1es')
+  # inflect.plural(/(matr|vert|ind)(?:ix|ex)$/i, '\1ices')
+  # inflect.plural(/(m|l)ouse$/i, '\1ice')
+  # inflect.plural(/(m|l)ice$/i, '\1ice')
+  # inflect.plural(/^(ox)$/i, '\1en')
+  # inflect.plural(/^(oxen)$/i, '\1')
+  # inflect.plural(/(quiz)$/i, '\1zes')
+
+  # inflect.singular(/s$/i, '')
+  # inflect.singular(/(ss)$/i, '\1')
+  # inflect.singular(/(n)ews$/i, '\1ews')
+  # inflect.singular(/([ti])a$/i, '\1um')
+  # inflect.singular(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)(sis|ses)$/i, '\1\2sis')
+  # inflect.singular(/(^analy)(sis|ses)$/i, '\1sis')
+  # inflect.singular(/([^f])ves$/i, '\1fe')
+  # inflect.singular(/(hive)s$/i, '\1')
+  # inflect.singular(/(tive)s$/i, '\1')
+  # inflect.singular(/([lr])ves$/i, '\1f')
+  # inflect.singular(/([^aeiouy]|qu)ies$/i, '\1y')
+  # inflect.singular(/(s)eries$/i, '\1eries')
+  # inflect.singular(/(m)ovies$/i, '\1ovie')
+  # inflect.singular(/(x|ch|ss|sh)es$/i, '\1')
+  # inflect.singular(/(m|l)ice$/i, '\1ouse')
+  # inflect.singular(/(bus)(es)?$/i, '\1')
+  # inflect.singular(/(o)es$/i, '\1')
+  # inflect.singular(/(shoe)s$/i, '\1')
+  # inflect.singular(/(cris|test)(is|es)$/i, '\1is')
+  # inflect.singular(/^(a)x[ie]s$/i, '\1xis')
+  # inflect.singular(/(octop|vir)(us|i)$/i, '\1us')
+  # inflect.singular(/(alias|status)(es)?$/i, '\1')
+  # inflect.singular(/^(ox)en/i, '\1')
+  # inflect.singular(/(vert|ind)ices$/i, '\1ex')
+  # inflect.singular(/(matr)ices$/i, '\1ix')
+  # inflect.singular(/(quiz)zes$/i, '\1')
+  # inflect.singular(/(database)s$/i, '\1')
+  #
+  # inflect.irregular('person', 'people')
+  # inflect.irregular('man', 'men')
+  # inflect.irregular('child', 'children')
+  # inflect.irregular('sex', 'sexes')
+  # inflect.irregular('move', 'moves')
+  # inflect.irregular('cow', 'kine')
+  # inflect.irregular('zombie', 'zombies')
+  #
+  # inflect.uncountable(%w(equipment information rice money species series fish sheep jeans))
+
+public
+
+  # def pluralize(word)
+  #   result = word.dup
+  #   plural_rules.each do |(rule, replacement)|
+  #     break if result.gsub!(rule, replacement)
+  #   end
+  #   return result
+  # end
+  #
+  # def singularize(word)
+  #   result = word.dup
+  #   singular_rules.each do |(rule, replacement)|
+  #     break if result.gsub!(rule, replacement)
+  #   end
+  #   return result
+  # end
+
+end

data/lib/gorillib/type/extended.rb

@@ -0,0 +1,52 @@
+require 'pathname'
+require 'time'
+
+class ::Long      < ::Integer ; end
+class ::Double    < ::Float   ; end
+class ::Binary    < ::String  ; end
+
+class ::Guid      < ::String  ; end
+class ::IpAddress < ::String  ; end
+class ::Hostname  < ::String  ; end
+
+class ::Url       < ::String  ; end
+
+# require 'gorillib/metaprogramming/delegation'
+#
+# class ::Boolean < ::Object
+#   attr_accessor :val
+#   def initialize(val=nil)
+#     self.val = val
+#   end
+#
+#   delegate :!,  :to_s, :blank?, :frozen?, :nil?, :present?, :to => :val
+#   delegate :!=, :&, :<=>, :=~, :^, :|, :to => :val
+#
+#   def inspect()
+#     "<Boolean #{val.inspect}>"
+#   end
+#   def try_dup()
+#     ::Boolean.new(val)
+#   end
+#
+#   def self.true  ; self.new(true)  ; end
+#   def self.false ; self.new(false) ; end
+#
+#   def is_a?(klass)        val.is_a?(klass)        || super ; end
+#   def kind_of?(klass)     val.kind_of?(klass)     || super ; end
+#   def instance_of?(klass) val.instance_of?(klass) || super ; end
+#
+#   def     !=(other_val) other_val = other_val.val if other_val.is_a?(::Boolean) ; (val     != other_val) ; end
+#   def     ==(other_val) other_val = other_val.val if other_val.is_a?(::Boolean) ; (val     == other_val) ; end
+#   def    ===(other_val) other_val = other_val.val if other_val.is_a?(::Boolean) ; (val    === other_val) ; end
+#   def    <=>(other_val) other_val = other_val.val if other_val.is_a?(::Boolean) ; (val    <=> other_val) ; end
+#   def   eql?(other_val) other_val = other_val.val if other_val.is_a?(::Boolean) ; (val.eql?   other_val) ; end
+#   def equal?(other_val) other_val = other_val.val if other_val.is_a?(::Boolean) ; (val.equal? other_val) ; end
+#
+# end
+
+# Datamapper also defines:
+#
+#  Apikey BCryptHash Decimal URI UUID Slug CommaSeparatedList Csv IpAddress Json Yaml Enum Flag Discriminator
+#
+# maybe someday we will too...

data/lib/gorillib/utils/capture_output.rb

@@ -0,0 +1,28 @@
+module Gorillib
+  module TestHelpers
+    module_function
+
+    def dummy_stdio(stdin_text=nil)
+      stdin = stdin_text.nil? ? $stdin : StringIO.new(stdin_text)
+      new_fhs = [stdin,  StringIO.new('', 'w'), StringIO.new('', 'w')]
+      old_fhs = [$stdin, $stdout,               $stderr]
+      begin
+        $stdin, $stdout, $stderr = new_fhs
+        yield
+      ensure
+        $stdin, $stdout, $stderr = old_fhs
+      end
+      new_fhs[1..2]
+    end
+
+    #
+    # Temporarily sets the global variables $stderr and $stdout to a capturable StringIO;
+    # restores them at the end, even if there is an error
+    #
+    def capture_output
+      dummy_stdio{ yield }
+    end
+
+    alias_method :quiet_output, :capture_output
+  end
+end

data/lib/gorillib/utils/console.rb

@@ -0,0 +1,131 @@
+#
+# An inspecting delegator.
+#
+# Create a trap passing in any object of your choice.
+#
+# Any time a method is called on the trap, it prints the method name, all its
+# args, and the direct caller.
+#
+# @example Did you know how basic operators work? Now you do!
+#
+#    trapped_int = ItsATrap.new(3)
+#
+#    trapped_int - 55
+#    [:-, [55], nil, "..."]
+#    => -52
+#
+#    55 - trapped_int
+#    [:coerce, [55], nil, "..."]
+#    => 52
+#
+#    - trapped_int
+#    [:-@, [], nil, "..."]
+#    => -3
+#
+class ItsATrap < BasicObject
+  def initialize(obj=::Object.new, show_ret=false)
+    @obj        = obj
+    @call_count = 0
+    @show_ret   = show_ret
+  end
+
+  # We implement to_s and inspect, because otherwise it's annoyingly noisy. :pretty_inspect makes pry happy.
+
+  def inspect() "~#{@obj.inspect}~" ; end
+  def to_s()    @obj.to_s        ; end
+  alias_method :pretty_inspect, :inspect
+  def methods() @obj.methods ; end
+
+  # These are defined on BasicObject, delegate them along with the rest
+  #   BasicObject.instance_methods
+  #   => [:==, :equal?, :!, :!=, :instance_eval, :instance_exec, :__send__, :__id__]
+
+  def ==(    *args, &block)        ; __describe_and_send__(:==,     *args, &block) ; end
+  def equal?(*args, &block)        ; __describe_and_send__(:equal?, *args, &block) ; end
+  def !@(    *args, &block)        ; __describe_and_send__(:!,      *args, &block) ; end
+  def !=(    *args, &block)        ; __describe_and_send__(:!=,     *args, &block) ; end
+  def instance_eval(*args, &block) ; __describe_and_send__(:instance_eval, *args, &block) ; end
+  def instance_exec(*args, &block) ; __describe_and_send__(:instance_exec, *args, &block) ; end
+
+private
+
+  #
+  # Any time a method is called on the trap, it prints the method name, all its
+  # args, and the direct caller.
+  #
+  def method_missing(meth, *args, &block)
+    __describe_and_send__(meth, *args, &block)
+  end
+
+  def __describe_and_send__(meth, *args, &block)
+    pref         = "%-3d %-14s %-15s" % [@call_count, __id__, self.to_s[0..14]]
+    @call_count += 1
+    $stderr.puts   "%s %-15s <-  %-30s %s -- %s" % [pref, meth.to_s[0..14], args.map(&:inspect).join(','), block, ::Kernel.caller.first]
+    ret = @obj.__send__(meth, *args, &block)
+    $stderr.puts   "%s %-15s  -> %s"             % [pref, meth.to_s[0..14], ret.inspect] if @show_ret
+    ret
+  end
+end
+
+module Test
+  module_function
+
+  def create_class(name, *args, &block)
+    Object.class_eval do
+      remove_const(name) if self.const_defined?(name)
+      const_set(name, Class.new(*args, &block))
+    end
+  end
+
+  def example_singleton(name, *args)
+    require 'singleton'
+    create_class(name, *args){ include ::Singleton }
+  end
+
+end
+
+class Module
+
+  #
+  # Lists the differences in methods between two modules/classes
+  #
+  # Breaks them down by providing module, and shows class and instance methods.
+  # @param other [Module] other class or module to compare with
+  # @param show_common [true,false] true to show methods they have in common; false by default
+  #
+  # @example Range has several extra instance methods; the Foo class and its instances have methods via the Happy module
+  #   module Happy ; def hello() 3 ; end ; end
+  #   class  Foo   ; include Enumerable ; include Happy ; extend Happy ; end
+  #   { "Foo#"   => { Happy => [:hello] },
+  #     "Foo."   => { Happy => [:hello] },
+  #     "Range#" => { Range => [:each, :step, :begin, :end, :last, :exclude_end?, :cover?]} }
+  #
+  def compare_methods(other=Object, show_common=false)
+    result = Hash.new{|h,k| h[k] = Hash.new{|hh,hk| hh[hk] = [] } }
+
+    inst_ancestors_both  = ancestors                 & other.ancestors
+    klass_ancestors_both = singleton_class.ancestors & other.singleton_class.ancestors
+
+    inst_meths  = (self.instance_methods | other.instance_methods)
+    klass_meths = (self.methods          | other.methods)
+
+    [ [:both, inst_ancestors_both,                     klass_ancestors_both],
+      [self,   (self.ancestors  - inst_ancestors_both), (self.singleton_class.ancestors  - klass_ancestors_both)],
+      [other,  (other.ancestors - inst_ancestors_both), (other.singleton_class.ancestors - klass_ancestors_both)],
+    ].each do |mod, inst_anc, klass_anc|
+      inst_anc.reverse.each do |ancestor|
+        result["#{mod}#"][ancestor] = inst_meths & ancestor.instance_methods
+        inst_meths -= ancestor.instance_methods
+      end
+      klass_anc.reverse.each do |ancestor|
+        result["#{mod}."][ancestor] = klass_meths & ancestor.instance_methods
+        klass_meths -= ancestor.instance_methods
+      end
+    end
+    unless show_common then result.delete("both#") ; result.delete("both.") ; end
+    result.each{|type,hsh|    hsh.reject!{|k,v| v.empty? } }
+    result.reject!{|type,hsh| hsh.empty? }
+    result
+  end
+
+end

data/lib/gorillib/utils/nuke_constants.rb

@@ -0,0 +1,9 @@
+class Module
+  #
+  # Removes all constants in the module's namespace -- this is useful when
+  # writing specs for metaprogramming methods
+  #
+  def nuke_constants
+    constants.each{|const| remove_const(const) }
+  end
+end

data/lib/gorillib/utils/stub_module.rb

@@ -0,0 +1,33 @@
+# spec/spec_helper_lite.rb
+
+# Conditionally creates empty or "stub" modules only if
+# a) they are not already defined; and
+# b) they are not auto-loadable.
+#
+# From http://objectsonrails.com/#sec-7-1
+#
+# @example Faking out ActiveModel
+#    # ...
+#    require_relative '../spec_helper_lite'
+#    stub_module 'ActiveModel::Conversion'
+#    stub_module 'ActiveModel::Naming'
+#    require_relative '../../app/models/post'
+#    # ...
+#
+def stub_module(full_name)
+  # Uses #const_get to attempt to reference the given module. If the module is
+  # defined, or if calling #const_get causes it to be auto-loaded, the method
+  # does nothing more. But if #const_get fails to turn up the module, it defines
+  # an anonymous empty module to act as a placeholder.
+  full_name.to_s.split(/::/).inject(Object) do |context, name|
+    begin
+      context.const_get(name)
+    rescue NameError
+      context.const_set(name, Module.new)
+    end
+  end
+end
+
+
+# refute
+# does_not_allow

data/spec/examples/builder/ironfan_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+# related libs
+require 'gorillib/model'
+require 'gorillib/model/field'
+require 'gorillib/model/defaults'
+# libs under test
+require 'gorillib/builder'
+require 'gorillib/builder/field'
+require 'gorillib/string/simple_inflector'
+# testing helpers
+
+load GORILLIB_ROOT_DIR('examples/builder/ironfan.rb')
+
+module Gorillib::Test       ; end
+module Meta::Gorillib::Test ; end
+
+describe Gorillib::Builder, :model_spec => true do
+  after(:each){   Gorillib::Test.nuke_constants ; Meta::Gorillib::Test.nuke_constants }
+  def example_cluster
+    Gorillib::Test.cluster
+  end
+
+  let(:ec_webnode  ){ fac = example_cluster.facet(:webnode); fac.cluster(example_cluster) ; fac }
+  let(:ec_webnode_a){ svr = ec_webnode.server(:a);           svr.facet(ec_webnode)        ; svr }
+
+  # it 'is awesome'
+
+  context "collections get a {foo}_name accessor:" do
+    it("facet.cluster_name"){ ec_webnode.cluster_name.should == :yellowhat }
+    it("server.facet_name" ){ ec_webnode_a.facet_name.should == :webnode   }
+  end
+
+  context "collections get a `has_{foo}` tester:" do
+    it("server.facet?"    ){ ec_webnode_a.facet?.should be_true }
+    it("facet.has_server?"){ ec_webnode.should have_server(:a) }
+  end
+end

data/spec/extlib/hash_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+require 'gorillib/hash/slice'
+
+describe Hash, "only" do
+  before do
+    @hash = { :one => 'ONE', 'two' => 'TWO', 3 => 'THREE', 4 => nil }
+  end
+
+  it "should return a hash with only the given key(s)" do
+    @hash.only(:not_in_there).should == {}
+    @hash.only(4).should == {4 => nil}
+    @hash.only(:one).should == { :one => 'ONE' }
+    @hash.only(:one, 3).should == { :one => 'ONE', 3 => 'THREE' }
+  end
+end
+
+
+describe Hash, "except" do
+  before do
+    @hash = { :one => 'ONE', 'two' => 'TWO', 3 => 'THREE' }
+  end
+
+  it "should return a hash without only the given key(s)" do
+    @hash.except(:one).should == { 'two' => 'TWO', 3 => 'THREE' }
+    @hash.except(:one, 3).should == { 'two' => 'TWO' }
+  end
+end
+
+# describe Hash, 'to_params' do
+#   {
+#     { "foo" => "bar", "baz" => "bat" } => "foo=bar&baz=bat",
+#     { "foo" => [ "bar", "baz" ] } => "foo%5B%5D=bar&foo%5B%5D=baz",
+#     { "foo" => [ {"bar" => "1"}, {"bar" => 2} ] } => "foo%5B%5D%5Bbar%5D=1&foo%5B%5D%5Bbar%5D=2",
+#     { "foo" => { "bar" => [ {"baz" => 1}, {"baz" => "2"}  ] } } => "foo%5Bbar%5D%5B%5D%5Bbaz%5D=1&foo%5Bbar%5D%5B%5D%5Bbaz%5D=2",
+#     { "foo" => {"1" => "bar", "2" => "baz"} } => "foo%5B1%5D=bar&foo%5B2%5D=baz"
+#   }.each do |hash, params|
+#     it "should covert hash: #{hash.inspect} to params: #{params.inspect}" do
+#       hash.to_params.split('&').sort.should == params.split('&').sort
+#     end
+#   end
+#
+#   it 'should not leave a trailing &' do
+#     { :name => 'Bob', :address => { :street => '111 Ruby Ave.', :city => 'Ruby Central', :phones => ['111-111-1111', '222-222-2222'] } }.to_params.should_not match(/&$/)
+#   end
+#
+#   it 'should encode query keys' do
+#     { 'First & Last' => 'Alice Smith' }.to_params.should == "First%20%26%20Last=Alice%20Smith"
+#   end
+#
+#   it 'should encode query values' do
+#     { :name => 'Alice & Bob' }.to_params.should == "name=Alice%20%26%20Bob"
+#   end
+# end
+#
+# describe Hash, 'to_mash' do
+#   before :each do
+#     @hash = Hash.new(10)
+#   end
+#
+#   it "copies default Hash value to Mash" do
+#     @mash = @hash.to_mash
+#     @mash[:merb].should == 10
+#   end
+# end