hashie 5.2.0 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1623620401412d6612e1b7a1d2963cd9b31d584c3278987fafe45eac8cdd025b
-  data.tar.gz: f3bb1e89d55110e20bed0b5c76e6e9e817c1e99ad0fed2e7ee7c89cc948baaf8
+  metadata.gz: 0fa02edecdffba1e181cfe0e80f6aa55db45f1b6b1cd0fc866b3bbc4ef6abd16
+  data.tar.gz: 02fefdce2dce50542155afa916e664f2f06b0d31bdc322fcde3ef70b33260c00
 SHA512:
-  metadata.gz: dea36ed10af73ca738634902bf043db652baa251b43066fcb9e309f28c501ac60ea843ef66944fd1b5a5801f37bac385bb2e165daeef9e62498f527387502e2e
-  data.tar.gz: 1131b72244560c35aaff3c6b3fcc28da13caa67c74b7c6f3dc6628c0cbe0ee74ae85429165d04988d1466ff045ee9198505c48192833ca249260cea3f2310dc8
+  metadata.gz: 1b09dff1ca0ecfb032087c56bd3e5472de999f81cd35cdbd8fdcd934aba6a518073ea58d29ccd32d1d4df52a790fada8769ee1ceaa30ee79e26bb49fa4256e7e
+  data.tar.gz: 21ea16dfaa5755d4f193d0b6159848aa299bbccdaf42bd068630aa1d565ea2f6fb9c8c7f26b49e6aeadc090f1faf05be1988da8e90f55156129be21b616e689f

data/CHANGELOG.md

@@ -6,6 +6,25 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 Any violations of this scheme are considered to be bugs.
 
+## [6.0.0] - 2026-11-11
+
+[Unreleased]: https://github.com/hashie/hashie/compare/v6.0.0...master
+[6.0.0]: https://github.com/hashie/hashie/compare/v5.2.0...v6.0.0
+
+### Added
+
+* [#648](https://github.com/hashie/hashie/pull/648): Added manually dispatched releases with `ruby-gem-release` and RubyGems Trusted Publishing - [@dblock](https://github.com/dblock).
+
+### Changed
+
+* [#649](https://github.com/hashie/hashie/pull/649): Updated Danger workflows to `danger/danger-pr-comment` v0.2.0 following its move to the Danger organization - [@dblock](https://github.com/dblock).
+* [#641](https://github.com/hashie/hashie/pull/641): **Breaking:** Changed `DeepFind#deep_find_all` and `deep_select` to return an empty array instead of `nil` when no matches exist, reviving [#548](https://github.com/hashie/hashie/pull/548) - [@punkisdead](https://github.com/punkisdead), [@dblock](https://github.com/dblock).
+* [#639](https://github.com/hashie/hashie/pull/639): **Breaking:** Standardized internal helpers on one leading underscore and prevented Dash/Trash properties and generated Mash accessors from replacing existing methods. Conflicting Dash/Trash properties now require bracket access - [@dblock](https://github.com/dblock).
+* [#637](https://github.com/hashie/hashie/pull/637): **Breaking:** Changed Mash to preserve nested custom Hash subclasses by identity instead of converting or duplicating them; custom values replace existing nested Mashes during merge. Plain Hash conversion and Mash copying remain unchanged, following [#390](https://github.com/hashie/hashie/issues/390), reported by [@schnittchen](https://github.com/schnittchen) - [@dblock](https://github.com/dblock).
+* [#633](https://github.com/hashie/hashie/pull/633): **Breaking:** Changed `DeepMerge` to recursively copy hashes, arrays, and strings while retaining other objects by identity on both sides, following [#572](https://github.com/hashie/hashie/issues/572) - [@apotonick](https://github.com/apotonick), [@michaelherold](https://github.com/michaelherold), [@dblock](https://github.com/dblock).
+* [#632](https://github.com/hashie/hashie/pull/632): **Breaking:** Changed `DeepMerge` to preserve incoming nested hash subclasses, defaults, and instance state directly with `dup.clear`, following [#619](https://github.com/hashie/hashie/pull/619), [#586](https://github.com/hashie/hashie/pull/586), and [#585](https://github.com/hashie/hashie/issues/585) - [@addam128](https://github.com/addam128), [@dblock](https://github.com/dblock).
+* [#631](https://github.com/hashie/hashie/pull/631): **Breaking:** Changed `Mash.load` to use `YamlParser` by default; ERB evaluation now requires explicit `YamlErbParser` selection, following [#575](https://github.com/hashie/hashie/issues/575) and [#625](https://github.com/hashie/hashie/pull/625) - [@bo-tato](https://github.com/bo-tato), [@dblock](https://github.com/dblock).
+
 ## [5.2.0] - 2026-10-23
 
 [5.2.0]: https://github.com/hashie/hashie/compare/v5.1.0...v5.2.0

data/CONTRIBUTING.md

@@ -57,6 +57,8 @@ RuboCop scans Ruby sources, specs, benchmarks, gem manifests, and Ruby scripts a
 
 On MRI Ruby 3.2 or newer, RuboCop also checks spelling in Ruby comments and strings and documentation with `rubocop-spellcheck`. The plugin's native dependencies are not installed on JRuby. Fix typos in the source and add intentional project terms to `.spellcheck.txt`, one word per line. Run only the spelling check with `bundle exec rubocop --only Spellcheck/Spelling`. If regenerating vocabulary with `--auto-gen-config`, review the word list so genuine typos are not accepted and preserve the existing `.rubocop_todo.yml` baseline.
 
+Name private and protected implementation helpers with one leading underscore. Keep Ruby callbacks and documented extension hooks under their required names. Double-underscore aliases such as `__size` in `MethodAccessWithOverride` are a public feature for accessing overridden methods, not an internal-helper convention. Generated accessors must not replace existing methods, including private and protected helpers.
+
 Make sure that `bundle exec rake` completes without errors.
 
 #### Write Documentation

data/README.md

@@ -82,7 +82,7 @@ gem install hashie
 
 ## Stable Release
 
-You're reading the documentation for the stable release of Hashie, 5.2.0.
+You're reading the documentation for the stable release of Hashie, 6.0.0.
 
 ## Hash Extensions
 
@@ -535,7 +535,7 @@ Configuration.load('config.yaml').name # => 'updated'
 
 Files contain plain YAML data, not Ruby class tags or persistence metadata. Loading uses `Psych.safe_load`, permits symbols for declared Dash/Trash properties, rejects aliases and non-hash roots, and never evaluates ERB. String and symbol keys retain their types; Dash/Trash files must use keys accepted by their constructors. Nested Hashie classes are not encoded: constructors such as Mash may reconstruct their own nested types, while Dash retains nested plain hashes. Supported values are hashes, arrays, strings, symbols, numbers, booleans, and `nil`; cycles and unsupported objects are rejected.
 
-Including this extension explicitly replaces an inherited class-level `load` on that subclass. Ordinary `Hashie::Mash.load` retains its existing caching and YAML/ERB behavior. No autosave or other serialization formats are provided.
+Including this extension explicitly replaces an inherited class-level `load` on that subclass. Ordinary `Hashie::Mash.load` uses cached YAML loading, with ERB evaluation available only through an explicit parser selection. No autosave or other serialization formats are provided.
 
 ### MethodAccessWithOverride
 
@@ -676,6 +676,12 @@ h2 = MyHash[{ b: 250, c: { c1: 200 } }]
 h1.deep_merge(h2) { |key, this_val, other_val| this_val + other_val } # => { a: 100, b: 450, c: { c1: 300 } }
 ```
 
+New nested hashes preserve incoming hash subclasses using `source.dup.clear`. This retains their instance state and hash defaults without requiring a zero-argument constructor. Existing destination hashes retain their own types. Both `deep_merge` and `deep_merge!` apply this policy at every incoming nested-hash level, including hashes inside replacement arrays; neither clears the source. Custom subclasses must support duplication, clearing, and assignment into the copied hash.
+
+`deep_merge` recursively copies hash and array values and duplicates strings on both sides. Other values retain their identity: it never calls `dup` or `deep_dup` on arbitrary leaf objects, such as ActiveRecord models. Arrays replace rather than merge existing values, but their elements are copied recursively. Hash keys retain the usual Ruby Hash semantics. Inputs must be acyclic; shared references are not preserved between independently copied containers.
+
+`deep_merge!` preserves existing receiver values unless replaced or recursively merged, and applies the same copying policy to incoming values. Conflict blocks receive the original incoming value and, for `deep_merge`, the copied receiver value; their return values are stored unchanged. Mutable leaf objects other than strings remain shared, so this is not a fully independent object-graph clone.
+
 ### 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.
@@ -731,6 +737,10 @@ 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']
+
+user.deep_find(:missing)     #=> nil
+user.deep_find_all(:missing) #=> []
+user.deep_select(:missing)   #=> []
 ```
 
 ### DeepGrep
@@ -820,7 +830,22 @@ end
 
 ## Mash
 
-Mash adds method-style access to Hash keys and recursively wraps nested hashes:
+Mash adds method-style access to Hash keys and recursively wraps nested plain hashes.
+
+Custom Hash subclasses other than Mash are stored unchanged, including when nested in arrays or ordinary hashes. Their methods, defaults, key types, and identity are preserved, and their contents are not recursively converted. Mash values retain their existing Mash-specific copying behavior. To explicitly normalize a custom Hash into nested Mashes, pass it as the root argument to `Hashie::Mash.new(custom_hash)`.
+
+```ruby
+class CustomHash < Hash
+end
+
+custom = CustomHash[name: 'Ada']
+mash = Hashie::Mash.new(custom: custom, plain: { name: 'Grace' })
+mash.custom.equal?(custom) # => true
+mash.custom[:name] # => 'Ada'
+mash.plain.name # => 'Grace'
+```
+
+Merging a custom Hash value replaces an existing nested Mash rather than recursively merging it. Custom Hash values remain shared when copying a Mash with `dup` or `merge`; mutations to those values are visible through every reference.
 
 ```ruby
 mash = Hashie::Mash.new
@@ -971,7 +996,7 @@ Use `Mash.load` to read a YAML configuration file:
 development:
   api_key: 'api_key'
 production:
-  api_key: <%= ENV.fetch('HASHIE_README_API_KEY') %> # set to 'abcd' below
+  api_key: 'abcd'
 ```
 
 <!-- hashie:example mash-load -->
@@ -984,9 +1009,8 @@ File.write('settings/twitter.yml', <<~YAML)
   development:
     api_key: 'api_key'
   production:
-    api_key: <%= ENV.fetch('HASHIE_README_API_KEY') %>
+    api_key: 'abcd'
 YAML
-ENV['HASHIE_README_API_KEY'] = 'abcd'
 
 mash = Hashie::Mash.load('settings/twitter.yml')
 mash.development.api_key # => 'api_key'
@@ -1010,14 +1034,24 @@ mash.development.api_key # => 'api_key'
 
 The loaded root is frozen, but nested Mashes remain mutable. Repeated loads with the same path object return the cached Mash.
 
-By default, `Mash.load` evaluates ERB before parsing YAML. Only use it with trusted files; `YAML.safe_load` does not make ERB evaluation safe. To parse untrusted or plain YAML without evaluating ERB, explicitly select `YamlParser`:
+By default, `Mash.load` uses [YamlParser](lib/hashie/extensions/parsers/yaml_parser.rb), which parses YAML without evaluating ERB. Embedded ERB remains literal text when valid YAML, or produces a YAML parsing error when it is not valid YAML:
 
 ```ruby
 File.write('data.yml', "api_key: <%= not_evaluated %>\n")
-mash = Hashie::Mash.load('data.yml', parser: Hashie::Extensions::Parsers::YamlParser)
+mash = Hashie::Mash.load('data.yml')
 mash.api_key # => '<%= not_evaluated %>'
 ```
 
+If trusted configuration files need ERB interpolation, explicitly select `YamlErbParser`:
+
+```ruby
+File.write('trusted-settings.yml', "api_key: <%= 'abcd' %>\n")
+mash = Hashie::Mash.load('trusted-settings.yml', parser: Hashie::Extensions::Parsers::YamlErbParser)
+mash.api_key # => 'abcd'
+```
+
+`YamlErbParser` executes Ruby code; `YAML.safe_load` does not make ERB evaluation safe. Only use it with trusted files. Loaded results remain cached by path, not parser or options; use separate Mash subclasses when the same path needs different loading policies.
+
 You can access a Mash from another class:
 
 <!-- hashie:example mash-load -->
@@ -1028,10 +1062,9 @@ end
 mash = Hashie::Mash.load('settings/twitter.yml')['production']
 Twitter.extend mash.to_module # NOTE: if you want another name than settings, call: to_module('my_settings')
 Twitter.settings.api_key # => 'abcd'
-ENV.delete('HASHIE_README_API_KEY')
 ```
 
-You can use another parser (by default: [YamlErbParser](lib/hashie/extensions/parsers/yaml_erb_parser.rb), which evaluates ERB):
+You can use another parser instead of the default `YamlParser`:
 
 ```text
 # data/user.csv
@@ -1402,6 +1435,23 @@ dash.update_attributes!(description: nil)
 dash.description  #=> 'none'
 ```
 
+Dash and Trash do not replace existing public, protected, or private methods with property accessors. Conflicting names remain available through brackets, including required-property validation and translations:
+
+```ruby
+class TypedParameter < Hashie::Trash
+  property :class, from: :type, required: true
+  property :count, default: 0
+end
+
+parameter = TypedParameter.new(type: 'query')
+parameter[:class] # => 'query'
+parameter.class # => TypedParameter
+parameter[:count] # => 0
+parameter.count # => 2 (Hash entry count, not the property value)
+```
+
+This also preserves custom readers and writers defined before the property declaration. A translated input key that conflicts with an existing writer uses bracket assignment instead, such as `parameter[:default] = value`; the existing writer retains its original behavior.
+
 The names `required` and `required?` can themselves be used as properties, for example when modeling a Swagger parameter. Their values are independent of Dash's `required: true` declaration option; `false` is a valid non-nil value even for a required property.
 
 ```ruby

data/Rakefile

@@ -6,6 +6,21 @@ Bundler.setup
 
 Bundler::GemHelper.install_tasks
 
+if RUBY_ENGINE == 'ruby' && Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3.3')
+  require_relative 'script/release_preparation'
+  require 'ruby-gem-release/workflow/ruby_gem'
+
+  workflow = RubyGemRelease::Workflow::RubyGem.new(
+    version: RubyGemRelease::Version::RubyConstant.new(path: 'lib/hashie/version.rb', constant: 'VERSION'),
+    changelog: RubyGemRelease::Changelog::KeepAChangelog.new
+  )
+  preparation = HashieReleasePreparation.new
+  workflow.before(:validate) { |ctx| preparation.validate!(ctx.release, changelog: ctx.workflow.changelog) }
+  workflow.before(:prepare_release) { |ctx| preparation.prepare!(ctx.release, changelog: ctx.workflow.changelog) }
+  workflow.after(:prepare_next) { |ctx| preparation.prepare_next!(ctx.release) }
+  workflow.install_tasks
+end
+
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new do |spec|
   spec.pattern = 'spec/**/*_spec.rb'

data/UPGRADING.md

@@ -1,24 +1,92 @@
 Upgrading Hashie
 ================
 
+### Upgrading to 6.0.0
+
+#### YAML loading no longer evaluates ERB by default
+
+`Hashie::Mash.load` now defaults to `Hashie::Extensions::Parsers::YamlParser`, introduced in #625, rather than `YamlErbParser`. This is a breaking change for configuration files containing ERB: template expressions are no longer evaluated and may remain literal strings or cause YAML parsing errors.
+
+For trusted files that require ERB interpolation, explicitly select the previous parser:
+
+```ruby
+Hashie::Mash.load('trusted-settings.yml', parser: Hashie::Extensions::Parsers::YamlErbParser)
+```
+
+Do not use `YamlErbParser` with untrusted input: it executes Ruby before parsing YAML. Both parsers still use `YAML.safe_load`, and `permitted_classes`, `permitted_symbols`, and `aliases` retain their existing meanings. Custom parsers, frozen results, and path-based caching are unchanged. Because cached results are keyed only by path, use separate Mash subclasses if the same file needs different parser policies.
+
+See [#631](https://github.com/hashie/hashie/pull/631) for more information.
+
+#### DeepMerge preserves incoming hash subclasses
+
+`Hashie::Extensions::DeepMerge` now preserves the class, instance state, and defaults of incoming nested hashes by default. New destinations use `source.dup.clear` instead of `{}`, so required constructor arguments and required-property Dashes do not require an empty constructor. Existing destination hashes keep their own types; source hashes are never cleared.
+
+This is a breaking change for code relying on incoming subclasses becoming plain hashes. Preserved subclasses may enforce custom assignment rules or expose different lookup behavior. Applications requiring plain nested hashes must explicitly normalize their input hash values before merging.
+
+The policy applies at every incoming nested-hash level for both `deep_merge` and `deep_merge!`, including hashes inside arrays. Custom hashes must support duplication, clearing, and assignment into the copied hash.
+
+See [#632](https://github.com/hashie/hashie/pull/632) for more information.
+
+#### DeepMerge value copying
+
+`Hashie::Extensions::DeepMerge` now recursively copies hashes, arrays, and strings on both sides, but retains other values by identity. It no longer calls `Hashie::Utils.safe_dup` on receiver leaves or `deep_dup` on incoming leaves. ActiveRecord models therefore retain their identity, primary keys, and persistence state without a custom policy.
+
+This is a breaking change: arbitrary receiver objects are now shared, incoming strings are now copied even without ActiveSupport, and receiver arrays are copied recursively rather than shallowly. Arrays still replace conflicting values rather than merging element by element. Incoming hashes inside arrays preserve their subclasses, and existing receiver container subclasses retain their types.
+
+If your application needs independent copies of domain objects, explicitly copy them according to their own APIs before merging. Do not assume `deep_merge` clones an entire object graph. `deep_merge!` keeps existing receiver values in place, and conflict-block results are still stored unchanged. Cyclic inputs are not supported.
+
+See [#633](https://github.com/hashie/hashie/pull/633) for more information.
+
+#### Mash preserves custom Hash values
+
+Nested Hash subclasses other than Mash are now stored by identity instead of being converted into Mashes or copied. This applies to initialization, assignment, arrays, copying, replacement, and merges. Plain Hash values are still recursively converted, and existing Mash-specific copying behavior is unchanged.
+
+Code relying on `mash.custom.some_key` for a custom Hash value must use that object's own API, such as `mash.custom[:some_key]`, or explicitly convert it with `Hashie::Mash.new(custom_hash)` before insertion. A custom Hash replaces an existing nested Mash during merge rather than recursively merging into it. Because custom values are shared, `dup` and `merge` no longer isolate mutations to them; explicitly copy such values when needed.
+
+See [#637](https://github.com/hashie/hashie/pull/637) for more information.
+
+#### Dash and Trash accessor collisions
+
+Property declarations no longer replace existing methods, regardless of visibility. Read and write conflicting properties with brackets: use `dash[:class]` instead of `dash.class`, and `dash[:count]` instead of `dash.count`. The latter methods retain their normal Ruby/Hash behavior. The same rule applies to translated source writers; use `trash[:source] = value` if `source=` already exists. Existing custom accessors are preserved; required and predefined-value validation now reads stored property values through brackets rather than invoking those accessors.
+
+See [#639](https://github.com/hashie/hashie/pull/639) for more information.
+
+#### Internal helper names
+
+Private and protected implementation helpers consistently use one leading underscore, including `_translations` (formerly `__translations`) and `_convert` (formerly `__convert`). Subclasses overriding renamed helpers must update those overrides and calls. Ruby callbacks, documented extension hooks such as `initialize_attributes`, `convert_key`, and `convert_value`, and public methods keep their existing names. The documented `__method` aliases created by `MethodAccessWithOverride` also remain unchanged; those expose overridden methods rather than internal helpers.
+
+Recursive key-conversion helpers, `Hashie::Utils`' integer-class helper, and Clash's merge-storage helper are now private and use underscore-prefixed names. Mash suffix parsing, method-redefinition helpers, and indifferent-hash detection are also private rather than protected. Use the public conversion, builder, and accessor APIs instead of calling these helpers directly.
+
+See [#639](https://github.com/hashie/hashie/pull/639) for more information.
+
+#### DeepFind results
+
+`deep_find_all` and its alias `deep_select` now return `[]` instead of `nil` when no matches exist, matching `Enumerable#find_all`. Replace no-match checks such as `result.nil?` or `if result` with `result.empty?` or `result.any?`. Fallbacks such as `deep_find_all(:key) || []` are no longer necessary. `deep_find` and `deep_detect` still return `nil` when no match exists; matching values, including `nil`, remain in the results array.
+
+See [#641](https://github.com/hashie/hashie/pull/641) for more information.
+
 ### Upgrading to 5.2.0
 
 #### Safer YAML loading
 
 `Hashie::Mash.load` continues to use `YamlErbParser` by default for compatibility, and that parser evaluates ERB. Do not load untrusted input with the default parser. To opt in to YAML parsing without ERB evaluation, pass `parser: Hashie::Extensions::Parsers::YamlParser`.
 
+See [#625](https://github.com/hashie/hashie/pull/625) for more information.
+
 #### Ruby version
 
 Hashie now requires Ruby 3.0 or newer. Ruby 2.7 is no longer supported; upgrade Ruby before updating Hashie.
 
+See [#622](https://github.com/hashie/hashie/pull/622) for more information.
+
 #### Exception messages
 
-Exception messages now begin with lowercase words, omit trailing periods, quote interpolated values
-with backticks, and use consistent wording. Exception classes and the conditions under which
-exceptions are raised have not changed.
+Exception messages now begin with lowercase words, omit trailing periods, quote interpolated values with backticks, and use consistent wording. Exception classes and the conditions under which exceptions are raised have not changed.
 
 Applications and tests that compare exact exception message strings must update their expectations.
 
+See [#607](https://github.com/hashie/hashie/pull/607) for more information.
+
 ### Upgrading to 5.0.0
 
 #### Mash initialization key conversion
@@ -40,6 +108,8 @@ Hashie::Mash.new(
 {{:foo=>"bar"}=>"baz", "1"=>"one sym", 1=>"one num"}
 ```
 
+See [#521](https://github.com/hashie/hashie/pull/521) for more information.
+
 #### Mash#dig with numeric keys
 
 `Hashie::Mash#dig` no longer considers numeric keys for indifferent access.
@@ -57,6 +127,8 @@ my_mash.dig(1) # => "a"
 my_mash.dig(1) # => nil
 ```
 
+See [#521](https://github.com/hashie/hashie/pull/521) for more information.
+
 ### Upgrading to 4.0.0
 
 #### Non-destructive Hash methods called on Mash
@@ -92,14 +164,20 @@ p cool_parents
 
 This may make places where you had to re-make the Mash redundant, and may cause unintended side effects if your application was expecting a plain old ruby Hash.
 
+See [#481](https://github.com/hashie/hashie/pull/481) for more information.
+
 #### Ruby 2.6: Mash#merge and Mash#merge!
 
 In Ruby > 2.6.0, Hashie now supports passing multiple hash and Mash objects to Mash#merge and Mash#merge!.
 
+See [#481](https://github.com/hashie/hashie/pull/481) for more information.
+
 #### Hashie::Mash::CannotDisableMashWarnings error class is removed
 
 There shouldn't really be a case that anyone was relying on catching this specific error, but if so, they should change it to rescue Hashie::Extensions::KeyConflictWarning::CannotDisableMashWarnings
 
+See [#488](https://github.com/hashie/hashie/pull/488) for more information.
+
 ### Upgrading to 3.7.0
 
 #### Mash#load takes options
@@ -135,12 +213,13 @@ Options can now be passed into `Mash#load`.
 Mash.load(filename, permitted_classes: [])
 ```
 
+See [#474](https://github.com/hashie/hashie/pull/474) for more information.
+
 ### Upgrading to 3.5.2
 
 #### Disable logging in Mash subclasses
 
-If you subclass `Hashie::Mash`, you can now disable the logging we do about
-overriding existing methods with keys. This looks like:
+If you subclass `Hashie::Mash`, you can now disable the logging we do about overriding existing methods with keys. This looks like:
 
 ```ruby
 class MyMash < Hashie::Mash
@@ -148,6 +227,8 @@ class MyMash < Hashie::Mash
 end
 ```
 
+See [#395](https://github.com/hashie/hashie/pull/395) for more information.
+
 ### Upgrading to 3.4.7
 
 #### Procs as default values for Dash
@@ -160,6 +241,9 @@ end
 
 In versions < 3.4.7 `Time.now` will be evaluated when `time` property is accessed directly first time.
 In version >= 3.4.7 `Time.now` is evaluated in time of object initialization.
+
+See [#380](https://github.com/hashie/hashie/pull/380) for more information.
+
 ### Upgrading to 3.4.4
 
 #### Mash subclasses and reverse_merge
@@ -171,6 +255,8 @@ end
 
 In versions >= 3.4.4 `MyMash#reverse_merge` returns an instance of `MyMash` but in previous versions it was a `Hashie::Mash` instance.
 
+See [#322](https://github.com/hashie/hashie/pull/322) for more information.
+
 ### Upgrading to 3.2.2
 
 #### Testing if key defined
@@ -195,6 +281,8 @@ h.abc? # => true
 h.abb? # => false
 ```
 
+See [#317](https://github.com/hashie/hashie/pull/317) for more information.
+
 ### Upgrading to 3.2.1
 
 #### Possible coercion changes
@@ -205,12 +293,16 @@ The improvements made to coercions in version 3.2.1 [issue #200](https://github.
 
 If necessary, `dup` or `clone` your own objects. Do not assume Hashie will do it for you.
 
+See [#200](https://github.com/hashie/hashie/pull/200) for more information.
+
 **Change**: Failed coercion attempts now raise Hashie::CoercionError.
 
 Hashie now raises a Hashie::CoercionError that details on the property that could not be coerced, the source and target type of the coercion, and the internal error. Previously only the internal error was raised.
 
 Applications that were attempting to rescuing the internal errors should be updated to rescue Hashie::CoercionError instead.
 
+See [#200](https://github.com/hashie/hashie/pull/200) for more information.
+
 ### Upgrading to 3.0
 
 #### Compatibility with Rails 4 Strong Parameters
@@ -223,7 +315,7 @@ To enable 2.1 compatible behavior with Rails 4, use the [hashie_rails](http://ru
 gem 'hashie_rails'
 ```
 
-See [#154](https://github.com/hashie/hashie/pull/154) and [Mash and Rails 4 Strong Parameters](README.md#mash-and-rails-4-strong-parameters) for more details.
+See [#154](https://github.com/hashie/hashie/pull/154) for more information. Also see [Mash and Rails 4 Strong Parameters](README.md#mash-and-rails-4-strong-parameters).
 
 #### Key Conversions in Hashie::Dash and Hashie::Trash
 
@@ -273,6 +365,8 @@ class Person < Hashie::Dash
 end
 ```
 
+See [#152](https://github.com/hashie/hashie/pull/152) for more information.
+
 #### Key Conversions in Hashie::Hash#to_hash
 
 Version 2.1 or older of Hash#to_hash converted keys to strings automatically.

data/lib/hashie/clash.rb

@@ -97,7 +97,7 @@ module Hashie
 
     # @example Merge repeated hash options through chained builder calls
     #   Hashie::Clash.new.conditions(active: true).conditions(role: 'admin') # => { conditions: { active: true, role: 'admin' } }
-    def merge_store(key, *args) # :nodoc:
+    def _merge_store(key, *args) # :nodoc:
       case args.length
       when 1
         val = args.first
@@ -109,6 +109,7 @@ module Hashie
       self[key.to_sym] = val
       self
     end
+    private :_merge_store
 
     # @example Build nested options with dynamic method names
     #   Hashie::Clash.new.conditions!.active(true)._end!.limit(10) # => { conditions: { active: true }, limit: 10 }
@@ -127,7 +128,7 @@ module Hashie
           raise ChainError, 'tried to chain into a non-hash key'
         end
       elsif args.any?
-        merge_store(name, *args)
+        _merge_store(name, *args)
       else
         super
       end

data/lib/hashie/dash.rb

@@ -57,8 +57,8 @@ module Hashie
         defaults.delete property_name
       end
 
-      define_getter_for(property_name)
-      define_setter_for(property_name)
+      _define_getter_for(property_name)
+      _define_setter_for(property_name)
 
       @subclasses.each { |klass| klass.property(property_name, options) } if defined? @subclasses
 
@@ -133,16 +133,16 @@ module Hashie
       required_properties.key? name
     end
 
-    private_class_method def self.define_getter_for(property_name)
-      return if getters.include?(property_name)
+    private_class_method def self._define_getter_for(property_name)
+      return if method_defined?(property_name) || private_method_defined?(property_name)
 
       define_method(property_name) { |&block| self.[](property_name, &block) }
       getters << property_name
     end
 
-    private_class_method def self.define_setter_for(property_name)
+    private_class_method def self._define_setter_for(property_name)
       setter = :"#{property_name}="
-      return if method_defined?(setter)
+      return if method_defined?(setter) || private_method_defined?(setter)
 
       define_method(setter) { |value| self.[]=(property_name, value) }
     end
@@ -160,7 +160,7 @@ module Hashie
       super(&block)
 
       initialize_attributes(attributes)
-      assert_required_attributes_set!
+      _assert_required_attributes_set!
     end
 
     alias _regular_reader []
@@ -174,7 +174,7 @@ module Hashie
     #   klass = Class.new(Hashie::Dash) { property :name, default: 'Ada' }
     #   klass.new[:name] # => 'Ada'
     def [](property)
-      assert_property_exists! property
+      _assert_property_exists! property
       value = super
       # If the value is a lambda, proc, or whatever answers to call, eval the thing!
       if value.is_a? Proc
@@ -194,8 +194,8 @@ module Hashie
     #   dash[:name] = 'Ada'
     #   dash.name # => 'Ada'
     def []=(property, value)
-      assert_property_required! property, value
-      assert_property_exists! property
+      _assert_property_required! property, value
+      _assert_property_exists! property
       super
     end
 
@@ -203,7 +203,7 @@ module Hashie
     #   klass = Class.new(Hashie::Dash) { property :count }
     #   dash = klass.new(count: 2)
     #   dash.merge(count: 3) { |_key, old, new| old + new }.to_h # => { count: 5 }
-    #   dash.count # => 2
+    #   dash[:count] # => 2
     def merge(other_hash)
       new_dash = dup
       other_hash.each do |k, v|
@@ -276,7 +276,7 @@ module Hashie
     #   dash.update_attributes!(name: nil)
     #   dash.name # => 'Ada'
     def update_attributes!(attributes)
-      update_attributes(attributes)
+      _update_attributes(attributes)
 
       self.class.defaults.each_pair do |prop, value|
         next unless fetch(prop, nil).nil?
@@ -293,7 +293,7 @@ module Hashie
         end
       end
 
-      assert_required_attributes_set!
+      _assert_required_attributes_set!
     end
 
     private
@@ -305,7 +305,7 @@ module Hashie
       update_attributes!(cleaned_attributes)
     end
 
-    def update_attributes(attributes)
+    def _update_attributes(attributes)
       return unless attributes
 
       attributes.each_pair do |att, value|
@@ -313,31 +313,31 @@ module Hashie
       end
     end
 
-    def assert_property_exists!(property)
-      fail_no_property_error!(property) unless self.class.property?(property)
+    def _assert_property_exists!(property)
+      _fail_no_property_error!(property) unless self.class.property?(property)
     end
 
-    def assert_required_attributes_set!
+    def _assert_required_attributes_set!
       self.class.required_properties.each_key do |required_property|
-        assert_property_set!(required_property)
+        _assert_property_set!(required_property)
       end
     end
 
-    def assert_property_set!(property)
-      fail_property_required_error!(property) if send(property).nil? && _required?(property)
+    def _assert_property_set!(property)
+      _fail_property_required_error!(property) if self[property].nil? && _required?(property)
     end
 
-    def assert_property_required!(property, value)
-      fail_property_required_error!(property) if value.nil? && _required?(property)
+    def _assert_property_required!(property, value)
+      _fail_property_required_error!(property) if value.nil? && _required?(property)
     end
 
-    def fail_property_required_error!(property)
+    def _fail_property_required_error!(property)
       message = self.class.required_properties[property][:message]
       raise ArgumentError,
             "the property `#{property}` " + message
     end
 
-    def fail_no_property_error!(property)
+    def _fail_no_property_error!(property)
       raise NoMethodError,
             "the property `#{property}` is not defined for `#{self.class.name || 'anonymous class'}`"
     end
@@ -348,7 +348,7 @@ module Hashie
       condition = self.class.required_properties[property][:condition]
       case condition
       when Proc   then !!instance_exec(&condition)
-      when Symbol then !!send(condition)
+      when Symbol then !!(self.class.property?(condition) ? self[condition] : send(condition))
       else             !!condition
       end
     end

data/lib/hashie/extensions/block_access.rb

@@ -28,7 +28,7 @@ module Hashie
       def [](key)
         return super unless block_given?
 
-        value = block_access_child(self, key)
+        value = _block_access_child(self, key)
         yield value
         value
       end
@@ -44,22 +44,22 @@ module Hashie
 
         raise ArgumentError, "wrong number of arguments (given `#{args.size}`, expected 0..1)" if args.size > 1
 
-        child = block_access_child(self, block_access_key(name))
-        child = block_access_child(child, args.first) unless args.empty?
+        child = _block_access_child(self, _block_access_key(name))
+        child = _block_access_child(child, args.first) unless args.empty?
         block.call(child)
         child
       end
 
       private
 
-      def block_access_key(name)
+      def _block_access_key(name)
         return name if key?(name)
         return name.to_s if key?(name.to_s)
 
         respond_to?(:convert_key, true) ? convert_key(name.to_s) : name.to_s
       end
 
-      def block_access_child(parent, key)
+      def _block_access_child(parent, key)
         parent[key] = parent.class.new unless parent.key?(key)
         child = parent[key]
         return child if child.is_a?(::Hash)