attribute-kit 0.1.4 → 0.2.0

data/Gemfile

@@ -1,6 +1,7 @@
 source "http://rubygems.org"
 
 group :development do
+  gem 'yajl-ruby', '>= 0.8.2', :require => 'yajl/json_gem'
   gem "rspec", "~> 2.3.0"
   gem "bundler", "~> 1.0.0"
   gem "jeweler", "~> 1.6.4"

data/Gemfile.lock

@@ -18,6 +18,7 @@ GEM
     rspec-expectations (2.3.0)
       diff-lcs (~> 1.1.2)
     rspec-mocks (2.3.0)
+    yajl-ruby (0.8.2)
     yard (0.7.2)
 
 PLATFORMS
@@ -29,4 +30,5 @@ DEPENDENCIES
   rcov
   rdiscount
   rspec (~> 2.3.0)
+  yajl-ruby (>= 0.8.2)
   yard

data/README.markdown

@@ -2,8 +2,101 @@
 
 Tools for attribute tracking like Hashes with dirty tracking and events, for building hybrid models and generally going beyond what's provided by your local ORM/DRM, while allowing you to expand what you can do with them, live without them, or roll your own
 
+## Rationale
+
+ORM and DRM frameworks implement many of the same concepts that this kit makes available, but they don't generally expose them
+as smaller pieces of functionality that you can consume and mix in as you please.  It is also difficult to get more ORMs to
+'play nice' with columns that are really schemaless hashes, because they just aren't meant to handle such things.  While DRMs
+are generally designed to work with schemaless data, there are times when you need to have both behaviors.
+
+The idea behind building AttributeKit was to make these concepts available in an ad-hoc format, so that classes could either
+inherit or mix in the behaviors that they want and/or need, without the overhead of the pieces they don't want or need.  This
+all stemmed from a side project that had a need for exactly that...ORM/DRM-like behavior, without the extra weight of actually
+using one of the ORMs or DRMs on the market and then extending them to handle both types of data, in two separate data stores.
+
+## Basic usage
+
+    attributes = AttributeKit::AttributeHash.new              #=> {}
+
+    attributes.empty?                                         #=> true
+    attributes.dirty?                                         #=> false
+    attributes[:foo] = 'bar'                                  #=> 'bar'
+    attributes.dirty?                                         #=> true
+    attributes.dirty_keys                                     #=> [:foo]
+    attributes                                                #=> {:foo=>"bar"}
+
+    attributes[:bar] = 5                                      #=> 5
+    attributes                                                #=> {:foo=>"bar", :bar=>5}
+    attributes.dirty_keys                                     #=> [:foo, :bar]
+    attributes.deleted_keys                                   #=> []
+
+    attributes.delete(:foo)                                   #=> "bar"
+    attributes.dirty_keys                                     #=> [:bar, :foo]
+    attributes.deleted_keys                                   #=> [:foo]
+
+    attributes.clean_attributes { |dirty_attrs|               # Deleted: foo    Nil value: true
+      dirty_attrs.each_pair do |k,v|                          # Changed: bar    New value: 5
+        case v[0]
+          when :changed                                       #=> {:foo=>[:deleted, nil], :bar=>[:changed, 5]}
+            puts "Changed: #{k}    New value: #{v[1]}"
+          when :deleted                                       # NOTE: The lack of a return value in this block
+            puts "Deleted: #{k}    Nil value: #{v[1].nil?}"   #       means that dirty_attrs was returned by both
+        end                                                   #       the block and the method itself.  You may
+      end                                                     #       want to write a block to return true if it
+    }                                                         #       succeeds, and the dirty_attrs hash if it
+                                                              #       fails, so you can pass the hash to a
+                                                              #       method that can retry later.
+
+## Serializing and deserializing a Hash with JSON
+
+    class JHash < Hash
+      include AttributeKit::JSONSerializableHash
+    end
+
+    attr_hash = JHash.new                                    #=> {}
+    attr_hash[:foo] = 'bar'                                  #=> 'bar'
+    attr_hash[:bar] = 5                                      #=> 5
+    attr_hash                                                #=> {:foo=>"bar", :bar=>5}
+
+    j = attr_hash.to_json                                    #=> "{\"foo\":\"bar\",\"bar\":5}"
+    new_hash = JHash.new                                     #=> {}
+    new_hash.from_json(j)                                    #=> {:foo=>"bar", :bar=>5}
+    new_hash                                                 #=> {:foo=>"bar", :bar=>5}
+    new_hash.clear                                           #=> {}
+
+    f = attr_hash.get_json(:foo)                             #=> "{\"foo\":\"bar\"}"
+    new_hash[:bar] = 5                                       #=> 5
+    new_hash.store_json(f)                                   #=> {:bar=>5, :foo=>"bar"}
+    new_hash                                                 #=> {:bar=>5, :foo=>"bar"}
+
+## Serializing and deserializing an AttributeHash with JSON
+
+    class MyHash < AttributeKit::AttributeHash
+      include AttributeKit::JSONSerializableHash
+    end
+
+    attr_hash = MyHash.new                                   #=> {}
+    attr_hash.empty?                                         #=> true
+    attr_hash.dirty?                                         #=> false
+    attr_hash[:foo] = 'bar'                                  #=> 'bar'
+    attr_hash.dirty?                                         #=> true
+    attr_hash.dirty_keys                                     #=> [:foo]
+    attr_hash[:bar] = 5                                      #=> 5
+    attr_hash                                                #=> {:foo=>"bar", :bar=>5}
+
+    j = attr_hash.to_json                                    #=> "{\"foo\":\"bar\",\"bar\":5}"
+    new_hash = MyHash.new                                    #=> {}
+    new_hash.from_json(j)                                    #=> {:foo=>"bar", :bar=>5}
+    new_hash                                                 #=> {:foo=>"bar", :bar=>5}
+    new_hash.clear                                           #=> {}
+
+    f = attr_hash.get_json(:foo)                             #=> "{\"foo\":\"bar\"}"
+    new_hash[:bar] = 5                                       #=> 5
+    new_hash.store_json(f)                                   #=> {:bar=>5, :foo=>"bar"}
+    new_hash                                                 #=> {:bar=>5, :foo=>"bar"}
+
 ## Contributing to attribute-kit
- 
+
 * Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
 * Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
 * Fork the project

data/VERSION

@@ -1 +1 @@
-0.1.4
+0.2.0

data/lib/attribute-kit/attribute-kit.rb

@@ -1 +1,2 @@
 require 'attribute-kit/attribute_hash'
+require 'attribute-kit/json_serializable_hash'

data/lib/attribute-kit/attribute_hash.rb

@@ -13,6 +13,39 @@
 module AttributeKit
 
   # AttributeHash inherits from and extends Hash, to provide tracking of attribute status (changed/deleted keys).
+  #
+  # @example Basic usage
+  #   attributes = AttributeKit::AttributeHash.new              #=> {}
+  #
+  #   attributes.empty?                                         #=> true
+  #   attributes.dirty?                                         #=> false
+  #   attributes[:foo] = 'bar'                                  #=> 'bar'
+  #   attributes.dirty?                                         #=> true
+  #   attributes.dirty_keys                                     #=> [:foo]
+  #   attributes                                                #=> {:foo=>"bar"}
+  #
+  #   attributes[:bar] = 5                                      #=> 5
+  #   attributes                                                #=> {:foo=>"bar", :bar=>5}
+  #   attributes.dirty_keys                                     #=> [:foo, :bar]
+  #   attributes.deleted_keys                                   #=> []
+  #
+  #   attributes.delete(:foo)                                   #=> "bar"
+  #   attributes.dirty_keys                                     #=> [:bar, :foo]
+  #   attributes.deleted_keys                                   #=> [:foo]
+  #
+  #   attributes.clean_attributes { |dirty_attrs|               # Deleted: foo    Nil value: true
+  #     dirty_attrs.each_pair do |k,v|                          # Changed: bar    New value: 5
+  #       case v[0]
+  #         when :changed                                       #=> {:foo=>[:deleted, nil], :bar=>[:changed, 5]}
+  #           puts "Changed: #{k}    New value: #{v[1]}"
+  #         when :deleted                                       # NOTE: The lack of a return value in this block
+  #           puts "Deleted: #{k}    Nil value: #{v[1].nil?}"   #       means that dirty_attrs was returned by both
+  #       end                                                   #       the block and the method itself.  You may
+  #     end                                                     #       want to write a block to return true if it
+  #   }                                                         #       succeeds, and the dirty_attrs hash if it
+  #                                                             #       fails, so you can pass the hash to a
+  #                                                             #       method that can retry later.
+  #
   class AttributeHash < Hash
 
     # @visibility private
@@ -32,6 +65,7 @@ module AttributeKit
     private_class_method :cond_deletion_method
 
     # Creates a new instance, using identical syntax to Hash
+    # @return [AttributeHash] new instance
     # @see Hash#new
     def initialize(*args)
       super(*args)
@@ -155,7 +189,8 @@ module AttributeKit
       [k,v]
     end
 
-    # Clear all contents of the object.
+    # Clear all contents of the object and mark it as dirty.  An array of all removed keys is available via #deleted_keys.
+    # @return [AttributeHash] an empty AttributeHash
     # @see Hash#clear
     def clear
       @deleted_keys += self.keys
@@ -187,6 +222,13 @@ module AttributeKit
     # that have changed since the object was last marked clean.  Marks the object as clean when it compiles
     # the list of keys that have been modified.
     # @param [Block] block to execute with hash of modified keys, actions, and values
+    # @yield [dirty_attrs] block is executed once, with a hash of dirty attributes
+    # @yieldparam [Hash] dirty_attrs the hash of changed/deleted attributes with the modified key as the key and a value
+    #   of an array in the format: [ACTION, VALUE] where ACTION is either :changed or :deleted, and VALUE is either the
+    #   new value or nil if the attribute is deleted.  A nil value does NOT mean the attribute is deleted if the ACTION
+    #   is :changed, it means the value was actually set to nil
+    # @yieldreturn [Object] any value the block returns bubbles up, otherwise
+    # @return [Object] the return value of the block is returned
     def clean_attributes(&block)
       if !@dirty_keys.empty?
         dirty_attrs = {}

data/lib/attribute-kit/json_serializable_hash.rb

@@ -0,0 +1,107 @@
+begin
+  require 'yajl/json_gem'
+rescue LoadError
+  begin
+    require 'json'
+  rescue LoadError
+    require 'json_pure'
+  end
+end
+
+module AttributeKit
+
+  # JSONSerializableHash adds a set of methods to manage serialization and deserialization of hashes and Hash decendants
+  # in a consistent manner.  By default, the methods symbolize the keys when they are deserialized, which greatly
+  # improves performance and also provides consistency in how keys appear both in JSON and in the hash.
+  #                                                                                            
+  # @example Serializing and deserializing a Hash with JSON
+  #
+  #  class JHash < Hash
+  #    include AttributeKit::JSONSerializableHash
+  #  end
+  #
+  #  attr_hash = JHash.new                                    #=> {}
+  #  attr_hash[:foo] = 'bar'                                  #=> 'bar'
+  #  attr_hash[:bar] = 5                                      #=> 5
+  #  attr_hash                                                #=> {:foo=>"bar", :bar=>5}
+  #
+  #  j = attr_hash.to_json                                    #=> "{\"foo\":\"bar\",\"bar\":5}"
+  #  new_hash = JHash.new                                     #=> {}
+  #  new_hash.from_json(j)                                    #=> {:foo=>"bar", :bar=>5}
+  #  new_hash                                                 #=> {:foo=>"bar", :bar=>5}
+  #  new_hash.clear                                           #=> {}
+  #
+  #  f = attr_hash.get_json(:foo)                             #=> "{\"foo\":\"bar\"}"
+  #  new_hash[:bar] = 5                                       #=> 5
+  #  new_hash.store_json(f)                                   #=> {:bar=>5, :foo=>"bar"}
+  #  new_hash                                                 #=> {:bar=>5, :foo=>"bar"}
+  #
+  #
+  # @example Serializing and deserializing an AttributeHash with JSON
+  #
+  #  class MyHash < AttributeKit::AttributeHash
+  #    include AttributeKit::JSONSerializableHash
+  #  end
+  #
+  #  attr_hash = MyHash.new                                   #=> {}
+  #  attr_hash.empty?                                         #=> true
+  #  attr_hash.dirty?                                         #=> false
+  #  attr_hash[:foo] = 'bar'                                  #=> 'bar'
+  #  attr_hash.dirty?                                         #=> true
+  #  attr_hash.dirty_keys                                     #=> [:foo]
+  #  attr_hash[:bar] = 5                                      #=> 5
+  #  attr_hash                                                #=> {:foo=>"bar", :bar=>5}
+  #
+  #  j = attr_hash.to_json                                    #=> "{\"foo\":\"bar\",\"bar\":5}"
+  #  new_hash = MyHash.new                                    #=> {}
+  #  new_hash.from_json(j)                                    #=> {:foo=>"bar", :bar=>5}
+  #  new_hash                                                 #=> {:foo=>"bar", :bar=>5}
+  #  new_hash.clear                                           #=> {}
+  #
+  #  f = attr_hash.get_json(:foo)                             #=> "{\"foo\":\"bar\"}"
+  #  new_hash[:bar] = 5                                       #=> 5
+  #  new_hash.store_json(f)                                   #=> {:bar=>5, :foo=>"bar"}
+  #  new_hash                                                 #=> {:bar=>5, :foo=>"bar"}
+  #
+  module JSONSerializableHash
+
+    # Serializes the entire hash contents into a JSON string.
+    # @param [Hash] opts A hash of options to be passed to the JSON generator, empty by default
+    # @return [String] A JSON encoded string describing the contents of the hash
+    def to_json(opts = {})
+      JSON.generate(self, opts)
+    end
+
+    # Deserializes hash contents from a JSON string, replacing the contents of the hash if they already exist
+    # @param [String] json A JSON formatted string to be parsed and assigned as the contents of the hash
+    # @param [Hash] opts A hash of options to be passed to the JSON generator, :symbolize_keys => true is set by default
+    # @return [Hash] The new contents of the hash
+    def from_json(json, opts = {})
+      defaults = {
+          :symbolize_keys => true
+      }
+      opts.merge!(defaults){ |key, param, default| param }
+      self.replace(JSON.parse(json, opts))
+    end
+
+    # Serializes a single key-value pair from the hash contents into a JSON string.
+    # @param [Symbol] key The key for the key-value pair to retrieve and encode
+    # @param [Hash] opts A hash of options to be passed to the JSON generator, empty by default
+    # @return [String] A JSON encoded string describing the key-value pair
+    def get_json(key, opts = {})
+      JSON.generate({key => self[key]}, opts)
+    end
+
+    # Deserializes hash contents from a JSON string, merging the contents with any contents of the hash that already exist
+    # @param [String] json A JSON formatted string to be parsed and update the contents of the hash with
+    # @param [Hash] opts A hash of options to be passed to the JSON generator, :symbolize_keys => true is set by default
+    # @return [Hash] The new contents of the hash
+    def store_json(json, opts = {})
+      defaults = {
+          :symbolize_keys => true
+      }
+      opts.merge!(defaults){ |key, param, default| param }
+      self.update(JSON.parse(json, opts))
+    end
+  end
+end

data/spec/AttributeKit/json_serializable_hash_spec.rb

@@ -0,0 +1,98 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+class JSONSerializableHashTestHash < Hash
+  include AttributeKit::JSONSerializableHash
+end
+
+describe "AttributeKit" do
+  context '::JSONSerializableHash' do
+    it 'should load' do
+      defined?(AttributeKit::JSONSerializableHash).should == 'constant'
+    end
+
+    before(:each) do
+      @hash = JSONSerializableHashTestHash.new
+      @hash[:a] = 'a'
+      @hash[:b] = 2
+      @hash[:c] = nil
+      @hash[:float] = 3.14
+      @hash[:integer] = 5.to_i
+    end
+
+    context '#to_json' do
+      it 'should serialize the contents of the hash to JSON' do
+        json = @hash.to_json
+        json.should == '{"a":"a","b":2,"c":null,"float":3.14,"integer":5}'
+      end
+    end
+
+    context '#from_json' do
+      before(:each) do
+        @new_hash = JSONSerializableHashTestHash.new
+        @new_hash.from_json('{"a":"a","b":2,"c":null,"float":3.14,"integer":5}')
+      end
+
+      it 'should use symbols for the keys instead of strings or other objects' do
+        @new_hash.has_key?(:a).should be_true
+        @new_hash.has_key?('a').should be_false
+      end
+
+      it 'should deserialize JSON into the correct contents of the hash' do
+        @new_hash.length.should == 5
+        @new_hash[:a].should == 'a'
+        @new_hash[:b].should == 2
+        @new_hash[:c].should be_nil
+        @new_hash[:float].should == 3.14
+        @new_hash[:integer].should == 5
+      end
+    end
+
+    context '#get_json' do
+      it 'should retrieve a key-value pair with a String value and JSON encode it' do
+        json = @hash.get_json(:a)
+        json.should == '{"a":"a"}'
+      end
+
+      it 'should retrieve a key-value pair with a Fixnum value and JSON encode it' do
+        json = @hash.get_json(:b)
+        json.should == '{"b":2}'
+      end
+
+      it 'should retrieve a key-value pair with a Nil value and JSON encode it' do
+        json = @hash.get_json(:c)
+        json.should == '{"c":null}'
+      end
+
+      it 'should retrieve a key-value pair with a Float value and JSON encode it' do
+        json = @hash.get_json(:float)
+        json.should == '{"float":3.14}'
+      end
+
+      it 'should retrieve a key-value pair with an Integer value and JSON encode it' do
+        json = @hash.get_json(:integer)
+        json.should == '{"integer":5}'
+      end
+    end
+
+    context '#store_json' do
+      before(:each) do
+        @new_hash = JSONSerializableHashTestHash.new
+        @new_hash.store_json('{"a":"a"}')
+      end
+
+      it 'should use symbols for the keys instead of strings or other objects' do
+        @new_hash.has_key?(:a).should be_true
+        @new_hash.has_key?('a').should be_false
+      end
+
+      it 'should parse the provided JSON and store it as a key-value pair' do
+        @new_hash[:a].should == 'a'
+      end
+
+      it 'should parse the provided JSON and replace an existing key-value pair' do
+        @new_hash.store_json('{"a":"b"}')
+        @new_hash[:a].should == 'b'
+      end
+    end
+  end
+end

data/spec/attribute-kit_spec.rb

@@ -5,8 +5,12 @@ describe "AttributeKit" do
     defined?(AttributeKit).should == 'constant'
   end
 
-  describe "::AttributeHash" do
-    describe '#new' do
+  context "::AttributeHash" do
+    it 'loads' do
+      defined?(AttributeKit::AttributeHash).should == 'constant'
+    end
+
+    context '#new' do
       it "should return an empty AttributeHash when initialized without arguments" do
         test_hash = AttributeKit::AttributeHash.new
         test_hash.empty?.should be_true
@@ -32,7 +36,7 @@ describe "AttributeKit" do
       end
     end
 
-    describe '#[]=' do
+    context '#[]=' do
       before(:each) do
         @test_hash = AttributeKit::AttributeHash.new
         @test_hash[:blue] = 'blue'
@@ -61,7 +65,7 @@ describe "AttributeKit" do
       end
     end
 
-    describe '#store' do
+    context '#store' do
       before(:each) do
         @test_hash = AttributeKit::AttributeHash.new
         @test_hash.store(:blue, 'blue')
@@ -86,7 +90,7 @@ describe "AttributeKit" do
       end
     end
 
-    describe '#[]' do
+    context '#[]' do
       before(:each) do
         @test_hash = AttributeKit::AttributeHash.new('red')
         @test_hash[:blue] = 'blue'
@@ -103,7 +107,7 @@ describe "AttributeKit" do
       end
     end
 
-    describe '#delete' do
+    context '#delete' do
       before(:each) do
         @test_hash = AttributeKit::AttributeHash.new
         @test_hash[:blue] = 'blue'
@@ -133,7 +137,7 @@ describe "AttributeKit" do
       end
     end
 
-    describe '#delete_if' do
+    context '#delete_if' do
       before(:each) do
         @test_hash = AttributeKit::AttributeHash.new
         @test_hash[:blue] = 'blue'
@@ -176,7 +180,7 @@ describe "AttributeKit" do
       end
     end
 
-    describe '#keep_if' do
+    context '#keep_if' do
       before(:each) do
         @test_hash = AttributeKit::AttributeHash.new
         @test_hash[:blue] = 'blue'
@@ -219,7 +223,7 @@ describe "AttributeKit" do
       end
     end
 
-    describe '#reject!' do
+    context '#reject!' do
       before(:each) do
         @test_hash = AttributeKit::AttributeHash.new
         @test_hash[:blue] = 'blue'
@@ -270,7 +274,7 @@ describe "AttributeKit" do
       end
     end
 
-    describe '#select!' do
+    context '#select!' do
       before(:each) do
         @test_hash = AttributeKit::AttributeHash.new
         @test_hash[:blue] = 'blue'
@@ -321,7 +325,7 @@ describe "AttributeKit" do
       end
     end
 
-    describe "#replace" do
+    context "#replace" do
       before(:each) do
         @test_hash = AttributeKit::AttributeHash.new
         @test_hash[:blue] = 'blue'
@@ -370,7 +374,7 @@ describe "AttributeKit" do
       end
     end
 
-    describe "#merge!" do
+    context "#merge!" do
       before(:each) do
         @test_hash = AttributeKit::AttributeHash.new
         @test_hash[:blue] = 'blue'
@@ -433,7 +437,7 @@ describe "AttributeKit" do
       end
     end
 
-    describe "#update" do
+    context "#update" do
       before(:each) do
         @test_hash = AttributeKit::AttributeHash.new
         @test_hash[:blue] = 'blue'
@@ -496,7 +500,7 @@ describe "AttributeKit" do
       end
     end
 
-    describe "#shift" do
+    context "#shift" do
       before(:each) do
         @test_hash = AttributeKit::AttributeHash.new
         @test_hash[:blue] = 'blue'
@@ -551,7 +555,7 @@ describe "AttributeKit" do
       end
     end
 
-    describe "#clear" do
+    context "#clear" do
       before(:each) do
         @test_hash = AttributeKit::AttributeHash.new
         @test_hash[:blue] = 'blue'
@@ -584,7 +588,7 @@ describe "AttributeKit" do
       end
     end
 
-    describe '#clean_attributes' do
+    context '#clean_attributes' do
       before(:each) do
         @test_hash = AttributeKit::AttributeHash.new
         @test_hash[:blue] = 'blue'

metadata

@@ -2,7 +2,7 @@
 name: attribute-kit
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors: 
 - Jonathan Mischo
@@ -10,55 +10,55 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-15 00:00:00 -07:00
+date: 2011-07-16 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: rspec
+  name: yajl-ruby
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version 
-        version: 2.3.0
+        version: 0.8.2
   type: :development
   prerelease: false
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: bundler
+  name: rspec
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        version: 1.0.0
+        version: 2.3.0
   type: :development
   prerelease: false
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: jeweler
+  name: bundler
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        version: 1.6.4
+        version: 1.0.0
   type: :development
   prerelease: false
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
-  name: rcov
+  name: jeweler
   requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
-        version: "0"
+        version: 1.6.4
   type: :development
   prerelease: false
   version_requirements: *id004
 - !ruby/object:Gem::Dependency 
-  name: yard
+  name: rcov
   requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -69,7 +69,7 @@ dependencies:
   prerelease: false
   version_requirements: *id005
 - !ruby/object:Gem::Dependency 
-  name: rdiscount
+  name: yard
   requirement: &id006 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -79,6 +79,17 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: rdiscount
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id007
 description: Tools for attribute tracking like Hashes with dirty tracking and events, for building hybrid models and generally going beyond what's provided by your local ORM/DRM, while allowing you to expand what you can do with them, live without them, or roll your own
 email: jon.mischo@gmail.com
 executables: []
@@ -98,6 +109,8 @@ files:
 - lib/attribute-kit.rb
 - lib/attribute-kit/attribute-kit.rb
 - lib/attribute-kit/attribute_hash.rb
+- lib/attribute-kit/json_serializable_hash.rb
+- spec/AttributeKit/json_serializable_hash_spec.rb
 - spec/attribute-kit_spec.rb
 - spec/spec_helper.rb
 has_rdoc: true
@@ -114,7 +127,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 464791598370222701
+      hash: -293996943625060104
       segments: 
       - 0
       version: "0"