# coding: utf-8
lib = File.expand_path('../lib', __FILE__)
$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
require 'bottomless_hash/version'

Gem::Specification.new do |spec|
  spec.name          = "bottomless_hash"
  spec.version       = BottomlessHash::VERSION
  spec.authors       = ["Nick Ostrovsky"]
  spec.email         = ["[email protected]"]

  spec.summary       = %q{Ruby Hash modified to accept keys blindly}
  spec.description   = %q{Is there a way to blindly assign nested values to a
                          Ruby hash without creating each key’s hash separately? Yes, but it’s more
                          involved than you’d think.}
  spec.homepage      = "https://github.com/firedev/bottomless_hash"
  spec.license       = "MIT"

  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
  # delete this section to allow pushing this gem to any host.
  # if spec.respond_to?(:metadata)
  #   spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com'"
  # else
  #   raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
  # end

  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
  spec.bindir        = "exe"
  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
  spec.require_paths = ["lib"]

  spec.add_development_dependency "bundler", "~> 1.10"
  spec.add_development_dependency "rake", "~> 10.0"
  spec.add_development_dependency "rspec"
end

# lib/bottomless_hash.rb

require "bottomless_hash/version"

class BottomlessHash < Hash
  def initialize
    super &-> h, k { h[k] = self.class.new }
  end

  def self.from_hash(hash)
    new.merge(hash)
  end
end

class Hash
  def bottomless
    BottomlessHash.from_hash(self)
  end
end

# spec/bottomless_hash
require 'spec_helper'

describe BottomlessHash do
  it 'has a version number' do
    expect(BottomlessHash::VERSION).not_to be nil
  end

  it 'does not raise on missing key' do
    expect do
      subject[:missing][:key]
    end.to_not raise_error
  end

  it 'returns an empty value on missing key' do
    expect(subject[:missing][:key]).to be_empty
  end

  it 'stores and returns keys' do
    subject[:existing][:key] = :value
    expect(subject[:existing][:key]).to eq :value
  end

  describe '#from_hash' do
    let (:hash) do
      { existing: { key: { value: :hello } } }
    end

    subject do
      described_class.from_hash(hash)
    end

    it 'returns old hash values' do
      expect(subject[:existing][:key][:value]).to eq :hello
    end

    it 'provides a bottomless version' do
      expect(subject[:missing][:key]).to be_empty
    end

    it 'stores and returns new values' do
      subject[:existing][:key] = :value
      expect(subject[:existing][:key]).to eq :value
    end

    it 'converts nested hashes as well' do
      expect do
        subject[:existing][:key][:missing]
      end.to_not raise_error
    end
  end
end

# lib/bottomless_hash/version.rb

class BottomlessHash < Hash
  VERSION = "0.1.0"
end

# spec/hash_spec.rb

require_relative '../lib/bottomless_hash'

describe Hash do
  subject do
    {
      existing: {
        key: :hello
      }
    }.bottomless
  end
  it 'is a BottomlessHash now' do
    expect(subject).to be_a BottomlessHash
  end

  it 'returns values for existing keys' do
    expect(subject[:existing][:key]).to eq :hello
  end

  it 'bottomlessly stores values' do
    subject[:new][:value] = :omg
    expect(subject[:new][:value]).to eq :omg
  end

  it 'does not raise error on missing keys' do
    expect do
      subject[:missing][:key]
    end.to_not raise_error
  end
end