RubyGems - restify - Versions diffs - 0.2.0.1.b42 → 0.2.0.1.b44 - Mend

restify 0.2.0.1.b42 → 0.2.0.1.b44

Files changed (6) hide show

checksums.yaml CHANGED Viewed

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MzJjZmYxYWVmNjY4ZjhkZDE1NTg0NWRiY2NkOTdkMjQ3NjRkZDEzMg==
+    MjE3MTg2YTE4MDdjMzY0NmRkNWNlOGI1OWRlNjM0MGYxMTc4YWE3Yg==
   data.tar.gz: !binary |-
-    YTcwMzYwZjVmY2E3OTY0NDc0Mjk4MzEwYzc0NWQ4ZDE5MDEyMGEyZg==
+    Y2E4Y2YzMGYwMzZiNmI0NmNhODNkNDFmMDY3N2ZlMmZjYzc3NmExNw==
 SHA512:
   metadata.gz: !binary |-
-    Mzk0NTQxZDQzNjI2N2E3Mzg4NDM4NjZlZWIyNzgyZDVmMWFiMDNkZmU2NjIz
-    NTA1YWIyN2VmZjg4YmQxZGZjYzk1NWQ1MmJmNjJkYWE2NDQ5NDY1MTIxZDRl
-    MDY1YWNkNzk0Y2NiNmQzYTBkYzE0M2ZjNWIxMzc4MDdiMjk5MTA=
+    MjdhNWEzNzExZjVhMzVkYjE4ODhkMGY2MTFjZTcwOWMyMGE1YTNkMjUyZDM4
+    MjA0ZTI1ODE5YjVkYTkyNTdmMzYzZTQxZDFlYzcyNmE2MmM1Y2VkNTFjNTU4
+    NjI1MThjYzI0ZDgyMjgyYWUxMWNkYjVlMmYxMmY4MzAyOTdkNWY=
   data.tar.gz: !binary |-
-    OTQ0YTljNTYwNjUzYmZlMzIwYTMxZDg1OWJjYTYwNTlhYzM5YjdlOTQ4ZGVj
-    NjJiMDAxZWIyYTQ4NmVjMjY0ZTlmN2MxMWU5N2RjZDY2NWE1MTI2N2MwOTM2
-    MjgzNmFiMDg3YmRkNDM4MjEyNjRhZjJhYWQzM2VlOTA3YWU5NDg=
+    NGYyNDRmYTIxOTEyZjc5MjcwNTM2ZmZiOGRmOGVmZTJiMmY3MDk2NDgyNjc5
+    MjE2ZjdhYzkxNDUzZDM3YjhhMGU2OTkyZjFlNWVjZmNiNGQ1ZjA4Y2Q2ODU1
+    NWMzMDVjMDEyNGI4NDIzMzU5NDFmMmM1MjczYjgzNWI0ODdjNTk=

data/vendor/bundle/ruby/2.1.0/bundler/gems/hashie-f42367e30e6a/CHANGELOG.md ADDED Viewed

@@ -0,0 +1,122 @@
+## Next
+* [#247](https://github.com/intridea/hashie/pull/247): Fixed #stringify_keys and #symbolize_keys collision with ActiveSupport - [@bartoszkopinski](https://github.com/bartoszkopinski).
+* [#249](https://github.com/intridea/hashie/pull/249): SafeAssignment will now also protect hash-style assignments - [@jrochkind](https://github.com/jrochkind).
+* [#251](https://github.com/intridea/hashie/pull/251): Add block to indifferent access #fetch - [@jgraichen](https://github.com/jgraichen).
+* [#252](https://github.com/intridia/hashie/pull/252): Add support for conditionally required Hashie::Dash attributes - [@ccashwell](https://github.com/ccashwell).
+* Your contribution here.
+## 3.3.2 (11/26/2014)
+* [#233](https://github.com/intridea/hashie/pull/233): Custom error messages for required properties in Hashie::Dash subclasses - [@joss](https://github.com/joss).
+* [#231](https://github.com/intridea/hashie/pull/231): Added support for coercion on class type that inherit from Hash - [@gregory](https://github.com/gregory).
+* [#228](https://github.com/intridea/hashie/pull/228): Made Hashie::Extensions::Parsers::YamlErbParser pass template filename to ERB - [@jperville](https://github.com/jperville).
+* [#224](https://github.com/intridea/hashie/pull/224): Merging Hashie::Mash now correctly only calls the block on duplicate values - [@amysutedja](https://github.com/amysutedja).
+* [#221](https://github.com/intridea/hashie/pull/221): Reduce amount of allocated objects on calls with suffixes in Hashie::Mash - [@kubum](https://github.com/kubum).
+* [#245](https://github.com/intridea/hashie/pull/245): Added Hashie::Extensions::MethodAccessWithOverride to autoloads - [@Fritzinger](https://github.com/Fritzinger).
+## 3.3.1 (8/26/2014)
+* [#183](https://github.com/intridea/hashie/pull/183): Added Mash#load with YAML file support - [@gregory](https://github.com/gregory).
+* [#195](https://github.com/intridea/hashie/pull/195): Ensure that the same object is returned after injecting IndifferentAccess - [@michaelherold](https://github.com/michaelherold).
+* [#201](https://github.com/intridea/hashie/pull/201): Hashie::Trash transforms can be inherited - [@fobocaster](https://github.com/fobocaster).
+* [#189](https://github.com/intridea/hashie/pull/189): Added Rash#fetch - [@medcat](https://github.com/medcat).
+* [#200](https://github.com/intridea/hashie/pull/200): Improved coercion: primitives and error handling - [@maxlinc](https://github.com/maxlinc).
+* [#204](https://github.com/intridea/hashie/pull/204): Added Hashie::Extensions::MethodOverridingWriter and Hashie::Extensions::MethodAccessWithOverride - [@michaelherold](https://github.com/michaelherold).
+* [#205](http://github.com/intridea/hashie/pull/205): Added Hashie::Extensions::Mash::SafeAssignment - [@michaelherold](https://github.com/michaelherold).
+* [#206](http://github.com/intridea/hashie/pull/206): Fixed stack overflow from repetitively including coercion in subclasses - [@michaelherold](https://github.com/michaelherold).
+* [#207](http://github.com/intridea/hashie/pull/207): Fixed inheritance of transformations in Trash - [@fobocaster](https://github.com/fobocaster).
+* [#209](http://github.com/intridea/hashie/pull/209): Added Hashie::Extensions::DeepFind - [@michaelherold](https://github.com/michaelherold).
+* [#69](https://github.com/intridea/hashie/pull/69): Fixed regression in assigning multiple properties in Hashie::Trash - [@michaelherold](https://github.com/michaelherold), [@einzige](https://github.com/einzige), [@dblock](https://github.com/dblock).
+## 3.2.0 (7/10/2014)
+* [#164](https://github.com/intridea/hashie/pull/164), [#165](https://github.com/intridea/hashie/pull/165), [#166](https://github.com/intridea/hashie/pull/166): Fixed stack overflow when coercing mashes that contain ActiveSupport::HashWithIndifferentAccess values - [@numinit](https://github.com/numinit), [@kgrz](https://github.com/kgrz).
+* [#177](https://github.com/intridea/hashie/pull/177): Added support for coercing enumerables and collections - [@gregory](https://github.com/gregory).
+* [#179](https://github.com/intridea/hashie/pull/179): Mash#values_at will convert each key before doing the lookup - [@nahiluhmot](https://github.com/nahiluhmot).
+* [#184](https://github.com/intridea/hashie/pull/184): Allow ranges on Rash to match all Numeric types - [@medcat](https://github.com/medcat).
+* [#187](https://github.com/intridea/hashie/pull/187): Automatically require version - [@medcat](https://github.com/medcat).
+* [#190](https://github.com/intridea/hashie/issues/190): Fixed `coerce_key` with `from` Trash feature and Coercion extension - [@gregory](https://github.com/gregory).
+* [#192](https://github.com/intridea/hashie/pull/192): Fixed StringifyKeys#stringify_keys! to recursively stringify keys of embedded ::Hash types - [@dblock](https://github.com/dblock).
+## 3.1.0 (6/25/2014)
+* [#169](https://github.com/intridea/hashie/pull/169): Hash#to_hash will also convert nested objects that implement to_hash - [@gregory](https://github.com/gregory).
+* [#171](https://github.com/intridea/hashie/pull/171): Include Trash and Dash class name when raising `NoMethodError` - [@gregory](https://github.com/gregory).
+* [#172](https://github.com/intridea/hashie/pull/172): Added Dash and Trash#update_attributes! - [@gregory](https://github.com/gregory).
+* [#173](https://github.com/intridea/hashie/pull/173): Auto include Dash::IndifferentAccess when IndiferentAccess is included in Dash - [@gregory](https://github.com/gregory).
+* [#174](https://github.com/intridea/hashie/pull/174): Fixed `from` and `transform_with` Trash features when IndifferentAccess is included - [@gregory](https://github.com/gregory).
+## 3.0.0 (6/3/2014)
+**Note:** This version introduces several backward incompatible API changes. See [UPGRADING](UPGRADING.md) for details.
+* [#150](https://github.com/intridea/hashie/pull/159): Handle nil intermediate object on deep fetch - [@stephenaument](https://github.com/stephenaument).
+* [#146](https://github.com/intridea/hashie/issues/146): Mash#respond_to? inconsistent with #method_missing and does not respond to #permitted? - [@dblock](https://github.com/dblock).
+* [#152](https://github.com/intridea/hashie/pull/152): Do not convert keys to String in Hashie::Dash and Hashie::Trash, use Hashie::Extensions::Dash::IndifferentAccess to achieve backward compatible behavior - [@dblock](https://github.com/dblock).
+* [#152](https://github.com/intridea/hashie/pull/152): Do not automatically stringify keys in Hashie::Hash#to_hash, pass `:stringify_keys` to achieve backward compatible behavior - [@dblock](https://github.com/dblock).
+* [#148](https://github.com/intridea/hashie/pull/148): Consolidated Hashie::Hash#stringify_keys implementation - [@dblock](https://github.com/dblock).
+* [#149](https://github.com/intridea/hashie/issues/149): Allow IgnoreUndeclared and DeepMerge to be used with undeclared properties - [@jhaesus](https://github.com/jhaesus).
+## 2.1.1 (4/12/2014)
+* [#144](https://github.com/intridea/hashie/issues/144): Fixed regression invoking `to_hash` with no parameters - [@mbleigh](https://github.com/mbleigh).
+## 2.1.0 (4/6/2014)
+* [#134](https://github.com/intridea/hashie/pull/134): Add deep_fetch extension for nested access - [@tylerdooling](https://github.com/tylerdooling).
+* Removed support for Ruby 1.8.7 - [@dblock](https://github.com/dblock).
+* Ruby style now enforced with Rubocop - [@dblock](https://github.com/dblock).
+* [#138](https://github.com/intridea/hashie/pull/138): Added Hashie#Rash, a hash whose keys can be regular expressions or ranges - [@epitron](https://github.com/epitron).
+* [#131](https://github.com/intridea/hashie/pull/131): Added IgnoreUndeclared, an extension to silently ignore undeclared properties at intialization - [@righi](https://github.com/righi).
+* [#136](https://github.com/intridea/hashie/issues/136): Removed Hashie::Extensions::Structure - [@markiz](https://github.com/markiz).
+* [#107](https://github.com/intridea/hashie/pull/107): Fixed excessive value conversions, poor performance of deep merge in Hashie::Mash - [@davemitchell](https://github.com/dblock), [@dblock](https://github.com/dblock).
+* [#69](https://github.com/intridea/hashie/issues/69): Fixed assigning multiple properties in Hashie::Trash - [@einzige](https://github.com/einzige).
+* [#100](https://github.com/intridea/hashie/pull/100): IndifferentAccess#store will respect indifference - [@jrochkind](https://github.com/jrochkind).
+* [#103](https://github.com/intridea/hashie/pull/103): Fixed support for Hashie::Dash properties that end in bang - [@thedavemarshall](https://github.com/thedavemarshall).
+* [89](https://github.com/intridea/hashie/issues/89): Do not respond to every method with suffix in Hashie::Mash, fixes Rails strong_parameters - [@Maxim-Filimonov](https://github.com/Maxim-Filimonov).
+* [#110](https://github.com/intridea/hashie/pull/110): Correctly use Hash#default from Mash#method_missing - [@ryansouza](https://github.com/ryansouza).
+* [#120](https://github.com/intridea/hashie/pull/120): Pass options to recursive to_hash calls - [@pwillett](https://github.com/pwillett).
+* [#113](https://github.com/intridea/hashie/issues/113): Fixed Hash#merge with Hashie::Dash - [@spencer1248](https://github.com/spencer1248).
+* [#99](https://github.com/intridea/hashie/issues/99): Hash#deep_merge raises errors when it encounters integers - [@defsprite](https://github.com/defsprite).
+* [#133](https://github.com/intridea/hashie/pull/133): Fixed Hash##to_hash with symbolize_keys - [@mhuggins](https://github.com/mhuggins).
+* [#130](https://github.com/intridea/hashie/pull/130): IndifferentAccess now works without MergeInitializer - [@npj](https://github.com/npj).
+* [#111](https://github.com/intridea/hashie/issues/111): Trash#translations correctly maps original to translated names - [@artm](https://github.com/artm).
+* [#129](https://github.com/intridea/hashie/pull/129): Added Trash#permitted_input_keys and inverse_translations - [@artm](https://github.com/artm).
+## 2.0.5
+* [#96](https://github.com/intridea/hashie/pull/96): Make coercion work better with non-symbol keys in Hashie::Mash - [@wapcaplet](https://github.com/wapcaplet).
+## 2.0.4
+* [#04](https://github.com/intridea/hashie/pull/94): Make #fetch method consistent with normal Hash - [@markiz](https://github.com/markiz).
+* [#90](https://github.com/intridea/hashie/pull/90): Various doc tweaks - [@craiglittle](https://github.com/craiglittle).
+## 2.0.3
+* [#88](https://github.com/intridea/hashie/pull/88): Hashie::Mash.new(abc: true).respond_to?(:abc?) works - [@7even](https://github.com/7even).
+* [#68](https://github.com/intridea/hashie/pull/68): Fix #replace - [@jimeh](https://github.com/jimeh).
+## 2.0.2
+* [#85](https://github.com/intridea/hashie/pull/85): adding symbolize_keys back to to_hash - [@cromulus](https://github.com/cromulus).
+## 2.0.1
+* [#81](https://github.com/intridea/hashie/pull/81): remove Mash#object_id override - [@matschaffer](https://github.com/matschaffer).
+* Gem cleanup: removed VERSION, Gemfile.lock [@jch](https://github.com/jch), [@mbleigh](https://github.com/mbleigh).
+## 2.0.0
+* [#72](https://github.com/intridea/hashie/pull/72): Updated gemspec with license info - [@jordimassaguerpla](https://github.com/jordimassaguerpla).
+* [#27](https://github.com/intridea/hashie/pull/27): Initialized with merge coerces values - [@mattfawcett](https://github.com/mattfawcett).
+* [#28](https://github.com/intridea/hashie/pull/28): Hashie::Extensions::Coercion coerce_keys takes arguments - [@mattfawcett](https://github.com/mattfawcett).
+* [#39](https://github.com/intridea/hashie/pull/39): Trash removes translated values on initialization - [@sleverbor](https://github.com/sleverbor).
+* [#66](https://github.com/intridea/hashie/pull/66): Mash#fetch works with symbol or string keys - [@arthwood](https://github.com/arthwood).
+* [#49](https://github.com/intridea/hashie/pull/49): Hashie::Hash inherits from ::Hash to avoid ambiguity - [@meh](https://github.com/meh), [@orend](https://github.com/orend).
+* [#62](https://github.com/intridea/hashie/pull/62): update respond_to? method signature to match ruby core definition - [@dlupu](https://github.com/dlupu).
+* [#41](https://github.com/intridea/hashie/pull/41): DeepMerge extension - [@nashby](https://github.com/nashby).
+* [#63](https://github.com/intridea/hashie/pull/63): Dash defaults are dup'ed before assigned - [@ohrite](https://github.com/ohrite).
+* [#77](https://github.com/intridea/hashie/pull/77): Remove id, type, and object_id as special allowable keys [@jch](https://github.com/jch).
+* [#78](https://github.com/intridea/hashie/pull/78): Merge and update accepts a block - [@jch](https://github.com/jch).

data/vendor/bundle/ruby/2.1.0/bundler/gems/hashie-f42367e30e6a/LICENSE ADDED Viewed

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Intridea, Inc., and Contributors
+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/vendor/bundle/ruby/2.1.0/bundler/gems/hashie-f42367e30e6a/README.md ADDED Viewed

@@ -0,0 +1,556 @@
+# Hashie [![Build Status](https://secure.travis-ci.org/intridea/hashie.png)](http://travis-ci.org/intridea/hashie) [![Dependency Status](https://gemnasium.com/intridea/hashie.png)](https://gemnasium.com/intridea/hashie) [![Code Climate](https://codeclimate.com/github/intridea/hashie.png)](https://codeclimate.com/github/intridea/hashie) [![Test Coverage](https://codeclimate.com/github/intridea/hashie/badges/coverage.png)](https://codeclimate.com/github/intridea/hashie)
+Hashie is a growing collection of tools that extend Hashes and make them more useful.
+## Installation
+Hashie is available as a RubyGem:
+```bash
+$ gem install hashie
+```
+## Upgrading
+You're reading the documentation for the next release of Hashie, which should be 3.3.2. Please read [UPGRADING](UPGRADING.md) when upgrading from a previous version. The current stable release is [3.3.1](https://github.com/intridea/hashie/blob/v3.3.1/README.md).
+## Hash Extensions
+The library is broken up into a number of atomically includeable Hash extension modules as described below. This provides maximum flexibility for users to mix and match functionality while maintaining feature parity with earlier versions of Hashie.
+Any of the extensions listed below can be mixed into a class by `include`-ing `Hashie::Extensions::ExtensionName`.
+### Coercion
+Coercions allow you to set up "coercion rules" based either on the key or the value type to massage data as it's being inserted into the Hash. Key coercions might be used, for example, in lightweight data modeling applications such as an API client:
+```ruby
+class Tweet < Hash
+  include Hashie::Extensions::Coercion
+  coerce_key :user, User
+end
+user_hash = { name: "Bob" }
+Tweet.new(user: user_hash)
+# => automatically calls User.coerce(user_hash) or
+#    User.new(user_hash) if that isn't present.
+```
+Value coercions, on the other hand, will coerce values based on the type of the value being inserted. This is useful if you are trying to build a Hash-like class that is self-propagating.
+```ruby
+class SpecialHash < Hash
+  include Hashie::Extensions::Coercion
+  coerce_value Hash, SpecialHash
+  def initialize(hash = {})
+    super
+    hash.each_pair do |k,v|
+      self[k] = v
+    end
+  end
+end
+```
+### Coercing Collections
+```ruby
+class Tweet < Hash
+  include Hashie::Extensions::Coercion
+  coerce_key :mentions, Array[User]
+  coerce_key :friends, Set[User]
+end
+user_hash = { name: "Bob" }
+mentions_hash= [user_hash, user_hash]
+friends_hash = [user_hash]
+tweet = Tweet.new(mentions: mentions_hash, friends: friends_hash)
+# => automatically calls User.coerce(user_hash) or
+#    User.new(user_hash) if that isn't present on each element of the array
+tweet.mentions.map(&:class) # => [User, User]
+tweet.friends.class # => Set
+```
+### Coercing Hashes
+```ruby
+class Relation
+  def initialize(string)
+    @relation = string
+  end
+end
+class Tweet < Hash
+  include Hashie::Extensions::Coercion
+  coerce_key :relations, Hash[User => Relation]
+end
+user_hash = { name: "Bob" }
+relations_hash= { user_hash => "father", user_hash => "friend" }
+tweet = Tweet.new(relations: relations_hash)
+tweet.relations.map { |k,v| [k.class, v.class] } # => [[User, Relation], [User, Relation]]
+tweet.relations.class # => Hash
+# => automatically calls User.coerce(user_hash) on each key
+#    and Relation.new on each value since Relation doesn't define the `coerce` class method
+```
+### Coercing Core Types
+Hashie handles coercion to the following by using standard conversion methods:
+| type     | method   |
+|----------|----------|
+| Integer  | `#to_i`  |
+| Float    | `#to_f`  |
+| Complex  | `#to_c`  |
+| Rational | `#to_r`  |
+| String   | `#to_s`  |
+| Symbol   | `#to_sym`|
+**Note**: The standard Ruby conversion methods are less strict than you may assume. For example, `:foo.to_i` raises an error but `"foo".to_i` returns 0.
+You can also use coerce from the following supertypes with `coerce_value`:
+- Integer
+- Numeric
+Hashie does not have built-in support for coercion boolean values, since Ruby does not have a built-in boolean type or standard method for to a boolean. You can coerce to booleans using a custom proc.
+### Coercion Proc
+You can use a custom coercion proc on either `#coerce_key` or `#coerce_value`. This is useful for coercing to booleans or other simple types without creating a new class and `coerce` method. For example:
+```ruby
+class Tweet < Hash
+  include Hashie::Extensions::Coercion
+  coerce_key :retweeted, ->(v) do
+    case v
+    when String
+      return !!(v =~ /^(true|t|yes|y|1)$/i)
+    when Numeric
+      return !v.to_i.zero?
+    else
+      return v == true
+    end
+  end
+end
+```
+### KeyConversion
+The KeyConversion extension gives you the convenience methods of `symbolize_keys` and `stringify_keys` along with their bang counterparts. You can also include just stringify or just symbolize with `Hashie::Extensions::StringifyKeys` or `Hashie::Extensions::SymbolizeKeys`.
+### MergeInitializer
+The MergeInitializer extension simply makes it possible to initialize a Hash subclass with another Hash, giving you a quick short-hand.
+### MethodAccess
+The MethodAccess extension allows you to quickly build method-based reading, writing, and querying into your Hash descendant. It can also be included as individual modules, i.e. `Hashie::Extensions::MethodReader`, `Hashie::Extensions::MethodWriter` and `Hashie::Extensions::MethodQuery`.
+```ruby
+class MyHash < Hash
+  include Hashie::Extensions::MethodAccess
+end
+h = MyHash.new
+h.abc = 'def'
+h.abc  # => 'def'
+h.abc? # => true
+```
+### MethodAccessWithOverride
+The MethodAccessWithOverride extension is like the MethodAccess extension, except that it allows you to override Hash methods. It aliases any overridden method with two leading underscores. To include only this overriding functionality, you can include the single module `Hashie::Extensions::MethodOverridingWriter`.
+```ruby
+class MyHash < Hash
+  include Hashie::Extensions::MethodAccess
+end
+class MyOverridingHash < Hash
+  include Hashie::Extensions::MethodAccessWithOverride
+end
+non_overriding = MyHash.new
+non_overriding.zip = 'a-dee-doo-dah'
+non_overriding.zip #=> [[['zip', 'a-dee-doo-dah']]]
+overriding = MyHash.new
+overriding.zip = 'a-dee-doo-dah'
+overriding.zip   #=> 'a-dee-doo-dah'
+overriding.__zip #=> [[['zip', 'a-dee-doo-dah']]]
+```
+### IndifferentAccess
+This extension can be mixed in to instantly give you indifferent access to your Hash subclass. This works just like the params hash in Rails and other frameworks where whether you provide symbols or strings to access keys, you will get the same results.
+A unique feature of Hashie's IndifferentAccess mixin is that it will inject itself recursively into subhashes *without* reinitializing the hash in question. This means you can safely merge together indifferent and non-indifferent hashes arbitrarily deeply without worrying about whether you'll be able to `hash[:other][:another]` properly.
+### IgnoreUndeclared
+This extension can be mixed in to silently ignore undeclared properties on initialization instead of raising an error. This is useful when using a Trash to capture a subset of a larger hash.
+```ruby
+class Person < Trash
+  include Hashie::Extensions::IgnoreUndeclared
+  property :first_name
+  property :last_name
+end
+user_data = {
+  first_name: 'Freddy',
+  last_name: 'Nostrils',
+  email: 'freddy@example.com'
+}
+p = Person.new(user_data) # 'email' is silently ignored
+p.first_name # => 'Freddy'
+p.last_name  # => 'Nostrils'
+p.email      # => NoMethodError
+```
+### DeepMerge
+This extension allow you to easily include a recursive merging
+system to any Hash descendant:
+```ruby
+class MyHash < Hash
+  include Hashie::Extensions::DeepMerge
+end
+h1 = MyHash[{ x: { y: [4,5,6] }, z: [7,8,9] }]
+h2 = MyHash[{ x: { y: [7,8,9] }, z: "xyz" }]
+h1.deep_merge(h2) # => { x: { y: [7, 8, 9] }, z: "xyz" }
+h2.deep_merge(h1) # => { x: { y: [4, 5, 6] }, z: [7, 8, 9] }
+```
+### DeepFetch
+This extension can be mixed in to provide for safe and concise retrieval of deeply nested hash values. In the event that the requested key does not exist a block can be provided and its value will be returned.
+Though this is a hash extension, it conveniently allows for arrays to be present in the nested structure. This feature makes the extension particularly useful for working with JSON API responses.
+```ruby
+user = {
+  name: { first: 'Bob', last: 'Boberts' },
+  groups: [
+    { name: 'Rubyists' },
+    { name: 'Open source enthusiasts' }
+  ]
+}
+user.extend Hashie::Extensions::DeepFetch
+user.deep_fetch :name, :first # => 'Bob'
+user.deep_fetch :name, :middle # => 'KeyError: Could not fetch middle'
+# using a default block
+user.deep_fetch(:name, :middle) { |key| 'default' }  # =>  'default'
+# a nested array
+user.deep_fetch :groups, 1, :name # => 'Open source enthusiasts'
+```
+### DeepFind
+This extension can be mixed in to provide for concise searching for keys within a deeply nested hash.
+It can also search through any Enumerable contained within the hash for objects with the specified key.
+Note: The searches are depth-first, so it is not guaranteed that a shallowly nested value will be found before a deeply nested value.
+```ruby
+user = {
+  name: { first: 'Bob', last: 'Boberts' },
+  groups: [
+    { name: 'Rubyists' },
+    { name: 'Open source enthusiasts' }
+  ]
+}
+user.extend Hashie::Extensions::DeepFind
+user.deep_find(:name)   #=> { first: 'Bob', last: 'Boberts' }
+user.deep_detect(:name) #=> { first: 'Bob', last: 'Boberts' }
+user.deep_find_all(:name) #=> [{ first: 'Bob', last: 'Boberts' }, 'Rubyists', 'Open source enthusiasts']
+user.deep_select(:name)   #=> [{ first: 'Bob', last: 'Boberts' }, 'Rubyists', 'Open source enthusiasts']
+```
+## Mash
+Mash is an extended Hash that gives simple pseudo-object functionality that can be built from hashes and easily extended. It is intended to give the user easier access to the objects within the Mash through a property-like syntax, while still retaining all Hash functionality.
+### Example:
+```ruby
+mash = Hashie::Mash.new
+mash.name? # => false
+mash.name # => nil
+mash.name = "My Mash"
+mash.name # => "My Mash"
+mash.name? # => true
+mash.inspect # => <Hashie::Mash name="My Mash">
+mash = Hashie::Mash.new
+# use bang methods for multi-level assignment
+mash.author!.name = "Michael Bleigh"
+mash.author # => <Hashie::Mash name="Michael Bleigh">
+mash = Hashie::Mash.new
+# use under-bang methods for multi-level testing
+mash.author_.name? # => false
+mash.inspect # => <Hashie::Mash>
+```
+**Note:** The `?` method will return false if a key has been set to false or nil. In order to check if a key has been set at all, use the `mash.key?('some_key')` method instead.
+Please note that a Mash will not override methods through the use of the property-like syntax. This can lead to confusion if you expect to be able to access a Mash value through the property-like syntax for a key that conflicts with a method name. However, it protects users of your library from the unexpected behavior of those methods being overridden behind the scenes.
+### Example:
+```ruby
+mash = Hashie::Mash.new
+mash.name = "My Mash"
+mash.zip = "Method Override?"
+mash.zip # => [[["name", "My Mash"]], [["zip", "Method Override?"]]]
+```
+Mash allows you also to transform any files into a Mash objects.
+### Example:
+```yml
+#/etc/config/settings/twitter.yml
+development:
+  api_key: 'api_key'
+production:
+  api_key: <%= ENV['API_KEY'] %> #let's say that ENV['API_KEY'] is set to 'abcd'
+```
+```ruby
+mash = Mash.load('settings/twitter.yml')
+mash.development.api_key # => 'localhost'
+mash.development.api_key = "foo" # => <# RuntimeError can't modify frozen ...>
+mash.development.api_key? # => true
+```
+You can access a Mash from another class:
+```ruby
+mash = Mash.load('settings/twitter.yml')[ENV['RACK_ENV']]
+Twitter.extend mash.to_module # NOTE: if you want another name than settings, call: to_module('my_settings')
+Twitter.settings.api_key # => 'abcd'
+```
+You can use another parser (by default: YamlErbParser):
+```
+#/etc/data/user.csv
+id | name          | lastname
+---|------------- | -------------
+1  |John          | Doe
+2  |Laurent       | Garnier
+```
+```ruby
+mash = Mash.load('data/user.csv', parser: MyCustomCsvParser)
+# => { 1 => { name: 'John', lastname: 'Doe'}, 2 => { name: 'Laurent', lastname: 'Garnier' } }
+mash[1] #=> { name: 'John', lastname: 'Doe' }
+```
+### Mash Extension: SafeAssignment
+This extension can be mixed into a Mash to guard the attempted overwriting of methods by property setters. When mixed in, the Mash will raise an `ArgumentError` if you attempt to write a property with the same name as an existing method.
+#### Example:
+```ruby
+class SafeMash < ::Hashie::Mash
+  include Hashie::Extensions::Mash::SafeAssignment
+end
+safe_mash = SafeMash.new
+safe_mash.zip   = 'Test' # => ArgumentError
+safe_mash[:zip] = 'test' # => still ArgumentError
+```
+## Dash
+Dash is an extended Hash that has a discrete set of defined properties and only those properties may be set on the hash. Additionally, you can set defaults for each property. You can also flag a property as required. Required properties will raise an exception if unset. Another option is message for required properties, which allow you to add custom messages for required property.
+You can also conditionally require certain properties by passing a Proc or Symbol. If a Proc is provided, it will be run in the context of the Dash instance. If a Symbol is provided, the value returned for the property or method of the same name will be evaluated. The property will be required if the result of the conditional is truthy.
+### Example:
+```ruby
+class Person < Hashie::Dash
+  property :name, required: true
+  property :age, required: true, message: 'must be set.'
+  property :email
+  property :phone, required: -> { email.nil? }, message: 'is required if email is not set.'
+  property :pants, required: :weekday?, message: 'are only required on weekdays.'
+  property :occupation, default: 'Rubyist'
+  def weekday?
+    [ Time.now.saturday?, Time.now.sunday? ].none?
+  end
+end
+p = Person.new # => ArgumentError: The property 'name' is required for this Dash.
+p = Person.new(name: 'Bob') # => ArgumentError: The property 'age' must be set.
+p = Person.new(name: "Bob", age: 18)
+p.name         # => 'Bob'
+p.name = nil   # => ArgumentError: The property 'name' is required for this Dash.
+p.age          # => 18
+p.age = nil    # => ArgumentError: The property 'age' must be set.
+p.email = 'abc@def.com'
+p.occupation   # => 'Rubyist'
+p.email        # => 'abc@def.com'
+p[:awesome]    # => NoMethodError
+p[:occupation] # => 'Rubyist'
+p.update_attributes!(name: 'Trudy', occupation: 'Evil')
+p.occupation   # => 'Evil'
+p.name         # => 'Trudy'
+p.update_attributes!(occupation: nil)
+p.occupation   # => 'Rubyist'
+```
+Properties defined as symbols are not the same thing as properties defined as strings.
+### Example:
+```ruby
+class Tricky < Hashie::Dash
+  property :trick
+  property 'trick'
+end
+p = Tricky.new(trick: 'one', 'trick' => 'two')
+p.trick # => 'one', always symbol version
+p[:trick] # => 'one'
+p['trick'] # => 'two'
+```
+Note that accessing a property as a method always uses the symbol version.
+```ruby
+class Tricky < Hashie::Dash
+  property 'trick'
+end
+p = Tricky.new('trick' => 'two')
+p.trick # => NoMethodError
+```
+### Mash and Rails 4 Strong Parameters
+To enable compatibility with Rails 4 use the [hashie_rails](http://rubygems.org/gems/hashie_rails) gem.
+## Trash
+A Trash is a Dash that allows you to translate keys on initialization. It is used like so:
+```ruby
+class Person < Hashie::Trash
+  property :first_name, from: :firstName
+end
+```
+This will automatically translate the <tt>firstName</tt> key to <tt>first_name</tt>
+when it is initialized using a hash such as through:
+```ruby
+Person.new(firstName: 'Bob')
+```
+Trash also supports translations using lambda, this could be useful when dealing with external API's. You can use it in this way:
+```ruby
+class Result < Hashie::Trash
+  property :id, transform_with: lambda { |v| v.to_i }
+  property :created_at, from: :creation_date, with: lambda { |v| Time.parse(v) }
+end
+```
+this will produce the following
+```ruby
+result = Result.new(id: '123', creation_date: '2012-03-30 17:23:28')
+result.id.class         # => Fixnum
+result.created_at.class # => Time
+```
+## Clash
+Clash is a Chainable Lazy Hash that allows you to easily construct complex hashes using method notation chaining. This will allow you to use a more action-oriented approach to building options hashes.
+Essentially, a Clash is a generalized way to provide much of the same kind of "chainability" that libraries like Arel or Rails 2.x's named_scopes provide.
+### Example:
+```ruby
+c = Hashie::Clash.new
+c.where(abc: 'def').order(:created_at)
+c # => { where: { abc: 'def' }, order: :created_at }
+# You can also use bang notation to chain into sub-hashes,
+# jumping back up the chain with _end!
+c = Hashie::Clash.new
+c.where!.abc('def').ghi(123)._end!.order(:created_at)
+c # => { where: { abc: 'def', ghi: 123 }, order: :created_at }
+# Multiple hashes are merged automatically
+c = Hashie::Clash.new
+c.where(abc: 'def').where(hgi: 123)
+c # => { where: { abc: 'def', hgi: 123 } }
+```
+## Rash
+Rash is a Hash whose keys can be Regexps or Ranges, which will map many input keys to a value.
+A good use case for the Rash is an URL router for a web framework, where URLs need to be mapped to actions; the Rash's keys match URL patterns, while the values call the action which handles the URL.
+If the Rash's value is a `proc`, the `proc` will be automatically called with the regexp's MatchData (matched groups) as a block argument.
+### Example:
+```ruby
+# Mapping names to appropriate greetings
+greeting = Hashie::Rash.new( /^Mr./ => "Hello sir!", /^Mrs./ => "Evening, madame." )
+greeting["Mr. Steve Austin"] # => "Hello sir!"
+greeting["Mrs. Steve Austin"] # => "Evening, madame."
+# Mapping statements to saucy retorts
+mapper = Hashie::Rash.new(
+  /I like (.+)/ => proc { |m| "Who DOESN'T like #{m[1]}?!" },
+  /Get off my (.+)!/ => proc { |m| "Forget your #{m[1]}, old man!" }
+)
+mapper["I like traffic lights"] # => "Who DOESN'T like traffic lights?!"
+mapper["Get off my lawn!"]      # => "Forget your lawn, old man!"
+```
+### Auto-optimized
+**Note:** The Rash is automatically optimized every 500 accesses (which means that it sorts the list of Regexps, putting the most frequently matched ones at the beginning).
+If this value is too low or too high for your needs, you can tune it by setting: `rash.optimize_every = n`.
+## Contributing
+See [CONTRIBUTING.md](CONTRIBUTING.md)
+## Copyright
+Copyright (c) 2009-2014 Intridea, Inc. (http://intridea.com/) and [contributors](https://github.com/intridea/hashie/graphs/contributors).
+MIT License. See [LICENSE](LICENSE) for details.

data/vendor/bundle/ruby/2.1.0/bundler/gems/hashie-f42367e30e6a/hashie.gemspec ADDED Viewed

@@ -0,0 +1,35 @@
+# -*- encoding: utf-8 -*-
+# stub: hashie 3.3.3 ruby lib
+Gem::Specification.new do |s|
+  s.name = "hashie"
+  s.version = "3.3.3"
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib"]
+  s.authors = ["Michael Bleigh", "Jerry Cheung"]
+  s.date = "2014-12-18"
+  s.description = "Hashie is a collection of classes and mixins that make hashes more powerful."
+  s.email = ["michael@intridea.com", "jollyjerry@gmail.com"]
+  s.files = [".yardopts", "CHANGELOG.md", "CONTRIBUTING.md", "LICENSE", "README.md", "Rakefile", "UPGRADING.md", "hashie.gemspec", "lib/hashie.rb", "lib/hashie/clash.rb", "lib/hashie/dash.rb", "lib/hashie/extensions/coercion.rb", "lib/hashie/extensions/dash/indifferent_access.rb", "lib/hashie/extensions/deep_fetch.rb", "lib/hashie/extensions/deep_find.rb", "lib/hashie/extensions/deep_merge.rb", "lib/hashie/extensions/ignore_undeclared.rb", "lib/hashie/extensions/indifferent_access.rb", "lib/hashie/extensions/key_conversion.rb", "lib/hashie/extensions/mash/safe_assignment.rb", "lib/hashie/extensions/merge_initializer.rb", "lib/hashie/extensions/method_access.rb", "lib/hashie/extensions/parsers/yaml_erb_parser.rb", "lib/hashie/extensions/pretty_inspect.rb", "lib/hashie/extensions/stringify_keys.rb", "lib/hashie/extensions/symbolize_keys.rb", "lib/hashie/hash.rb", "lib/hashie/mash.rb", "lib/hashie/rash.rb", "lib/hashie/trash.rb", "lib/hashie/version.rb", "spec/hashie/clash_spec.rb", "spec/hashie/dash_spec.rb", "spec/hashie/extensions/autoload_spec.rb", "spec/hashie/extensions/coercion_spec.rb", "spec/hashie/extensions/dash/indifferent_access_spec.rb", "spec/hashie/extensions/deep_fetch_spec.rb", "spec/hashie/extensions/deep_find_spec.rb", "spec/hashie/extensions/deep_merge_spec.rb", "spec/hashie/extensions/ignore_undeclared_spec.rb", "spec/hashie/extensions/indifferent_access_spec.rb", "spec/hashie/extensions/indifferent_access_with_rails_hwia_spec.rb", "spec/hashie/extensions/key_conversion_spec.rb", "spec/hashie/extensions/mash/safe_assignment_spec.rb", "spec/hashie/extensions/merge_initializer_spec.rb", "spec/hashie/extensions/method_access_spec.rb", "spec/hashie/extensions/stringify_keys_spec.rb", "spec/hashie/extensions/symbolize_keys_spec.rb", "spec/hashie/hash_spec.rb", "spec/hashie/mash_spec.rb", "spec/hashie/parsers/yaml_erb_parser_spec.rb", "spec/hashie/rash_spec.rb", "spec/hashie/trash_spec.rb", "spec/hashie/version_spec.rb", "spec/spec_helper.rb", "spec/support/module_context.rb"]
+  s.homepage = "https://github.com/intridea/hashie"
+  s.licenses = ["MIT"]
+  s.rubygems_version = "2.4.5"
+  s.summary = "Your friendly neighborhood hash library."
+  s.test_files = ["spec/support/module_context.rb", "spec/spec_helper.rb", "spec/hashie/version_spec.rb", "spec/hashie/trash_spec.rb", "spec/hashie/rash_spec.rb", "spec/hashie/parsers/yaml_erb_parser_spec.rb", "spec/hashie/mash_spec.rb", "spec/hashie/hash_spec.rb", "spec/hashie/extensions/symbolize_keys_spec.rb", "spec/hashie/extensions/stringify_keys_spec.rb", "spec/hashie/extensions/method_access_spec.rb", "spec/hashie/extensions/merge_initializer_spec.rb", "spec/hashie/extensions/mash/safe_assignment_spec.rb", "spec/hashie/extensions/key_conversion_spec.rb", "spec/hashie/extensions/indifferent_access_with_rails_hwia_spec.rb", "spec/hashie/extensions/indifferent_access_spec.rb", "spec/hashie/extensions/ignore_undeclared_spec.rb", "spec/hashie/extensions/deep_merge_spec.rb", "spec/hashie/extensions/deep_find_spec.rb", "spec/hashie/extensions/deep_fetch_spec.rb", "spec/hashie/extensions/dash/indifferent_access_spec.rb", "spec/hashie/extensions/coercion_spec.rb", "spec/hashie/extensions/autoload_spec.rb", "spec/hashie/dash_spec.rb", "spec/hashie/clash_spec.rb"]
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rake>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, ["~> 3.0"])
+    else
+      s.add_dependency(%q<rake>, [">= 0"])
+      s.add_dependency(%q<rspec>, ["~> 3.0"])
+    end
+  else
+    s.add_dependency(%q<rake>, [">= 0"])
+    s.add_dependency(%q<rspec>, ["~> 3.0"])
+  end
+end

metadata CHANGED Viewed

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: restify
 version: !ruby/object:Gem::Version
-  version: 0.2.0.1.b42
+  version: 0.2.0.1.b44
 platform: ruby
 authors:
 - Jan Graichen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-12-16 00:00:00.000000000 Z
+date: 2014-12-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: obligation
@@ -140,6 +140,10 @@ files:
 - spec/restify/resource_spec.rb
 - spec/restify_spec.rb
 - spec/spec_helper.rb
+- vendor/bundle/ruby/2.1.0/bundler/gems/hashie-f42367e30e6a/CHANGELOG.md
+- vendor/bundle/ruby/2.1.0/bundler/gems/hashie-f42367e30e6a/LICENSE
+- vendor/bundle/ruby/2.1.0/bundler/gems/hashie-f42367e30e6a/README.md
+- vendor/bundle/ruby/2.1.0/bundler/gems/hashie-f42367e30e6a/hashie.gemspec
 homepage: https://github.com/jgraichen/restify
 licenses:
 - LGPLv3