casted_hash 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2f735188cdd5cdd37dc4227455a8ca9e47ba5c5c
-  data.tar.gz: c10f6c97be498703a37092e8972e09a982c1e789
+  metadata.gz: 80a47e0dbe45026edc63a50e69adf59090ffd638
+  data.tar.gz: 973fc8ba7cadd92869cb0667b8875c3ef500efd2
 SHA512:
-  metadata.gz: 8785cacb5f811f22d70323ffab6d3bbb2b51a6ce1df80a99579df7101ca41bd0c456f68fe0d9511f6d986cea6852fc5bc7d0260df9bb6b6a2d291be949b52600
-  data.tar.gz: 2c4a168c1137d09894360cff7ac5d1ff757ba7edd251a46acade8f303ebb68abedea17d2dbc0990be46d6dd6e0d2e9bb945b1bd07d6ce71029c33688c72757f0
+  metadata.gz: 1f0ff29181122f15a57bcadc791402b0010db1c186c0b44dca5dadee33276f49392712cd92d43792a7bf9b4ec2e593a2767f3ae6775e25859eb39d5e0f95b0f7
+  data.tar.gz: 40a7606d898ef57a6671bc10a3af21f4b3a87a4fc5726ea0bb82f892a35d4761e814f6b8a5e62f4dbf9a0df38eacd58a1e3bf0662dd0e66931270e8e31fad0f4

data/casted_hash.gemspec

@@ -1,7 +1,7 @@
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'casted_hash/version'
+require 'casted_hash'
 
 Gem::Specification.new do |spec|
   spec.name          = "casted_hash"
@@ -14,10 +14,8 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
-  spec.add_dependency "equalizer", ">= 0.0.7"
-  spec.add_dependency "activesupport"
 
-  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "bundler", ">= 1.3"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "minitest", "~> 5"
   spec.add_development_dependency "coveralls"

data/lib/casted_hash.rb

@@ -1,133 +1,133 @@
-require "casted_hash/version"
-require "equalizer"
-require "casted_hash/value"
-require "active_support/hash_with_indifferent_access"
-
-class CastedHash
-  include Equalizer.new(:raw, :cast_proc)
-  extend Forwardable
-  attr_reader :cast_proc
-
-  def_delegators :@hash, *[:keys, :inject, :key?, :include?, :empty?, :any?]
-  def_delegators :casted_hash, *[:collect, :reject]
+class CastedHash < Hash
+  VERSION = "0.2.0"
 
   def initialize(constructor = {}, cast_proc = nil)
     raise ArgumentError, "`cast_proc` required" unless cast_proc
 
     @cast_proc = cast_proc
 
-    if constructor.is_a?(Hash)
-      @hash = HashWithIndifferentAccess.new
+    if constructor.is_a?(CastedHash)
+      super()
+      @casted_keys = constructor.instance_variable_get(:@casted_keys)
+      regular_update(constructor)
+    elsif constructor.is_a?(Hash)
+      @casted_keys = []
+      super()
       update(constructor)
-    elsif constructor.is_a?(CastedHash)
-      @hash = constructor.pack_hash(self)
     else
-      raise ArgumentError
+      @casted_keys = []
+      super(constructor)
     end
   end
 
-  def each
-    @hash.each do |key, value|
-      yield key, value.casted_value
-    end
-  end
-  alias_method :each_pair, :each
+  alias_method :regular_reader, :[] unless method_defined?(:regular_reader)
 
-  def values
-    @hash.values.map(&:casted_value)
+  def [](key)
+    cast! key
   end
 
-  def fetch(key, *args)
-    val = @hash[key]
+  def fetch(key, *extras)
+    value = cast!(key)
 
-    if val.nil?
-      @hash.fetch(key, *args)
+    if value.nil?
+      super(convert_key(key), *extras)
     else
-      cast(key, val).value
+      value
     end
   end
 
-  def [](key)
-    val = @hash[key]
-    val.casted_value unless val.nil?
-  end
+  alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
+  alias_method :regular_update, :update unless method_defined?(:regular_update)
 
   def []=(key, value)
-    @hash[key] = pack(value)
+    @casted_keys.delete key.to_s
+    regular_writer(convert_key(key), value)
   end
-  alias_method :store, :[]=
 
-  def delete(key)
-    @hash.delete(key)
-  end
-
-  def to_hash
-    @hash
-  end
+  alias_method :store, :[]=
 
-  def pack_hash(casted_hash)
-    @hash.inject(HashWithIndifferentAccess.new) do |hash, (key, value)|
-      hash.merge key => pack(value, casted_hash)
-    end
+  def merge(hash)
+    self.dup.update(hash)
   end
 
   def update(other_hash)
     return self if other_hash.empty?
 
     if other_hash.is_a? CastedHash
-      @hash.update other_hash.pack_hash(self)
+      other_hash.keys.each{|key| @casted_keys.delete key}
+      super(other_hash)
     else
-      other_hash.each_pair { |key, value| store(key, value) }
+      other_hash.each_pair { |key, value| self[key] = value }
+      self
     end
-
-    self
   end
+
   alias_method :merge!, :update
 
-  def merge(other)
-    self.dup.update other
+  def key?(key)
+    super(convert_key(key))
   end
 
-  def casted?(key)
-    val = @hash[key]
-    val.casted? if val
+  alias_method :include?, :key?
+  alias_method :has_key?, :key?
+  alias_method :member?, :key?
+
+  def values_at(*indices)
+    indices.collect {|key| self[convert_key(key)]}
   end
 
-  def inspect
-    "#<#{self.class.name} hash=#{@hash.inject({}){|hash, (k, v)|hash.merge(k => casted?(k) ? v.value : "<#{v.value}>")}}>"
+  def dup
+    self.class.new(self, @cast_proc)
   end
 
-  def casted_hash
+  def delete(key)
+    @casted_keys.delete key.to_s
+    super(convert_key(key))
+  end
+
+  def values
     cast_all!
+    super
+  end
 
-    @hash.inject({}) do |hash, (key, value)|
-      hash.merge(key => value.value)
-    end
+  def each
+    cast_all!
+    super
   end
 
-  def dup
-    self.class.new(self, @cast_proc)
+  def casted_hash
+    cast_all!
+    self
+  end
+
+  def casted?(key)
+    @casted_keys.include?(key.to_s)
   end
 
-private
+protected
+
+  def cast!(key)
+    return unless key?(key)
+    return regular_reader(convert_key(key)) if casted?(key)
+    @casted_keys << key.to_s
+
+    value = if @cast_proc.arity == 1
+      @cast_proc.call regular_reader(convert_key(key))
+    elsif @cast_proc.arity == 2
+      @cast_proc.call key, regular_reader(convert_key(key))
+    else
+      @cast_proc.call
+    end
 
-  def raw
-    @hash
+    regular_writer(convert_key(key), value)
   end
 
   def cast_all!
-    @hash.each do |key, value|
-      value.cast!
-    end
+    keys.each{|key| cast! key}
   end
 
-  def pack(value, casted_hash = self)
-    if value.is_a?(Value)
-      value.casted_hash =  casted_hash
-      value
-    else
-      Value.new(value, casted_hash)
-    end
+  def convert_key(key)
+    key.kind_of?(Symbol) ? key.to_s : key
   end
 
 end

data/test/test_casted_hash.rb

@@ -1,244 +1,211 @@
 require 'helper'
 
-class TestCastedHash < Minitest::Test
-  describe CastedHash do
+describe CastedHash do
 
-    it "should be able to define a cast method" do
-      hash = CastedHash.new({:foo => 1}, lambda { |x| x.to_s })
+  it "is able to define a cast method" do
+    hash = CastedHash.new({:foo => 1}, lambda { |x| x.to_s })
 
-      hash[:bar] = 1
-      assert_equal "1", hash[:bar]
+    hash[:bar] = 1
+    assert_equal "1", hash[:bar]
 
-      hash[:bar] = 2
-      assert_equal "2", hash[:bar]
+    hash[:bar] = 2
+    assert_equal "2", hash[:bar]
 
-      hash.store :bar, 3
-      assert_equal "3", hash[:bar]
-    end
-
-    it "should not loop when refering to itself" do
-      @hash = CastedHash.new({:a => 1}, lambda {|x| @hash[:a] + 1 })
-      exception = assert_raises(SystemStackError) do
-        @hash[:a]
-      end
-      assert_equal "Cannot cast value that is currently being cast", exception.message
-    end
-
-    it "should cast when expected" do
-      hash = CastedHash.new({:a => 1, :b => 2}, lambda {|x| x + 10 })
-      assert !hash.casted?(:a)
-      assert !hash.casted?(:b)
+    hash.store :bar, 3
+    assert_equal "3", hash[:bar]
+  end
 
-      assert hash[:a]
+  it "does not loop when refering to itself" do
+    @hash = CastedHash.new({:a => 1}, lambda {|x| @hash[:a] + 1 })
+    assert_equal 2, @hash[:a]
+  end
 
-      assert hash.casted?(:a)
-      assert !hash.casted?(:b)
-    end
+  it "casts when expected" do
+    hash = CastedHash.new({:a => 1, :b => 2}, lambda {|x| x + 10 })
+    assert !hash.casted?(:a)
+    assert !hash.casted?(:b)
 
-    it "should respond to any? and empty?" do
-      hash = CastedHash.new({}, lambda {})
-      assert hash.empty?
-      assert !hash.any?
+    assert_equal 11, hash[:a]
 
-      hash = CastedHash.new({:foo => "bar"}, lambda {})
-      assert !hash.empty?
-      assert hash.any?
-    end
+    assert hash.casted?(:a)
+    assert !hash.casted?(:b)
+  end
 
-    it "should only cast once" do
-      hash = CastedHash.new({:foo => 1}, lambda { |x| x + 1 })
+  it "responds to any? and empty?" do
+    hash = CastedHash.new({}, lambda {})
+    assert hash.empty?
+    assert !hash.any?
 
-      assert_equal 2, hash[:foo]
-      assert_equal 2, hash[:foo]
+    hash = CastedHash.new({:foo => "bar"}, lambda {})
+    assert !hash.empty?
+    assert hash.any?
+  end
 
-      hash[:bar] = 123
-      assert_equal 124, hash[:bar]
-      assert_equal 124, hash[:bar]
-    end
+  it "only casts once" do
+    hash = CastedHash.new({:foo => 1}, lambda { |x| x + 1 })
 
-    it "should be able to fetch all casted values" do
-      hash = CastedHash.new({:a => 1, :b => 10, :c => 100}, lambda { |x| x * 10 })
-      assert_equal [10, 100, 1000], hash.values
-    end
+    assert_equal 2, hash[:foo]
+    assert_equal 2, hash[:foo]
 
-    it "should inspect casted values" do
-      hash = CastedHash.new({}, lambda { |x| "foobar" })
+    hash[:bar] = 123
+    assert_equal 124, hash[:bar]
+    assert_equal 124, hash[:bar]
+  end
 
-      assert_equal("#<CastedHash hash={}>", hash.inspect)
+  it "is able to fetch all casted values" do
+    hash = CastedHash.new({:a => 1, :b => 10, :c => 100}, lambda { |x| x * 10 })
+    assert_equal [10, 100, 1000], hash.values
+  end
 
-      hash[:bar] = "foo"
-      assert_equal("#<CastedHash hash={\"bar\"=>\"<foo>\"}>", hash.inspect) # not yet casted
-      assert_equal("foobar", hash[:bar])
-      assert_equal("#<CastedHash hash={\"bar\"=>\"foobar\"}>", hash.inspect)
+  it "loops through casted values" do
+    hash = CastedHash.new({:a => 1, :b => 2}, lambda { |x| "processed: #{x}" })
+    map = []
 
-      hash = CastedHash.new({:foo => "bar"}, lambda { |x| "foobar" })
-      assert_equal("#<CastedHash hash={\"foo\"=>\"<bar>\"}>", hash.inspect) # not yet casted
-      assert_equal("foobar", hash[:foo])
-      assert_equal("#<CastedHash hash={\"foo\"=>\"foobar\"}>", hash.inspect)
+    hash.each do |key, value|
+      map << value
     end
 
-    it "should loop through casted values" do
-      hash = CastedHash.new({:a => 1, :b => 2}, lambda { |x| "processed: #{x}" })
-      map = []
-
-      hash.each do |key, value|
-        map << value
-      end
+    assert_equal ["processed: 1", "processed: 2"], map
+  end
 
-      assert_equal ["processed: 1", "processed: 2"], map
-    end
+  it "deletes values" do
+    hash = CastedHash.new({:a => 1, :b => 2}, lambda {|x| x + 10 })
+    hash.delete(:b)
+    assert_equal({"a" => 11}, hash.casted_hash)
+  end
 
-    it "should delete values" do
+  describe "merge" do
+    it "merges values" do
       hash = CastedHash.new({:a => 1, :b => 2}, lambda {|x| x + 10 })
-      hash.delete(:b)
-      assert_equal({"a" => 11}, hash.casted_hash)
-    end
-
-    describe "merge" do
-      it "should merge values" do
-        hash = CastedHash.new({:a => 1, :b => 2}, lambda {|x| x + 10 })
-        assert_equal 11, hash[:a]
-        assert_equal 12, hash[:b]
-
-        hash = hash.merge({:a => 3})
+      assert_equal 11, hash[:a]
+      assert_equal 12, hash[:b]
 
-        assert_equal 13, hash[:a]
-        assert_equal 12, hash[:b]
+      hash = hash.merge({:a => 3})
 
-        assert_equal hash, hash.merge({})
-      end
+      assert_equal 13, hash[:a]
+      assert_equal 12, hash[:b]
 
-      it "should take over scope when merging two casted hashes" do
-        hash1 = CastedHash.new({:a => 1, :b => 2}, lambda {|x| x + 10 })
-        hash2 = CastedHash.new({:c => 3, :d => 4}, lambda {|x| x + 100 })
-
-        assert_equal 11, hash1[:a]
-        assert_equal 12, hash1[:b]
-        assert hash1.casted?(:a)
-        assert hash1.casted?(:b)
-
-        cast_proc1_object_id = hash1.cast_proc.object_id
-        assert_equal [hash1.object_id], hash1.send(:raw).values.map{|v|v.casted_hash.object_id}.uniq
-
-        hash3 = hash1.merge hash2
+      assert_equal hash, hash.merge({})
+    end
 
-        assert_equal [hash3.object_id], hash3.send(:raw).values.map{|v|v.casted_hash.object_id}.uniq
-        assert_equal hash3.cast_proc.object_id, cast_proc1_object_id
+    it "leaves original hash alone" do
+      hash = CastedHash.new({:a => 1, :b => 2}, lambda {|x| x + 10 })
+      new_hash = hash.merge({:c => 3})
 
-        assert_equal ["a", "b", "c", "d"], hash3.keys
-        assert hash3.casted?(:a)
-        assert hash3.casted?(:b)
-        assert !hash3.casted?(:c)
-        assert !hash3.casted?(:d)
+      assert_equal ['a', 'b', 'c'], new_hash.keys
+      assert_equal ['a', 'b'], hash.keys
+    end
 
-        assert_equal 11, hash3[:a]
-        assert_equal 12, hash3[:b]
-        assert_equal 13, hash3[:c]
-        assert_equal 14, hash3[:d]
-      end
+    it "takes over scope when merging two casted hashes" do
+      hash1 = CastedHash.new({:a => 1, :b => 2}, lambda {|x| x + 10 })
+      hash2 = CastedHash.new({:a => 2, :c => 3, :d => 4}, lambda {|x| x + 100 })
 
-      it "should not cast all values when merging hashes" do
-        hash = CastedHash.new({:a => 1, :b => 2}, lambda {|x| x + 10 })
-        hash = hash.merge :c => 3
+      assert_equal 11, hash1[:a]
+      assert_equal 12, hash1[:b]
+      assert_equal 104, hash2[:d]
+      assert hash1.casted?(:a)
+      assert hash1.casted?(:b)
 
-        assert !hash.casted?(:a)
-        assert !hash.casted?(:b)
-        assert !hash.casted?(:c)
+      hash3 = hash1.merge hash2
 
-        other_hash = CastedHash.new({:c => 1, :d => 2}, lambda {|x| x + 10 })
-        hash = hash.merge other_hash
+      assert_equal ["a", "b", "c", "d"], hash3.keys
+      assert !hash3.casted?(:a)
+      assert hash3.casted?(:b)
+      assert !hash3.casted?(:c)
+      assert !hash3.casted?(:d)
 
-        assert !hash.casted?(:a)
-        assert !hash.casted?(:b)
-        assert !hash.casted?(:c)
-        assert !other_hash.casted?(:c)
-        assert !other_hash.casted?(:d)
-      end
+      assert_equal 12, hash3[:a]
+      assert_equal 12, hash3[:b]
+      assert_equal 13, hash3[:c]
+      assert_equal 114, hash3[:d] # casted twice
     end
 
-    describe "merge!" do
-      it "should merge! values" do
-        hash = CastedHash.new({:a => 1, :b => 2}, lambda {|x| x + 10 })
-        assert_equal 11, hash[:a]
-        assert_equal 12, hash[:b]
+    it "does not cast all values when merging hashes" do
+      hash = CastedHash.new({:a => 1, :b => 2}, lambda {|x| x + 10 })
+      hash = hash.merge :c => 3
 
-        hash.merge!({:a => 3})
+      assert !hash.casted?(:a)
+      assert !hash.casted?(:b)
+      assert !hash.casted?(:c)
 
-        assert_equal 13, hash[:a]
-        assert_equal 12, hash[:b]
-      end
+      other_hash = CastedHash.new({:c => 1, :d => 2}, lambda {|x| x + 10 })
+      hash = hash.merge other_hash
 
-      it "should take over scope when merging two casted hashes" do
-        hash1 = CastedHash.new({:a => 1, :b => 2}, lambda {|x| x + 10 })
-        hash2 = CastedHash.new({:c => 3, :d => 4}, lambda {|x| x + 100 })
+      assert !hash.casted?(:a)
+      assert !hash.casted?(:b)
+      assert !hash.casted?(:c)
+      assert !other_hash.casted?(:c)
+      assert !other_hash.casted?(:d)
+    end
+  end
 
-        assert_equal 11, hash1[:a]
-        assert_equal 12, hash1[:b]
-        assert hash1.casted?(:a)
-        assert hash1.casted?(:b)
+  describe "merge!" do
+    it "merge!s values" do
+      hash = CastedHash.new({:a => 1, :b => 2}, lambda {|x| x + 10 })
+      assert_equal 11, hash[:a]
+      assert_equal 12, hash[:b]
 
-        cast_proc1_object_id = hash1.cast_proc.object_id
-        assert_equal [hash1.object_id], hash1.send(:raw).values.map{|v|v.casted_hash.object_id}.uniq
+      hash.merge!({:a => 3})
 
-        hash1.merge! hash2
+      assert_equal 13, hash[:a]
+      assert_equal 12, hash[:b]
+    end
 
-        assert_equal [hash1.object_id], hash1.send(:raw).values.map{|v|v.casted_hash.object_id}.uniq
-        assert_equal hash1.cast_proc.object_id, cast_proc1_object_id
+    it "takes over scope when merging two casted hashes" do
+      hash1 = CastedHash.new({:a => 1, :b => 2}, lambda {|x| x + 10 })
+      hash2 = CastedHash.new({:c => 3, :d => 4}, lambda {|x| x + 100 })
 
-        assert_equal ["a", "b", "c", "d"], hash1.keys
-        assert hash1.casted?(:a)
-        assert hash1.casted?(:b)
-        assert !hash1.casted?(:c)
-        assert !hash1.casted?(:d)
+      assert_equal 11, hash1[:a]
+      assert_equal 12, hash1[:b]
+      assert hash1.casted?(:a)
+      assert hash1.casted?(:b)
 
-        assert_equal 11, hash1[:a]
-        assert_equal 12, hash1[:b]
-        assert_equal 13, hash1[:c]
-        assert_equal 14, hash1[:d]
-      end
+      hash1.merge! hash2
 
-      it "should not cast all values when merging hashes" do
-        hash = CastedHash.new({:a => 1, :b => 2}, lambda {|x| x + 10 })
-        hash.merge! :c => 3
+      assert_equal ["a", "b", "c", "d"], hash1.keys
+      assert hash1.casted?(:a)
+      assert hash1.casted?(:b)
+      assert !hash1.casted?(:c)
+      assert !hash1.casted?(:d)
 
-        assert !hash.casted?(:a)
-        assert !hash.casted?(:b)
-        assert !hash.casted?(:c)
+      assert_equal 11, hash1[:a]
+      assert_equal 12, hash1[:b]
+      assert_equal 13, hash1[:c]
+      assert_equal 14, hash1[:d]
+    end
 
-        other_hash = CastedHash.new({:c => 1, :d => 2}, lambda {|x| x + 10 })
-        hash.merge! other_hash
+    it "does not cast all values when merging hashes" do
+      hash = CastedHash.new({:a => 1, :b => 2}, lambda {|x| x + 10 })
+      hash.merge! :c => 3
 
-        assert !hash.casted?(:a)
-        assert !hash.casted?(:b)
-        assert !hash.casted?(:c)
-        assert !other_hash.casted?(:c)
-        assert !other_hash.casted?(:d)
-      end
-    end
+      assert !hash.casted?(:a)
+      assert !hash.casted?(:b)
+      assert !hash.casted?(:c)
 
-    it "should define a hash method" do
-      l = lambda {|x| x + 10 }
-      hash1 = CastedHash.new({:a => 1, :b => 2}, l)
-      hash2 = CastedHash.new({:a => 1, :b => 2}, l)
-      hash3 = CastedHash.new({:a => 1, :b => 2}, lambda {|x| x + 11 })
+      other_hash = CastedHash.new({:c => 1, :d => 2}, lambda {|x| x + 10 })
+      hash.merge! other_hash
 
-      assert_equal hash1.hash, hash2.hash
-      assert hash1.hash != hash3.hash
+      assert !hash.casted?(:a)
+      assert !hash.casted?(:b)
+      assert !hash.casted?(:c)
+      assert !other_hash.casted?(:c)
+      assert !other_hash.casted?(:d)
     end
+  end
 
-    it "should not add all requested values" do
-      hash = CastedHash.new({:a => 1, :b => 2}, lambda {|x|x})
-      assert_nil hash[:undefined_key]
-
-      assert_equal ["a", "b"], hash.keys
+  it "does not add all requested values" do
+    hash = CastedHash.new({:a => 1, :b => 2}, lambda {|x|x + 1})
+    assert_equal 2, hash.fetch(:a)
 
-      assert_raises(KeyError) do
-        hash.fetch('another_undefined_key')
-      end
+    assert_nil hash[:undefined_key]
+    assert_equal ["a", "b"], hash.keys
 
-      assert_equal '123', hash.fetch('another_undefined_key', '123')
-      assert_equal ["a", "b"], hash.keys
+    assert_raises(KeyError) do
+      hash.fetch('another_undefined_key')
     end
 
+    assert_equal '123', hash.fetch('another_undefined_key', '123')
+    assert_equal ["a", "b"], hash.keys
   end
+
 end

metadata

@@ -1,97 +1,69 @@
 --- !ruby/object:Gem::Specification
 name: casted_hash
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Stephan Kaag
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-19 00:00:00.000000000 Z
+date: 2014-01-24 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: equalizer
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: 0.0.7
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: 0.0.7
-- !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '5'
 - !ruby/object:Gem::Dependency
   name: coveralls
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: A casted hash
@@ -101,15 +73,13 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - casted_hash.gemspec
 - lib/casted_hash.rb
-- lib/casted_hash/value.rb
-- lib/casted_hash/version.rb
 - test/helper.rb
 - test/test_casted_hash.rb
 homepage: 
@@ -121,17 +91,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.2.0
 signing_key: 
 specification_version: 4
 summary: A casted hash

data/lib/casted_hash/value.rb

@@ -1,33 +0,0 @@
-class CastedHash
-  class Value
-    include Equalizer.new(:value)
-    attr_reader :value
-    attr_accessor :casted_hash
-
-    def initialize(value, casted_hash)
-      @value = value
-      @casted_hash = casted_hash
-    end
-
-    def casted_value
-      cast!
-      @value
-    end
-
-    def casted?
-      !!@casted
-    end
-
-    def cast!
-      return if casted?
-      raise SystemStackError, "Cannot cast value that is currently being cast" if @casting
-
-      @casting = true
-
-      @value = casted_hash.cast_proc.call(value)
-    ensure
-      @casted = true
-      @casting = false
-    end
-  end
-end

data/lib/casted_hash/version.rb

@@ -1,3 +0,0 @@
-class CastedHash
-  VERSION = "0.1.4"
-end