hashie 4.1.0 → 5.1.0

data/README.md

@@ -2,11 +2,53 @@
 
 [![Join the chat at https://gitter.im/hashie/hashie](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/hashie/hashie?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 [![Gem Version](http://img.shields.io/gem/v/hashie.svg)](http://badge.fury.io/rb/hashie)
-[![Build Status](http://img.shields.io/travis/hashie/hashie.svg)](https://travis-ci.org/hashie/hashie)
-[![Test Coverage](https://api.codeclimate.com/v1/badges/7a0b42c8a22c945571fd/test_coverage)](https://codeclimate.com/github/hashie/hashie/test_coverage)
-[![Maintainability](https://api.codeclimate.com/v1/badges/7a0b42c8a22c945571fd/maintainability)](https://codeclimate.com/github/hashie/hashie/maintainability)
-
-Hashie is a growing collection of tools that extend Hashes and make them more useful.
+[![Build Status](https://github.com/hashie/hashie/actions/workflows/test.yml/badge.svg)](https://github.com/hashie/hashie/actions/workflows/test.yml)
+
+[![eierlegende Wollmilchsau](./mascot.svg)](#mascot) Hashie is a growing collection of tools that extend Hashes and make them more useful.
+
+# Table of Contents
+
+- [Installation](#installation)
+- [Stable Release](#stable-release)
+- [Hash Extensions](#hash-extensions)
+- [Logging](#logging)
+  - [Coercion](#coercion)
+  - [Coercing Collections](#coercing-collections)
+  - [Coercing Hashes](#coercing-hashes)
+  - [Coercing Core Types](#coercing-core-types)
+  - [Coercion Proc](#coercion-proc)
+    - [A note on circular coercion](#a-note-on-circular-coercion)
+  - [KeyConversion](#keyconversion)
+  - [MergeInitializer](#mergeinitializer)
+  - [MethodAccess](#methodaccess)
+  - [MethodAccessWithOverride](#methodaccesswithoverride)
+  - [MethodOverridingInitializer](#methodoverridinginitializer)
+  - [IndifferentAccess](#indifferentaccess)
+  - [IgnoreUndeclared](#ignoreundeclared)
+  - [DeepMerge](#deepmerge)
+  - [DeepFetch](#deepfetch)
+  - [DeepFind](#deepfind)
+  - [DeepLocate](#deeplocate)
+- [StrictKeyAccess](#strictkeyaccess)
+- [Mash](#mash)
+  - [KeepOriginalKeys](#keeporiginalkeys)
+  - [PermissiveRespondTo](#permissiverespondto)
+  - [SafeAssignment](#safeassignment)
+  - [SymbolizeKeys](#symbolizekeys)
+  - [DefineAccessors](#defineaccessors)
+- [Dash](#dash)
+  - [Potential Gotchas](#potential-gotchas)
+  - [PropertyTranslation](#propertytranslation)
+  - [Mash and Rails 4 Strong Parameters](#mash-and-rails-4-strong-parameters)
+  - [Coercion](#coercion-1)
+  - [PredefinedValues](#predefinedvalues)
+- [Trash](#trash)
+- [Clash](#clash)
+- [Rash](#rash)
+  - [Auto-Optimized](#auto-optimized)
+- [Mascot](#mascot)
+- [Contributing](#contributing)
+- [Copyright](#copyright)
 
 ## Installation
 
@@ -18,7 +60,7 @@ $ gem install hashie
 
 ## Stable Release
 
-You're reading the documentation for the stable release of Hashie, 4.1.0.(https://github.com/hashie/hashie/blob/v4.1.0/README.md).
+You're reading the documentation for the stable release of Hashie, 5.1.0.
 
 ## Hash Extensions
 
@@ -190,13 +232,13 @@ 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`](#mash-extension-symbolizekeys).
+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`.
 
 Hashie also has a utility method for converting keys on a Hash without a mixin:
 
 ```ruby
-Hashie.symbolize_keys! hash # => Symbolizes keys of hash.
-Hashie.symbolize_keys hash # => Returns a copy of hash with keys symbolized.
+Hashie.symbolize_keys! hash # => Symbolizes all string keys of hash.
+Hashie.symbolize_keys hash # => Returns a copy of hash with string keys symbolized.
 Hashie.stringify_keys! hash # => Stringifies keys of hash.
 Hashie.stringify_keys hash # => Returns a copy of hash with keys stringified.
 ```
@@ -269,8 +311,6 @@ This extension can be mixed in to your Hash subclass to allow you to use Strings
 
 In addition, IndifferentAccess will also inject itself into sub-hashes so they behave the same.
 
-Example:
-
 ```ruby
 class MyHash < Hash
   include Hashie::Extensions::MergeInitializer
@@ -290,6 +330,18 @@ myhash['fishes'][:food] = 'flakes'
 myhash['fishes']['food'] # => "flakes"
 ```
 
+To get back a normal, not-indifferent Hash, you can use `#to_hash` on the indifferent hash. It exports the keys as strings, not symbols:
+
+```ruby
+myhash = MyHash.new
+myhash["foo"] = "bar"
+myhash[:foo]  #=> "bar"
+
+normal_hash = myhash.to_hash
+myhash["foo"]  #=> "bar"
+myhash[:foo]  #=> nil
+```
+
 ### 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.
@@ -445,8 +497,6 @@ books.deep_locate -> (key, value, object) { key == :pages && value <= 120 }
 
 This extension can be mixed in to allow a Hash to raise an error when attempting to extract a value using a non-existent key.
 
-### Example:
-
 ```ruby
 class StrictKeyAccessHash < Hash
   include Hashie::Extensions::StrictKeyAccess
@@ -464,8 +514,6 @@ end
 
 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
@@ -488,12 +536,10 @@ 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.
 
-### How does Mash handle conflicts with pre-existing methods?
+_How does Mash handle conflicts with pre-existing methods?_
 
 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"
@@ -564,12 +610,10 @@ Hashie::Mash.quiet.new(zip: '90210', compact: true) # no errors logged
 Hashie::Mash.quiet(:zip).new(zip: '90210', compact: true) # error logged for compact
 ```
 
-### How does the wrapping of Mash sub-Hashes work?
+_How does the wrapping of Mash sub-Hashes work?_
 
 Mash duplicates any sub-Hashes that you add to it and wraps them in a Mash. This allows for infinite chaining of nested Hashes within a Mash without modifying the object(s) that are passed into the Mash. When you subclass Mash, the subclass wraps any sub-Hashes in its own class. This preserves any extensions that you mixed into the Mash subclass and allows them to work within the sub-Hashes, in addition to the main containing Mash.
 
-#### Example:
-
 ```ruby
 mash = Hashie::Mash.new(name: "Hashie", dependencies: { rake: "< 11", rspec: "~> 3.0" })
 mash.dependencies.class #=> Hashie::Mash
@@ -579,11 +623,20 @@ my_gem = MyGem.new(name: "Hashie", dependencies: { rake: "< 11", rspec: "~> 3.0"
 my_gem.dependencies.class #=> MyGem
 ```
 
-### What else can Mash do?
+_How does Mash handle key types which cannot be symbolized?_
 
-Mash allows you also to transform any files into a Mash objects.
+Mash preserves keys which cannot be converted *directly* to both a string and a symbol, such as numeric keys. Since Mash is conceived to provide pseudo-object functionality, handling keys which cannot represent a method call falls outside its scope of value.
+
+```ruby
+Hashie::Mash.new('1' => 'one string', :'1' => 'one sym', 1 => 'one num')
+# => {"1"=>"one sym", 1=>"one num"}
+```
+
+The symbol key `:'1'` is converted the string `'1'` to support indifferent access and consequently its value `'one sym'` will override the previously set `'one string'`. However, the subsequent key of `1` cannot directly convert to a symbol and therefore **not** converted to the string `'1'` that would otherwise override the previously set value of `'one sym'`.
 
-#### Example:
+_What else can Mash do?_
+
+Mash allows you also to transform any files into a Mash objects.
 
 ```yml
 #/etc/config/settings/twitter.yml
@@ -639,9 +692,9 @@ Specify `permitted_symbols`, `permitted_classes` and `aliases` options as needed
 Mash.load('data/user.csv', permitted_classes: [Symbol], permitted_symbols: [], aliases: false)
 ```
 
-### Mash Extension: KeepOriginalKeys
+### KeepOriginalKeys
 
-This extension can be mixed into a Mash to keep the form of any keys passed directly into the Mash. By default, Mash converts keys to strings to give indifferent access. This extension still allows indifferent access, but keeps the form of the keys to eliminate confusion when you're not expecting the keys to change.
+This extension can be mixed into a Mash to keep the form of any keys passed directly into the Mash. By default, Mash converts symbol keys to strings to give indifferent access. This extension still allows indifferent access, but keeps the form of the keys to eliminate confusion when you're not expecting the keys to change.
 
 ```ruby
 class KeepingMash < ::Hashie::Mash
@@ -658,7 +711,7 @@ mash['string_key']  #=> 'string'
 mash[:string_key]  #=> 'string'
 ```
 
-### Mash Extension: PermissiveRespondTo
+### PermissiveRespondTo
 
 By default, Mash only states that it responds to built-in methods, affixed methods (e.g. setters, underbangs, etc.), and keys that it currently contains. That means it won't state that it responds to a getter for an unset key, as in the following example:
 
@@ -682,12 +735,10 @@ mash.respond_to? :b  #=> true
 
 This comes at the cost of approximately 20% performance for initialization and setters and 19KB of permanent memory growth for each such class that you create.
 
-### Mash Extension: SafeAssignment
+### 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
@@ -698,9 +749,9 @@ safe_mash.zip   = 'Test' # => ArgumentError
 safe_mash[:zip] = 'test' # => still ArgumentError
 ```
 
-### Mash Extension: SymbolizeKeys
+### SymbolizeKeys
 
-This extension can be mixed into a Mash to change the default behavior of converting keys to strings. After mixing this extension into a Mash, the Mash will convert all keys to symbols. It can be useful to use with keywords argument, which required symbol keys.
+This extension can be mixed into a Mash to change the default behavior of converting keys to strings. After mixing this extension into a Mash, the Mash will convert all string keys to symbols. It can be useful to use with keywords argument, which required symbol keys.
 
 ```ruby
 class SymbolizedMash < ::Hashie::Mash
@@ -731,7 +782,7 @@ end
 
 However, on Rubies less than 2.0, this means that every key you send to the Mash will generate a symbol. Since symbols are not garbage-collected on older versions of Ruby, this can cause a slow memory leak when using a symbolized Mash with data generated from user input.
 
-### Mash Extension: DefineAccessors
+### DefineAccessors
 
 This extension can be mixed into a Mash so it makes it behave like `OpenStruct`. It reduces the overhead of `method_missing?` magic by lazily defining field accessors when they're requested.
 
@@ -758,12 +809,10 @@ mash = ::Hashie::Mash.new.with_accessors!
 
 ## 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.
+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. A property with a proc value will be evaluated lazily upon retrieval.
 
 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
@@ -772,6 +821,7 @@ class Person < Hashie::Dash
   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'
+  property :genome
 
   def weekday?
     [ Time.now.saturday?, Time.now.sunday? ].none?
@@ -796,12 +846,12 @@ p.occupation   # => 'Evil'
 p.name         # => 'Trudy'
 p.update_attributes!(occupation: nil)
 p.occupation   # => 'Rubyist'
+p.genome = -> { Genome.sequence } # Some expensive operation
+p.genome       # => 'GATTACA'
 ```
 
 Properties defined as symbols are not the same thing as properties defined as strings.
 
-### Example:
-
 ```ruby
 class Tricky < Hashie::Dash
   property :trick
@@ -825,7 +875,28 @@ p = Tricky.new('trick' => 'two')
 p.trick # => NoMethodError
 ```
 
-### Potential gotchas
+If you would like to update a Dash and use any default values set in the case of a `nil` value, use `#update_attributes!`.
+
+```ruby
+class WithDefaults < Hashie::Dash
+  property :description, default: 'none'
+end
+
+dash = WithDefaults.new
+dash.description  #=> 'none'
+
+dash.description = 'You committed one of the classic blunders!'
+dash.description  #=> 'You committed one of the classic blunders!'
+
+dash.description = nil
+dash.description  #=> nil
+
+dash.description = 'Only slightly less known is ...'
+dash.update_attributes!(description: nil)
+dash.description  #=> 'none'
+```
+
+### Potential Gotchas
 
 Because Dashes are subclasses of the built-in Ruby Hash class, the double-splat operator takes the Dash as-is without any conversion. This can lead to strange behavior when you use the double-splat operator on a Dash as the first part of a keyword list or built Hash. For example:
 
@@ -857,13 +928,11 @@ qux.is_a?(Hash)                #=> true
 qux[:quux]                     #=> "corge"
 ```
 
-### Dash Extension: PropertyTranslation
+### PropertyTranslation
 
 The `Hashie::Extensions::Dash::PropertyTranslation` mixin extends a Dash with
 the ability to remap keys from a source hash.
 
-### Example from inconsistent APIs
-
 Property translation is useful when you need to read data from another
 application -- such as a Java API -- where the keys are named differently from
 Ruby conventions.
@@ -883,8 +952,6 @@ person[:first_name]  #=> 'Michael'
 person[:last_name]   #=> 'Bleigh
 ```
 
-### Example using translation lambdas
-
 You can also use a lambda to translate the value. This is particularly useful
 when you want to ensure the type of data you're wrapping.
 
@@ -905,7 +972,7 @@ model.created_at.class  #=> Time
 
 To enable compatibility with Rails 4 use the [hashie-forbidden_attributes](https://github.com/Maxim-Filimonov/hashie-forbidden_attributes) gem.
 
-### Dash Extension: Coercion.
+### Coercion
 
 If you want to use `Hashie::Extensions::Coercion` together with `Dash` then
 you may probably want to use `Hashie::Extensions::Dash::Coercion` instead.
@@ -935,6 +1002,20 @@ class UserHash < Hashie::Dash
 end
 ```
 
+### PredefinedValues
+
+The `Hashie::Extensions::Dash::PredefinedValues` mixin extends a Dash with
+the ability to accept predefined values on a property.
+
+```ruby
+class UserHash < Hashie::Dash
+  include Hashie::Extensions::Dash::PredefinedValues
+
+  property :gender, values: %i[male female prefer_not_to_say]
+  property :age, values: (0..150)
+end
+```
+
 ## Trash
 
 A Trash is a Dash that allows you to translate keys on initialization. It mixes
@@ -976,8 +1057,6 @@ Clash is a Chainable Lazy Hash that allows you to easily construct complex hashe
 
 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)
@@ -1003,8 +1082,6 @@ A good use case for the Rash is an URL router for a web framework, where URLs ne
 
 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
@@ -1021,18 +1098,21 @@ mapper["I like traffic lights"] # => "Who DOESN'T like traffic lights?!"
 mapper["Get off my lawn!"]      # => "Forget your lawn, old man!"
 ```
 
-### Auto-optimized
+### 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`.
 
+## Mascot
+[![eierlegende Wollmilchsau](./mascot.svg)](https://en.wiktionary.org/wiki/eierlegende_Wollmilchsau) Meet Hashie's "official" mascot, the [eierlegende Wollmilchsau](https://en.wiktionary.org/wiki/eierlegende_Wollmilchsau)!
+
 ## Contributing
 
 See [CONTRIBUTING.md](CONTRIBUTING.md)
 
 ## Copyright
 
-Copyright (c) 2009-2014 Intridea, Inc. (http://intridea.com/) and [contributors](https://github.com/hashie/hashie/graphs/contributors).
+Copyright (c) 2009-2020 [Intridea, Inc.](http://intridea.com), and [contributors](https://github.com/hashie/hashie/graphs/contributors).
 
 MIT License. See [LICENSE](LICENSE) for details.

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rubygems'
 require 'bundler'
 Bundler.setup
@@ -16,6 +18,7 @@ RuboCop::RakeTask.new(:rubocop)
 require_relative 'spec/support/integration_specs'
 task :integration_specs do
   next if ENV['CI']
+
   status_codes = []
   handler = lambda do |status_code|
     status_codes << status_code unless status_code.zero?

data/UPGRADING.md

@@ -1,6 +1,44 @@
 Upgrading Hashie
 ================
 
+### Upgrading to 5.0.0
+
+#### Mash initialization key conversion
+
+Mash initialization now only converts to string keys which can be represented as symbols.
+
+```ruby
+Hashie::Mash.new(
+  {foo: "bar"} => "baz",
+  "1" => "one string",
+  :"1" => "one sym",
+  1 => "one num"
+)
+
+# Before
+{"{:foo=>\"bar\"}"=>"baz", "1"=>"one num"}
+
+# After
+{{:foo=>"bar"}=>"baz", "1"=>"one sym", 1=>"one num"}
+```
+
+#### Mash#dig with numeric keys
+
+`Hashie::Mash#dig` no longer considers numeric keys for indifferent access.
+
+```ruby
+my_mash = Hashie::Mash.new("1" => "a") # => {"1"=>"a"}
+
+my_mash.dig("1") # => "a"
+my_mash.dig(:"1") # => "a"
+
+# Before
+my_mash.dig(1) # => "a"
+
+# After
+my_mash.dig(1) # => nil
+```
+
 ### Upgrading to 4.0.0
 
 #### Non-destructive Hash methods called on Mash

data/hashie.gemspec

@@ -24,5 +24,9 @@ Gem::Specification.new do |gem|
     }
   end
 
+  gem.required_ruby_version = '>= 2.7'
+
+  gem.add_dependency 'logger' # for Ruby >= 3.4
+
   gem.add_development_dependency 'bundler'
 end

data/lib/hashie/dash.rb

@@ -10,7 +10,7 @@ module Hashie
   # lightweight data object that needs even fewer options and
   # resources than something like a DataMapper resource.
   #
-  # It is preferrable to a Struct because of the in-class
+  # It is preferable to a Struct because of the in-class
   # API for defining properties as well as per-property defaults.
   class Dash < Hash
     include Hashie::Extensions::PrettyInspect
@@ -104,19 +104,6 @@ module Hashie
     def initialize(attributes = {}, &block)
       super(&block)
 
-      self.class.defaults.each_pair do |prop, value|
-        self[prop] = begin
-          val = value.dup
-          if val.is_a?(Proc)
-            val.arity == 1 ? val.call(self) : val.call
-          else
-            val
-          end
-        rescue TypeError
-          value
-        end
-      end
-
       initialize_attributes(attributes)
       assert_required_attributes_set!
     end
@@ -169,17 +156,30 @@ module Hashie
       self
     end
 
+    def to_h
+      defaults = ::Hash[self.class.properties.map { |prop| [prop, self.class.defaults[prop]] }]
+
+      defaults.merge(self)
+    end
+    alias to_hash to_h
+
     def update_attributes!(attributes)
       update_attributes(attributes)
 
       self.class.defaults.each_pair do |prop, value|
-        next unless self[prop].nil?
+        next unless fetch(prop, nil).nil?
         self[prop] = begin
-          value.dup
+          val = value.dup
+          if val.is_a?(Proc)
+            val.arity == 1 ? val.call(self) : val.call
+          else
+            val
+          end
         rescue TypeError
           value
         end
       end
+
       assert_required_attributes_set!
     end
 
@@ -189,7 +189,7 @@ module Hashie
       return unless attributes
 
       cleaned_attributes = attributes.reject { |_attr, value| value.nil? }
-      update_attributes(cleaned_attributes)
+      update_attributes!(cleaned_attributes)
     end
 
     def update_attributes(attributes)

data/lib/hashie/extensions/coercion.rb

@@ -17,14 +17,7 @@ module Hashie
       }.freeze
 
       ABSTRACT_CORE_TYPES =
-        if RubyVersion.new(RUBY_VERSION) >= RubyVersion.new('2.4.0')
-          { Numeric => [Integer, Float, Complex, Rational] }
-        else
-          {
-            Integer => [Fixnum, Bignum],
-            Numeric => [Fixnum, Bignum, Float, Complex, Rational]
-          }
-        end
+        { Numeric => [Integer, Float, Complex, Rational] }
 
       def self.included(base)
         base.send :include, InstanceMethods

data/lib/hashie/extensions/dash/indifferent_access.rb

@@ -19,6 +19,15 @@ module Hashie
         end
         private_class_method :requires_class_methods?
 
+        def to_h
+          defaults = ::Hash[self.class.properties.map do |prop|
+            [Hashie::Extensions::IndifferentAccess.convert_key(prop), self.class.defaults[prop]]
+          end]
+
+          defaults.merge(self)
+        end
+        alias to_hash to_h
+
         module ClassMethods
           # Check to see if the specified property has already been
           # defined.

data/lib/hashie/extensions/dash/predefined_values.rb

@@ -0,0 +1,88 @@
+module Hashie
+  module Extensions
+    module Dash
+      # Extends a Dash with the ability to accept only predefined values on a property.
+      #
+      # == Example
+      #
+      #   class PersonHash < Hashie::Dash
+      #     include Hashie::Extensions::Dash::PredefinedValues
+      #
+      #     property :gender, values: [:male, :female, :prefer_not_to_say]
+      #     property :age, values: (0..150) # a Range
+      #   end
+      #
+      #   person = PersonHash.new(gender: :male, age: -1)
+      #   # => ArgumentError: The value '-1' is not accepted for property 'age'
+      module PredefinedValues
+        def self.included(base)
+          base.instance_variable_set(:@values_for_properties, {})
+          base.extend(ClassMethods)
+          base.include(InstanceMethods)
+        end
+
+        module ClassMethods
+          attr_reader :values_for_properties
+
+          def inherited(klass)
+            super
+            klass.instance_variable_set(:@values_for_properties, values_for_properties.dup)
+          end
+
+          def property(property_name, options = {})
+            super
+
+            return unless (predefined_values = options[:values])
+
+            assert_predefined_values!(predefined_values)
+            set_predefined_values(property_name, predefined_values)
+          end
+
+          private
+
+          def assert_predefined_values!(predefined_values)
+            return if supported_type?(predefined_values)
+
+            raise ArgumentError, %(`values` accepts an Array or a Range.)
+          end
+
+          def supported_type?(predefined_values)
+            [::Array, ::Range].any? { |klass| predefined_values.is_a?(klass) }
+          end
+
+          def set_predefined_values(property_name, predefined_values)
+            @values_for_properties[property_name] = predefined_values
+          end
+        end
+
+        module InstanceMethods
+          def initialize(*)
+            super
+
+            assert_property_values!
+          end
+
+          private
+
+          def assert_property_values!
+            self.class.values_for_properties.each_key do |property|
+              value = send(property)
+
+              if value && !values_for_properties(property).include?(value)
+                fail_property_value_error!(property)
+              end
+            end
+          end
+
+          def fail_property_value_error!(property)
+            raise ArgumentError, "Invalid value for property '#{property}'"
+          end
+
+          def values_for_properties(property)
+            self.class.values_for_properties[property]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hashie/extensions/dash/property_translation.rb

@@ -153,7 +153,12 @@ module Hashie
           def []=(property, value)
             if self.class.translation_exists? property
               send("#{property}=", value)
-              super(property, value) if self.class.properties.include?(property)
+
+              if self.class.transformation_exists? property
+                super property, self.class.transformed_property(property, value)
+              elsif self.class.properties.include?(property)
+                super(property, value)
+              end
             elsif self.class.transformation_exists? property
               super property, self.class.transformed_property(property, value)
             elsif property_exists? property

data/lib/hashie/extensions/deep_locate.rb

@@ -1,7 +1,7 @@
 module Hashie
   module Extensions
     module DeepLocate
-      # The module level implementation of #deep_locate, incase you do not want
+      # The module level implementation of #deep_locate, in case you do not want
       # to include/extend the base datastructure. For further examples please
       # see #deep_locate.
       #