hashie 2.0.5 → 2.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1fd1f73bdb3a592938fb9e274e7306c16c2410b8
+  data.tar.gz: 545f19b3a9989433f31c047af0fdf477789f8d10
+SHA512:
+  metadata.gz: 4a96ffb374b4560d0276412d43ceaa5717aa963e5c8e596343c6cf484081cc2f1b49b7725b97eb9c64baf33631e96f8ccecc1ee95dc470c2fe677334f3c38a45
+  data.tar.gz: e67465dc21d6a9eef56e3eb7b603d41471a926c42e2a4f687d4e2c4ead92522e04dc03408b6854f7d594b7a9510d517d432208e94287a1f77c13008d4a5a40f8

data/.rubocop.yml

@@ -0,0 +1,36 @@
+AllCops:
+  Exclude:
+    - vendor/**
+    - bin/**
+    - .bundle/**
+
+LineLength:
+  Enabled: false
+
+MethodLength:
+  Enabled: false
+
+ClassLength:
+  Enabled: false
+
+Documentation:
+  # don't require classes to be documented
+  Enabled: false
+
+Encoding:
+  # no need to always specify encoding
+  Enabled: false
+
+Lambda:
+  # TODO: replace all lambda with -> or Proc
+  Enabled: false
+
+CyclomaticComplexity:
+  Enabled: false
+
+DoubleNegation:
+  Enabled: false
+
+CaseEquality:
+  Enabled: false
+

data/.travis.yml

@@ -1,8 +1,15 @@
+language: ruby
 rvm:
-  - 2.0.0
-  - 1.8.7
-  - 1.9.2
-  - rbx
-  - ree
   - ruby-head
-  - jruby
+  - 2.1.1
+  - 2.1.0
+  - 2.0.0
+  - 1.9.3
+  - jruby-19mode
+  - jruby-head
+  - rbx-2.1
+  - rbx-2.2
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: jruby-head

data/CHANGELOG.md

@@ -1,39 +1,58 @@
-# CHANGELOG
+## Next Release
+
+* [#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
 
-* make coercion work better with non-symbol keys in mash wapcaplet #96
+* [#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
 
-* make #fetch method consistent with normal Hash markiz #94
-* various doc tweaks craiglittle #90
+* [#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
 
-* Hashie::Mash.new(abc: true).respond_to?(:abc?) works 7even #88
-* Fix #replace jimeh #68
+* [#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
 
-* adding symbolize_keys back to to_hash cromulus #85
+* [#85](https://github.com/intridea/hashie/pull/85): adding symbolize_keys back to to_hash - [@cromulus](https://github.com/cromulus).
 
 ## 2.0.1
 
-* remove Mash#object_id override matschaffer #81
-* gem cleanup: remove VERSION, Gemfile.lock jch, mbleigh
+* [#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
 
-* update gemspec with license info jordimassaguerpla #72
-* fix readme typo jcamenisch #71
-* initialize with merge coerces values mattfawcett #27
-* Hashie::Extensions::Coercion coerce_keys takes arguments mattfawcett #28
-* Trash removes translated values on initialization sleverbor #39
-* Mash#fetch works with symbol or string keys arthwood #66
-* Hashie::Hash inherits from ::Hash to avoid ambiguity meh, orend #49
-* update respond_to? method signature to match ruby core definition dlupu #62
-* DeepMerge extension nashby #41
-* Dash defaults are dup'ed before assigned ohrite #63
-* remove id, type, and object_id as special allowable keys jch #77
-* merge and update accepts a block jch #78
+* [#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/CONTRIBUTING.md

@@ -1,27 +1,118 @@
-## Note on Patches/Pull Requests
+Contributing to Hashie
+======================
 
-Thanks for taking the time to contribute back! To make it easier for us to
-review your changes, try to follow these guidelines:
+Hashie is work of [many contributors](https://github.com/intridea/hashie/graphs/contributors). You're encouraged to submit [pull requests](https://github.com/intridea/hashie/pulls), [propose features and discuss issues](https://github.com/intridea/hashie/issues).
 
-* Keep changesets small and on topic. Itching to refactor or clean something
-  up? Do it in a separate branch.
-* Stay consistent with existing code conventions.
-* Break changes into smaller logical commits.
+#### Fork the Project
 
-To propose a change:
+Fork the [project on Github](https://github.com/intridea/hashie) and check out your copy.
 
-* [Fork the project.](https://help.github.com/articles/fork-a-repo)
-* Make your feature addition or bug fix.
-* Add tests for it. This is important so I don't break it in a future version unintentionally.
-* Commit, do not mess with rakefile, version, or history. (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
-* [Send me a pull request](https://help.github.com/articles/using-pull-requests). Bonus points for topic branches.
-* [Check that your pull request passes the build](https://travis-ci.org/intridea/hashie/pull_requests).
+```
+git clone https://github.com/contributor/hashie.git
+cd hashie
+git remote add upstream https://github.com/intridea/hashie.git
+```
 
-## Bug triage
+#### Create a Topic Branch
 
-Have a problem? File an [issue here](https://github.com/intridea/hashie/issues).
+Make sure your fork is up-to-date and create a topic branch for your feature or bug fix.
 
-To make bug squashing easier, include the following in your issue:
+```
+git checkout master
+git pull upstream master
+git checkout -b my-feature-branch
+```
 
-* What version of hashie are you using?
-* Is it still a problem in master?
+#### Bundle Install and Test
+
+Ensure that you can build the project and run tests.
+
+```
+bundle install
+bundle exec rake
+```
+
+#### Write Tests
+
+Try to write a test that reproduces the problem you're trying to fix or describes a feature that you want to build. Add to [spec/hashie](spec/hashie).
+
+We definitely appreciate pull requests that highlight or reproduce a problem, even without a fix.
+
+#### Write Code
+
+Implement your feature or bug fix.
+
+Ruby style is enforced with [Rubocop](https://github.com/bbatsov/rubocop), run `bundle exec rubocop` and fix any style issues highlighted.
+
+Make sure that `bundle exec rake` completes without errors.
+
+#### Write Documentation
+
+Document any external behavior in the [README](README.md).
+
+#### Update Changelog
+
+Add a line to [CHANGELOG](CHANGELOG.md) under *Next Release*. Make it look like every other line, including your name and link to your Github account.
+
+#### Commit Changes
+
+Make sure git knows your name and email address:
+
+```
+git config --global user.name "Your Name"
+git config --global user.email "contributor@example.com"
+```
+
+Writing good commit logs is important. A commit log should describe what changed and why.
+
+```
+git add ...
+git commit
+```
+
+#### Push
+
+```
+git push origin my-feature-branch
+```
+
+#### Make a Pull Request
+
+Go to https://github.com/contributor/hashie and select your feature branch. Click the 'Pull Request' button and fill out the form. Pull requests are usually reviewed within a few days.
+
+#### Rebase
+
+If you've been working on a change for a while, rebase with upstream/master.
+
+```
+git fetch upstream
+git rebase upstream/master
+git push origin my-feature-branch -f
+```
+
+#### Update CHANGELOG Again
+
+Update the [CHANGELOG](CHANGELOG.md) with the pull request number. A typical entry looks as follows.
+
+```
+* [#123](https://github.com/intridea/hashie/pull/123): Reticulated splines - [@contributor](https://github.com/contributor).
+```
+
+Amend your previous commit and force push the changes.
+
+```
+git commit --amend
+git push origin my-feature-branch -f
+```
+
+#### Check on Your Pull Request
+
+Go back to your pull request after a few minutes and see whether it passed muster with Travis-CI. Everything should look green, otherwise fix issues and amend your commit as described above.
+
+#### Be Patient
+
+It's likely that your change will not be merged and that the nitpicky maintainers will ask you to do more, or fix seemingly benign problems. Hang on there!
+
+#### Thank You
+
+Please do know that we really appreciate and value your time and work. We love you, really.

data/Gemfile

@@ -1,2 +1,11 @@
 source 'http://rubygems.org'
+
+platforms :rbx do
+  gem 'rubysl'
+  gem 'rubinius-developer_tools'
+  gem 'racc'
+end
+
 gemspec
+
+gem 'rubocop', '0.20.0'

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009 Intridea, Inc.
+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

data/README.md

@@ -0,0 +1,347 @@
+# 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)
+
+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
+```
+
+## 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
+```
+
+### 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
+```
+
+### 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.new
+h2 = MyHash.new
+
+h1 = { x: { y: [4,5,6] }, z: [7,8,9] }
+h2 = { 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'
+```
+
+## Mash
+
+Mash is an extended Hash that gives simple pseudo-object functionality
+that can be built from hashes and easily extended. It is designed to
+be used in RESTful API libraries to provide easy object-like access
+to JSON and XML parsed hashes.
+
+### 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 = Mash.new
+# use bang methods for multi-level assignment
+mash.author!.name = "Michael Bleigh"
+mash.author # => <Hashie::Mash name="Michael Bleigh">
+
+mash = 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.
+
+## 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.
+
+### Example:
+
+```ruby
+class Person < Hashie::Dash
+  property :name, required: true
+  property :email
+  property :occupation, default: 'Rubyist'
+end
+
+p = Person.new # => ArgumentError: The property 'name' is required for this Dash.
+
+p = Person.new(name: "Bob")
+p.name # => 'Bob'
+p.name = nil # => ArgumentError: The property 'name' is required for this Dash.
+p.email = 'abc@def.com'
+p.occupation   # => 'Rubyist'
+p.email        # => 'abc@def.com'
+p[:awesome]    # => NoMethodError
+p[:occupation] # => 'Rubyist'
+```
+
+## 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.