inquisitive 1.0.0

data/lib/inquisitive/hash.rb

@@ -0,0 +1,39 @@
+module Inquisitive
+  class Hash < HashWithIndifferentAccess
+    include Inquisitive
+
+    attr_accessor :negated
+    def no
+      dup.tap{ |s| s.negated = !s.negated }
+    end
+
+    def convert_value(value, options={})
+      super(Inquisitive[value], options)
+    end
+
+  private
+
+    def dup
+      super.tap{ |duplicate| duplicate.negated = self.negated }
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      predicate_method?(method_name) or has_key?(method_name)
+    end
+    def method_missing(method_name, *arguments)
+      if predicate_method? method_name
+        if has_key? predication(method_name)
+          Inquisitive.present? self[predication(method_name)]
+        else
+          false
+        end ^ negated
+      elsif has_key? method_name
+        self[method_name]
+      else
+        super
+      end
+    end
+
+  end
+
+end

data/lib/inquisitive/hash_with_indifferent_access.rb

@@ -0,0 +1,185 @@
+module Inquisitive
+####
+# A trimmed down version of ActiveSupport 4.0's HashWithIndifferentAccess
+#  modified slightly so we don't have to inject behaviour into Hash.
+# It lacks all `deep_` transforms since that requires patching Object and Array.
+##
+  class HashWithIndifferentAccess < ::Hash
+
+    def extractable_options?
+      true
+    end
+    def with_indifferent_access
+      dup
+    end
+    def nested_under_indifferent_access
+      self
+    end
+
+    def self.[](*args)
+      new.merge!(::Hash[*args])
+    end
+
+    def initialize(constructor = {}, &block)
+      if constructor.is_a?(::Hash)
+        super()
+        steal_default_from(constructor)
+        update(constructor)
+      else
+        super(constructor)
+      end.tap do |hash|
+        self.default_proc = block if block_given?
+      end
+    end
+
+    def default(key = nil)
+      if key.is_a?(Symbol) && include?(key = key.to_s)
+        self[key]
+      else
+        super
+      end
+    end
+
+    def steal_default_from(hash)
+      if hash.default_proc
+        self.default_proc = hash.default_proc
+      else
+        self.default = hash.default
+      end
+    end
+
+    alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
+    alias_method :regular_update, :update unless method_defined?(:regular_update)
+
+    def []=(key, value)
+      regular_writer(convert_key(key), convert_value(value, for: :assignment))
+    end
+
+    alias_method :store, :[]=
+
+    def update(other_hash)
+      if other_hash.is_a? self.class
+        super(other_hash)
+      else
+        other_hash.each_pair do |key, value|
+          if block_given? && key?(key)
+            value = yield(convert_key(key), self[key], value)
+          end
+          regular_writer(convert_key(key), convert_value(value))
+        end
+        self
+      end
+    end
+
+    alias_method :merge!, :update
+
+    def key?(key)
+      super(convert_key(key))
+    end
+
+    alias_method :include?, :key?
+    alias_method :has_key?, :key?
+    alias_method :member?, :key?
+
+    def fetch(key, *extras)
+      super(convert_key(key), *extras)
+    end
+
+    def values_at(*indices)
+      indices.collect {|key| self[convert_key(key)]}
+    end
+
+    def dup
+      self.class.new(self).tap do |new_hash|
+        new_hash.default = default
+      end
+    end
+
+    def merge(hash, &block)
+      self.dup.update(hash, &block)
+    end
+
+    def replace(other_hash)
+      super(self.class.new(other_hash))
+    end
+
+    def delete(key)
+      super(convert_key(key))
+    end
+
+    def transform_keys
+      result = {}
+      each_key do |key|
+        result[yield(key)] = self[key]
+      end
+      result
+    end
+
+    def transform_keys!
+      keys.each do |key|
+        self[yield(key)] = delete(key)
+      end
+      self
+    end
+
+    def symbolize_keys
+      transform_keys{ |key| key.to_sym rescue key }
+    end
+
+    def symbolize_keys!
+      transform_keys!{ |key| key.to_sym rescue key }
+    end
+
+    def assert_valid_keys(*valid_keys)
+      valid_string_keys = valid_keys.flatten.map(&:to_s).uniq
+      each_key do |k|
+        raise ArgumentError.new("Unknown key: #{k}") unless valid_string_keys.include?(k)
+      end
+    end
+
+    def stringify_keys!; self end
+    def stringify_keys; dup end
+    def to_options!; self end
+
+    def select(*args, &block)
+      dup.tap {|hash| hash.select!(*args, &block)}
+    end
+
+    def to_hash
+      _new_hash= {}
+      each do |key, value|
+        _new_hash[convert_key(key)] = convert_value(value, for: :to_hash)
+      end
+      ::Hash.new(default).merge!(_new_hash)
+    end
+
+  protected
+
+    def convert_key(key)
+      key.kind_of?(Symbol) ? key.to_s : key
+    end
+
+    def convert_value(value, options = {})
+      if value.is_a? ::Hash
+        if options[:for] == :to_hash
+          value.to_hash
+        else
+          if value.is_a? self.class
+            value
+          else
+            self.class.new value
+          end
+        end
+      elsif value.is_a?(::Array)
+        unless options[:for] == :assignment
+          value = value.dup
+        end
+        value.map! { |e| convert_value(e, options) }
+      else
+        value
+      end
+    end
+
+  end
+
+end

data/lib/inquisitive/string.rb

@@ -0,0 +1,24 @@
+module Inquisitive
+  class String < ::String
+    include Inquisitive
+
+    attr_accessor :negated
+    def not
+      self.dup.tap{ |s| s.negated = !s.negated }
+    end
+
+  private
+
+    def respond_to_missing?(method_name, include_private = false)
+      predicate_method? method_name
+    end
+    def method_missing(method_name, *arguments)
+      if predicate_method? method_name
+        (self == predication(method_name)) ^ negated
+      else
+        super
+      end
+    end
+
+  end
+end

data/test/inquisitive/array_test.rb

@@ -0,0 +1,11 @@
+require 'test_helper'
+
+class InquisitiveArrayTest < Test
+
+  def array
+    Inquisitive::Array.new @raw_array
+  end
+
+  include ArrayTests
+
+end

data/test/inquisitive/combinatorial_environment_test.rb

@@ -0,0 +1,72 @@
+class InquisitiveCombinatorialEnvironmentTest < EnvironmentTest
+
+  def setup
+    super
+    ENV['STRING'] = @raw_string
+    ENV['ARRAY'] = @raw_array.join(',')
+    ENV['HASH_AUTHENTICATION'] = @raw_hash[:authentication].to_s
+    ENV['HASH_IN'] = @raw_hash[:in]
+    ENV['HASH_DATABASES'] = @raw_hash[:databases].join(',')
+  end
+  def teardown
+    super
+    ENV.delete 'STRING'
+    ENV.delete 'ARRAY'
+    ENV.delete 'HASH_AUTHENTICATION'
+    ENV.delete 'HASH_IN'
+    ENV.delete 'HASH_DATABASES'
+    ENV.delete 'HASH_SOMETHING_NEW'
+  end
+
+  def change_string_variable
+    ENV['STRING'] = 'something_new'
+  end
+  def change_array_variable
+    ENV['ARRAY'] = [ ENV['ARRAY'], 'something_new' ].join ','
+  end
+  def change_hash_variable
+    ENV['HASH_SOMETHING_NEW'] = 'true'
+  end
+
+end
+
+%w[dynamic cached static].each do |mode|
+  %w[string array hash].each do |type|
+
+    Inquisitive.const_set(
+      :"Inquisitive#{mode.capitalize}#{type.capitalize}EnvironmentTest",
+      Class.new(InquisitiveCombinatorialEnvironmentTest) do
+
+        class << self
+          attr_accessor :mode, :type
+        end
+
+        def setup
+          super
+          @mode = Inquisitive[self.class.mode]
+          @type = Inquisitive[self.class.type]
+          App.inquires_about @type.upcase, mode: @mode
+        end
+
+        def string
+          App.string
+        end
+        def array
+          App.array
+        end
+        def hash
+          App.hash
+        end
+
+        include CombinatorialEnvironmentTests
+
+      end
+    ).tap do |klass|
+      klass.mode = mode
+      klass.type = type
+    end.send :include, Object.const_get(:"#{type.capitalize}Tests")
+    # Mixes in type-specific tests to ensure lookup behaves normally
+    #  when accessed through the modes of App getters
+
+  end
+end

data/test/inquisitive/environment_test.rb

@@ -0,0 +1,44 @@
+require 'test_helper'
+
+class InquisitiveEnvironmentTest < EnvironmentTest
+
+  def test_missing_variable_responses
+    App.inquires_about '__DOES_NOT_EXIST__', with: :exists
+    assert_equal App.exists, nil
+  end
+  def test_missing_variable_predicates
+    App.inquires_about '__DOES_NOT_EXIST__', with: :exists
+    refute App.exists?
+  end
+
+  def test_autonaming_of_inquirers
+    App.inquires_about 'NAME_NOT_SPECIFIED'
+    assert App.respond_to? :name_not_specified
+  end
+
+  def test_default_mode_of_dynamic
+    App.inquires_about 'DEFAULTS_TO', with: :defaults_to
+    App.defaults_to # Call once to ensure no caching
+    ENV['DEFAULTS_TO'] = 'dynamic'
+    assert App.defaults_to.dynamic?
+  end
+
+  def test_custom_string_presence
+    ENV['AUTHORIZABLE'] = 'false'
+    App.inquires_about 'AUTHORIZABLE', present_if: 'true'
+    refute App.authorizable?
+  end
+
+  def test_custom_regex_presence
+    ENV['AUTHORIZABLE'] = 'not at all'
+    App.inquires_about 'AUTHORIZABLE', present_if: /yes/
+    refute App.authorizable?
+  end
+
+  def test_custom_class_presence
+    ENV['AUTHORIZABLE'] = 'not at all'
+    App.inquires_about 'AUTHORIZABLE', present_if: Array
+    refute App.authorizable?
+  end
+
+end

data/test/inquisitive/hash_test.rb

@@ -0,0 +1,20 @@
+require 'test_helper'
+
+class HashTest < Test
+
+  def hash
+    Inquisitive::Hash.new @raw_hash
+  end
+  include HashTests
+
+  def string
+    hash.in
+  end
+  include StringTests
+
+  def array
+    hash.databases
+  end
+  include ArrayTests
+
+end

data/test/inquisitive/hash_with_indifferent_access_test.rb

@@ -0,0 +1,482 @@
+require 'test_helper'
+
+class InquisitiveHashWithIndifferentAccessTest < Test
+  HashWithIndifferentAccess = Inquisitive::HashWithIndifferentAccess
+
+  class IndifferentHash < HashWithIndifferentAccess
+  end
+
+  class SubclassingArray < Array
+  end
+
+  class SubclassingHash < Hash
+  end
+
+  def setup
+    @strings                 = { 'a' => 1, 'b' => 2 }
+    @nested_strings          = { 'a' => { 'b' => { 'c' => 3 } } }
+    @symbols                 = { :a  => 1, :b  => 2 }
+    @nested_symbols          = { :a  => { :b => { :c => 3 } } }
+    @mixed                   = { :a  => 1, 'b' => 2 }
+    @nested_mixed            = { 'a' => { :b => { 'c' => 3 } } }
+    @fixnums                 = {  0  => 1,  1  => 2 }
+    @nested_fixnums          = {  0  => { 1  => { 2 => 3} } }
+    @illegal_symbols         = { []  => 3 }
+    @nested_illegal_symbols  = { []  => { [] => 3} }
+    @upcase_strings          = { 'A' => 1, 'B' => 2 }
+    @nested_upcase_strings   = { 'A' => { 'B' => { 'C' => 3 } } }
+
+    @indifferent_strings                 = HashWithIndifferentAccess.new @strings
+    @indifferent_nested_strings          = HashWithIndifferentAccess.new @nested_strings
+    @indifferent_symbols                 = HashWithIndifferentAccess.new @symbols
+    @indifferent_nested_symbols          = HashWithIndifferentAccess.new @nested_symbols
+    @indifferent_mixed                   = HashWithIndifferentAccess.new @mixed
+    @indifferent_nested_mixed            = HashWithIndifferentAccess.new @nested_mixed
+    @indifferent_fixnums                 = HashWithIndifferentAccess.new @fixnums
+    @indifferent_nested_fixnums          = HashWithIndifferentAccess.new @nested_fixnums
+    @indifferent_illegal_symbols         = HashWithIndifferentAccess.new @illegal_symbols
+    @indifferent_nested_illegal_symbols  = HashWithIndifferentAccess.new @nested_illegal_symbols
+    @indifferent_upcase_strings          = HashWithIndifferentAccess.new @upcase_strings
+    @indifferent_nested_upcase_strings   = HashWithIndifferentAccess.new @nested_upcase_strings
+  end
+
+  def test_extractable_options?
+    assert @indifferent_strings.extractable_options?
+  end
+
+  def test_with_indifferent_access
+    assert_equal @indifferent_strings, @indifferent_strings.with_indifferent_access
+  end
+
+  def test_nested_under_indifferent_access
+    assert_same @indifferent_strings, @indifferent_strings.nested_under_indifferent_access
+  end
+
+  def test_indifferent_transform_keys
+    assert_equal @indifferent_upcase_strings, @indifferent_strings.transform_keys{ |key| key.to_s.upcase }
+    assert_equal @indifferent_upcase_strings, @indifferent_symbols.transform_keys{ |key| key.to_s.upcase }
+    assert_equal @indifferent_upcase_strings, @indifferent_mixed.transform_keys{ |key| key.to_s.upcase }
+  end
+
+  def test_indifferent_transform_keys_not_mutates
+    transformed_hash = @indifferent_mixed.dup
+    transformed_hash.transform_keys{ |key| key.to_s.upcase }
+    assert_equal @indifferent_mixed, transformed_hash
+  end
+
+  def test_indifferent_transform_keys!
+    assert_equal @indifferent_upcase_strings, @indifferent_symbols.dup.transform_keys!{ |key| key.to_s.upcase }
+    assert_equal @indifferent_upcase_strings, @indifferent_strings.dup.transform_keys!{ |key| key.to_s.upcase }
+    assert_equal @indifferent_upcase_strings, @indifferent_mixed.dup.transform_keys!{ |key| key.to_s.upcase }
+  end
+
+  def test_indifferent_transform_keys_with_bang_mutates
+    transformed_hash = @indifferent_mixed.dup
+    transformed_hash.transform_keys!{ |key| key.to_s.upcase }
+    assert_equal @indifferent_upcase_strings, transformed_hash
+    assert_equal @mixed, { :a => 1, "b" => 2 }
+  end
+
+  def test_indifferent_symbolize_keys
+    assert_equal @symbols, @indifferent_symbols.symbolize_keys
+    assert_equal @symbols, @indifferent_strings.symbolize_keys
+    assert_equal @symbols, @indifferent_mixed.symbolize_keys
+  end
+
+  def test_indifferent_symbolize_keys_not_mutates
+    transformed_hash = @indifferent_mixed.dup
+    transformed_hash.symbolize_keys
+    assert_equal @indifferent_mixed, transformed_hash
+  end
+
+  def test_indifferent_symbolize_keys!
+    assert_equal @indifferent_symbols, @indifferent_symbols.dup.symbolize_keys!
+    assert_equal @indifferent_symbols, @indifferent_strings.dup.symbolize_keys!
+    assert_equal @indifferent_symbols, @indifferent_mixed.dup.symbolize_keys!
+  end
+
+  def test_indifferent_symbolize_keys_preserves_keys_that_cant_be_symbolized
+    assert_equal @indifferent_illegal_symbols, @indifferent_illegal_symbols.symbolize_keys
+    assert_equal @indifferent_illegal_symbols, @indifferent_illegal_symbols.dup.symbolize_keys!
+  end
+
+  def test_indifferent_stringify_keys
+    assert_equal @indifferent_strings, @indifferent_symbols.stringify_keys
+    assert_equal @indifferent_strings, @indifferent_strings.stringify_keys
+    assert_equal @indifferent_strings, @indifferent_mixed.stringify_keys
+  end
+
+  def test_indifferent_stringify_keys_not_mutates
+    transformed_hash = @indifferent_mixed.dup
+    transformed_hash.stringify_keys
+    assert_equal @indifferent_mixed, transformed_hash
+  end
+
+  def test_indifferent_stringify_keys!
+    assert_equal @indifferent_strings, @indifferent_symbols.dup.stringify_keys!
+    assert_equal @indifferent_strings, @indifferent_strings.dup.stringify_keys!
+    assert_equal @indifferent_strings, @indifferent_mixed.dup.stringify_keys!
+  end
+
+  def test_indifferent_stringify_keys_with_bang_mutates
+    transformed_hash = @indifferent_mixed.dup
+    transformed_hash.stringify_keys!
+    assert_equal @indifferent_strings, transformed_hash
+    assert_equal @mixed, { :a => 1, "b" => 2 }
+  end
+
+  def test_indifferent_assorted
+    @strings = HashWithIndifferentAccess.new @strings
+    @symbols = HashWithIndifferentAccess.new @symbols
+    @mixed   = HashWithIndifferentAccess.new @mixed
+
+    assert_equal 'a', @strings.__send__(:convert_key, :a)
+
+    assert_equal 1, @strings.fetch('a')
+    assert_equal 1, @strings.fetch(:a.to_s)
+    assert_equal 1, @strings.fetch(:a)
+
+    hashes = { :@strings => @strings, :@symbols => @symbols, :@mixed => @mixed }
+    method_map = { :'[]' => 1, :fetch => 1, :values_at => [1],
+      :has_key? => true, :include? => true, :key? => true,
+      :member? => true }
+
+    hashes.each do |name, hash|
+      method_map.sort_by { |m| m.to_s }.each do |meth, expected|
+        assert_equal(expected, hash.__send__(meth, 'a'),
+                     "Calling #{name}.#{meth} 'a'")
+        assert_equal(expected, hash.__send__(meth, :a),
+                     "Calling #{name}.#{meth} :a")
+      end
+    end
+
+    assert_equal [1, 2], @strings.values_at('a', 'b')
+    assert_equal [1, 2], @strings.values_at(:a, :b)
+    assert_equal [1, 2], @symbols.values_at('a', 'b')
+    assert_equal [1, 2], @symbols.values_at(:a, :b)
+    assert_equal [1, 2], @mixed.values_at('a', 'b')
+    assert_equal [1, 2], @mixed.values_at(:a, :b)
+  end
+
+  def test_indifferent_reading
+    hash = HashWithIndifferentAccess.new
+    hash["a"] = 1
+    hash["b"] = true
+    hash["c"] = false
+    hash["d"] = nil
+
+    assert_equal 1, hash[:a]
+    assert_equal true, hash[:b]
+    assert_equal false, hash[:c]
+    assert_equal nil, hash[:d]
+    assert_equal nil, hash[:e]
+  end
+
+
+  def test_indifferent_reading_with_nonnil_default
+    hash = HashWithIndifferentAccess.new(1)
+    hash["a"] = 1
+    hash["b"] = true
+    hash["c"] = false
+    hash["d"] = nil
+
+    assert_equal 1, hash[:a]
+    assert_equal true, hash[:b]
+    assert_equal false, hash[:c]
+    assert_equal nil, hash[:d]
+    assert_equal 1, hash[:e]
+  end
+
+  def test_indifferent_writing
+    hash = HashWithIndifferentAccess.new
+    hash[:a] = 1
+    hash['b'] = 2
+    hash[3] = 3
+
+    assert_equal hash['a'], 1
+    assert_equal hash['b'], 2
+    assert_equal hash[:a], 1
+    assert_equal hash[:b], 2
+    assert_equal hash[3], 3
+  end
+
+  def test_indifferent_update
+    hash = HashWithIndifferentAccess.new
+    hash[:a] = 'a'
+    hash['b'] = 'b'
+
+    updated_with_strings = hash.update(@strings)
+    updated_with_symbols = hash.update(@symbols)
+    updated_with_mixed = hash.update(@mixed)
+
+    assert_equal updated_with_strings[:a], 1
+    assert_equal updated_with_strings['a'], 1
+    assert_equal updated_with_strings['b'], 2
+
+    assert_equal updated_with_symbols[:a], 1
+    assert_equal updated_with_symbols['b'], 2
+    assert_equal updated_with_symbols[:b], 2
+
+    assert_equal updated_with_mixed[:a], 1
+    assert_equal updated_with_mixed['b'], 2
+
+    assert [updated_with_strings, updated_with_symbols, updated_with_mixed].all? { |h| h.keys.size == 2 }
+  end
+
+  def test_indifferent_merging
+    hash = HashWithIndifferentAccess.new
+    hash[:a] = 'failure'
+    hash['b'] = 'failure'
+
+    other = { 'a' => 1, :b => 2 }
+
+    merged = hash.merge(other)
+
+    assert_equal HashWithIndifferentAccess, merged.class
+    assert_equal 1, merged[:a]
+    assert_equal 2, merged['b']
+
+    hash.update(other)
+
+    assert_equal 1, hash[:a]
+    assert_equal 2, hash['b']
+  end
+
+  def test_indifferent_replace
+    hash = HashWithIndifferentAccess.new
+    hash[:a] = 42
+
+    replaced = hash.replace(b: 12)
+
+    assert hash.key?('b')
+    assert !hash.key?(:a)
+    assert_equal 12, hash[:b]
+    assert_same hash, replaced
+  end
+
+  def test_indifferent_merging_with_block
+    hash = HashWithIndifferentAccess.new
+    hash[:a] = 1
+    hash['b'] = 3
+
+    other = { 'a' => 4, :b => 2, 'c' => 10 }
+
+    merged = hash.merge(other) { |key, old, new| old > new ? old : new }
+
+    assert_equal HashWithIndifferentAccess, merged.class
+    assert_equal 4, merged[:a]
+    assert_equal 3, merged['b']
+    assert_equal 10, merged[:c]
+
+    other_indifferent = HashWithIndifferentAccess.new('a' => 9, :b => 2)
+
+    merged = hash.merge(other_indifferent) { |key, old, new| old + new }
+
+    assert_equal HashWithIndifferentAccess, merged.class
+    assert_equal 10, merged[:a]
+    assert_equal 5, merged[:b]
+  end
+
+  def test_indifferent_deleting
+    get_hash = proc{ HashWithIndifferentAccess.new(:a => 'foo') }
+    hash = get_hash.call
+    assert_equal hash.delete(:a), 'foo'
+    assert_equal hash.delete(:a), nil
+    hash = get_hash.call
+    assert_equal hash.delete('a'), 'foo'
+    assert_equal hash.delete('a'), nil
+  end
+
+  def test_indifferent_select
+    hash = HashWithIndifferentAccess.new(@strings).select {|k,v| v == 1}
+
+    assert_equal({ 'a' => 1 }, hash)
+    assert_instance_of HashWithIndifferentAccess, hash
+  end
+
+  def test_indifferent_select_returns_a_hash_when_unchanged
+    hash = HashWithIndifferentAccess.new(@strings).select {|k,v| true}
+
+    assert_instance_of HashWithIndifferentAccess, hash
+  end
+
+  def test_indifferent_select_bang
+    indifferent_strings = HashWithIndifferentAccess.new(@strings)
+    indifferent_strings.select! {|k,v| v == 1}
+
+    assert_equal({ 'a' => 1 }, indifferent_strings)
+    assert_instance_of HashWithIndifferentAccess, indifferent_strings
+  end
+
+  def test_indifferent_reject
+    hash = HashWithIndifferentAccess.new(@strings).reject {|k,v| v != 1}
+
+    assert_equal({ 'a' => 1 }, hash)
+    assert_instance_of HashWithIndifferentAccess, hash
+  end
+
+  def test_indifferent_reject_bang
+    indifferent_strings = HashWithIndifferentAccess.new(@strings)
+    indifferent_strings.reject! {|k,v| v != 1}
+
+    assert_equal({ 'a' => 1 }, indifferent_strings)
+    assert_instance_of HashWithIndifferentAccess, indifferent_strings
+  end
+
+  def test_indifferent_to_hash
+    # Should convert to a Hash with String keys.
+    assert_equal @strings, HashWithIndifferentAccess.new(@mixed).to_hash
+
+    # Should preserve the default value.
+    mixed_with_default = @mixed.dup
+    mixed_with_default.default = '1234'
+    roundtrip = HashWithIndifferentAccess.new(mixed_with_default).to_hash
+    assert_equal @strings, roundtrip
+    assert_equal '1234', roundtrip.default
+
+    # Should preserve the default proc.
+    mixed_with_default_proc = @mixed.dup
+    mixed_with_default_proc.default_proc = -> (h, k) { '1234' }
+    roundtrip = HashWithIndifferentAccess.new(mixed_with_default_proc).to_hash
+    assert_equal @strings, roundtrip
+    assert_equal '1234', roundtrip.default
+
+    # Should preserve access
+    new_to_hash = HashWithIndifferentAccess.new(@nested_mixed).to_hash
+    refute_instance_of HashWithIndifferentAccess, new_to_hash
+    refute_instance_of HashWithIndifferentAccess, new_to_hash["a"]
+    refute_instance_of HashWithIndifferentAccess, new_to_hash["a"]["b"]
+  end
+
+  def test_lookup_returns_the_same_object_that_is_stored_in_hash_indifferent_access
+    hash = HashWithIndifferentAccess.new {|h, k| h[k] = []}
+    hash[:a] << 1
+
+    assert_equal [1], hash[:a]
+  end
+
+  def test_with_indifferent_access_has_no_side_effects_on_existing_hash
+    hash = {content: [{:foo => :bar, 'bar' => 'baz'}]}
+    HashWithIndifferentAccess.new(hash)
+
+    assert_equal [:foo, "bar"], hash[:content].first.keys
+  end
+
+  def test_indifferent_hash_with_array_of_hashes
+    hash = HashWithIndifferentAccess.new( "urls" => { "url" => [ { "address" => "1" }, { "address" => "2" } ] })
+    assert_equal "1", hash[:urls][:url].first[:address]
+
+    hash = hash.to_hash
+    refute_instance_of HashWithIndifferentAccess, hash
+    refute_instance_of HashWithIndifferentAccess, hash["urls"]
+    refute_instance_of HashWithIndifferentAccess, hash["urls"]["url"].first
+  end
+
+  def test_should_preserve_array_subclass_when_value_is_array
+    array = SubclassingArray.new
+    array << { "address" => "1" }
+    hash = HashWithIndifferentAccess.new "urls" => { "url" => array }
+    assert_equal SubclassingArray, hash[:urls][:url].class
+  end
+
+  def test_should_preserve_array_class_when_hash_value_is_frozen_array
+    array = SubclassingArray.new
+    array << { "address" => "1" }
+    hash = HashWithIndifferentAccess.new "urls" => { "url" => array.freeze }
+    assert_equal SubclassingArray, hash[:urls][:url].class
+  end
+
+  def test_stringify_and_symbolize_keys_on_indifferent_preserves_hash
+    h = HashWithIndifferentAccess.new
+    h[:first] = 1
+    h = h.stringify_keys
+    assert_equal 1, h['first']
+    h = HashWithIndifferentAccess.new
+    h['first'] = 1
+    h = h.symbolize_keys
+    assert_equal 1, h[:first]
+  end
+
+  def test_to_options_on_indifferent_preserves_hash
+    h = HashWithIndifferentAccess.new
+    h['first'] = 1
+    h.to_options!
+    assert_equal 1, h['first']
+  end
+
+  def test_indifferent_subhashes
+    h = HashWithIndifferentAccess.new 'user' => {'id' => 5}
+    ['user', :user].each {|user| [:id, 'id'].each {|id| assert_equal 5, h[user][id], "h[#{user.inspect}][#{id.inspect}] should be 5"}}
+
+    h = HashWithIndifferentAccess.new :user => {:id => 5}
+    ['user', :user].each {|user| [:id, 'id'].each {|id| assert_equal 5, h[user][id], "h[#{user.inspect}][#{id.inspect}] should be 5"}}
+  end
+
+  def test_indifferent_duplication
+    # Should preserve default value
+    h = HashWithIndifferentAccess.new
+    h.default = '1234'
+    assert_equal h.default, h.dup.default
+
+    # Should preserve class for subclasses
+    h = IndifferentHash.new
+    assert_equal h.class, h.dup.class
+  end
+
+  def test_assert_valid_keys
+    refute_raise do
+      HashWithIndifferentAccess.new(:failure => "stuff", :funny => "business").
+        assert_valid_keys([ :failure, :funny ])
+      HashWithIndifferentAccess.new(:failure => "stuff", :funny => "business").
+        assert_valid_keys(:failure, :funny)
+    end
+
+    assert_raises(ArgumentError, "Unknown key: failore") do
+      HashWithIndifferentAccess.new(:failore => "stuff", :funny => "business").
+        assert_valid_keys([ :failure, :funny ])
+      HashWithIndifferentAccess.new(:failore => "stuff", :funny => "business").
+        assert_valid_keys(:failure, :funny)
+    end
+  end
+
+  def test_store_on_indifferent_access
+    hash = HashWithIndifferentAccess.new
+    hash.store(:test1, 1)
+    hash.store('test1', 11)
+    hash[:test2] = 2
+    hash['test2'] = 22
+    expected = { "test1" => 11, "test2" => 22 }
+    assert_equal expected, hash
+  end
+
+  def test_constructor_on_indifferent_access
+    hash = HashWithIndifferentAccess[:foo, 1]
+    assert_equal 1, hash[:foo]
+    assert_equal 1, hash['foo']
+    hash[:foo] = 3
+    assert_equal 3, hash[:foo]
+    assert_equal 3, hash['foo']
+  end
+
+  def test_should_use_default_value_for_unknown_key
+    hash_wia = HashWithIndifferentAccess.new(3)
+    assert_equal 3, hash_wia[:new_key]
+  end
+
+  def test_should_use_default_value_if_no_key_is_supplied
+    hash_wia = HashWithIndifferentAccess.new(3)
+    assert_equal 3, hash_wia.default
+  end
+
+  def test_should_nil_if_no_default_value_is_supplied
+    hash_wia = HashWithIndifferentAccess.new
+    assert_nil hash_wia.default
+  end
+
+  def test_should_copy_the_default_value_when_converting_to_hash_with_indifferent_access
+    hash = Hash.new(3)
+    hash_wia = HashWithIndifferentAccess.new(hash)
+    assert_equal 3, hash_wia.default
+  end
+
+end