json_record 1.0.0

data/spec/serialized_spec.rb

@@ -0,0 +1,430 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+describe JsonRecord::Serialized do
+  before(:all) do
+    JsonRecord::Test.create_tables
+  end
+  
+  after(:all) do
+    JsonRecord::Test.drop_tables
+  end
+  
+  it "should have accessors for json attributes" do
+    model = JsonRecord::Test::Model.new
+    model.name.should == nil
+    model.name = "test"
+    model.name.should == "test"
+  end
+  
+  it "should convert blank values to nil" do
+    model = JsonRecord::Test::Model.new
+    model.name = ""
+    model.name.should == nil
+  end
+  
+  it "should convert values to strings" do
+    model = JsonRecord::Test::Model.new
+    model.name = 1
+    model.name.should == "1"
+  end
+  
+  it "should convert values to integers" do
+    model = JsonRecord::Test::Model.new
+    model.value = "1"
+    model.value.should == 1
+  end
+  
+  it "should convert values to floats" do
+    model = JsonRecord::Test::Model.new
+    model.price = "1.2"
+    model.price.should == 1.2
+  end
+  
+  it "should convert values to dates" do
+    model = JsonRecord::Test::Model.new
+    model.when = "2010-01-25"
+    model.when.should == Date.civil(2010, 1, 25)
+  end
+  
+  it "should convert values to times" do
+    model = JsonRecord::Test::Model.new
+    model.verified_at = "2010-01-25T12:00:15-6:00"
+    model.verified_at.should == Time.parse("2010-01-25T12:00:15-6:00").utc
+  end
+  
+  it "should convert values to datetimes" do
+    model = JsonRecord::Test::Model.new
+    model.viewed_at = "2010-01-25T12:00:15-6:00"
+    model.viewed_at.should == Time.parse("2010-01-25T12:00:15-6:00").utc
+  end
+  
+  it "should convert values to booleans" do
+    model = JsonRecord::Test::Model.new
+    model.verified = "true"
+    model.verified.should == true
+    model.verified = "false"
+    model.verified.should == false
+    model.verified = "1"
+    model.verified?.should == true
+    model.verified = "0"
+    model.verified?.should == false
+    model.verified = 1
+    model.verified?.should == true
+    model.verified = 0
+    model.verified?.should == false
+    model.verified = true
+    model.verified?.should == true
+    model.verified = nil
+    model.verified?.should == false
+  end
+  
+  it "should convert values to array" do
+    model = JsonRecord::Test::Model.new
+    model.strings = "a"
+    model.strings.should == ["a"]
+    model.strings = ["a", "b"]
+    model.strings.should == ["a", "b"]
+  end
+  
+  it "should convert a hash to an embedded document" do
+    model = JsonRecord::Test::Model.new
+    model.primary_trait = {:name => "thing", :value => "stuff"}
+    model.primary_trait.name.should == "thing"
+    model.primary_trait.value.should == "stuff"
+    model.primary_trait.attributes.should == {"name" => "thing", "value" => "stuff"}
+  end
+  
+  it "should not convert values that are already of the right class" do
+    model = JsonRecord::Test::Model.new
+    model.map = {:name => "thing", :value => "stuff"}
+    model.map.should == {:name => "thing", :value => "stuff"}
+  end
+  
+  it "should leave a value unconverted if it can't be converted" do
+    model = JsonRecord::Test::Model.new
+    model.value = "foo"
+    model.value.should == "foo"
+    model.price = "expensive"
+    model.price.should == "expensive"
+    model.when = "now"
+    model.when.should == "now"
+    model.verified_at = "2001-100-100"
+    model.verified_at.should == "2001-100-100"
+    model.viewed_at = "the year 2000"
+    model.viewed_at.should == "the year 2000"
+    lambda{model.primary_trait = "stuff"}.should raise_error(ArgumentError)
+  end
+  
+  it "should mix the json attributes into the regular attribute minus the json field itself" do
+    model = JsonRecord::Test::Model.new(:string_field => "test")
+    model.name = "test name"
+    model.value = 1
+    attrs = model.attributes
+    attrs["string_field"].should == "test"
+    attrs["name"].should == "test name"
+    attrs["value"].should == 1
+    attrs.should_not include("json")
+  end
+  
+  it "should use default values if a value has not been set" do
+    model = JsonRecord::Test::Model.new
+    model.value.should == 0
+    model.value = nil
+    model.value.should == 0
+  end
+  
+  it "should initialize json attributes with blank values" do
+    JsonRecord::Test::Model.new.attributes.should == {
+      "name"=>nil,
+      "price"=>nil,
+      "string_field"=>nil,
+      "verified_at"=>nil,
+      "viewed_at"=>nil,
+      "field_1"=>nil,
+      "field_2"=>nil,
+      "field_3"=>nil,
+      "field_4"=>nil,
+      "field_5"=>nil,
+      "traits"=>[],
+      "value"=>0,
+      "strings"=>[],
+      "map"=>{},
+      "verified"=>nil,
+      "when"=>nil,
+      "primary_trait"=>nil
+    }
+    JsonRecord::Test::Model.new.attributes["traits"].should be_a(JsonRecord::EmbeddedDocumentArray)
+  end
+  
+  it "should make default values automatically for arrays and hashes" do
+    model_1 = JsonRecord::Test::Model.new
+    model_1.strings << "val"
+    model_1.strings.should == ["val"]
+    model_1.map["val"] = 1
+    model_1.map.should == {"val" => 1}
+    model_2 = JsonRecord::Test::Model.new
+    model_2.strings << "val2"
+    model_2.strings.should == ["val2"]
+    model_2.map["val2"] = 2
+    model_2.map.should == {"val2" => 2}
+  end
+  
+  it "should allow mass assignment of json attributes" do
+    model = JsonRecord::Test::Model.new(:name => "test name", :string_field => "test string_field", :price => "1")
+    model.name.should == "test name"
+    model.string_field.should == "test string_field"
+    model.price.should == 1.0
+  end
+  
+  it "should deserialize JSON in a json field into the attributes" do
+    model = JsonRecord::Test::Model.new(:json => '{"name": "test name", "value": 1}')
+    model.name.should == "test name"
+    model.value.should == 1
+  end
+  
+  it "should reserialize json attributes into a JSON field" do
+    model = JsonRecord::Test::Model.new(:name => "test name", :value => 1)
+    model.save!
+    model = JsonRecord::Test::Model.find(model.id)
+    ActiveSupport::JSON.decode(model.json).should == {"name" => "test name", "value" => 1}
+    model.value = 2
+    model.save!
+    model = JsonRecord::Test::Model.find(model.id)
+    ActiveSupport::JSON.decode(model.json).should == {"name" => "test name", "value" => 2}
+  end
+  
+  it "should keep undefined keys found in the JSON field" do
+    model = JsonRecord::Test::Model.new(:json => '{"name": "test name", "value": 1, "unknown": "my value", "other stuff": {"value": 2}, "primary_trait": {"name": "n1", "stuff": true}}')
+    model.save!
+    model.value = 2
+    model.primary_trait.value = "beans"
+    ActiveSupport::JSON.decode(model.json).should == {"name" => "test name", "value" => 1, "unknown" => "my value", "other stuff" => {"value" => 2}, "primary_trait" => {"name" => "n1", "stuff" => true, "sub_traits" => []}}
+    model = JsonRecord::Test::Model.find(model.id)
+    ActiveSupport::JSON.decode(model.json).should == {"name" => "test name", "value" => 1, "unknown" => "my value", "other stuff" => {"value" => 2}, "primary_trait" => {"name" => "n1", "stuff" => true, "sub_traits" => []}}
+    model.attributes.should_not include("other stuff")
+    model.should_not respond_to(:other_stuff)
+    model.primary_trait.attributes.should_not include("stuff")
+  end
+  
+  it "should allow multiple JSON fields" do
+    model = JsonRecord::Test::Model.new(:name => "test name", :value => 1, :field_1 => "one")
+    model.save!
+    model = JsonRecord::Test::Model.find(model.id)
+    model.name.should == "test name"
+    model.field_1.should == "one"
+    ActiveSupport::JSON.decode(model.json).should == {"name" => "test name", "value" => 1}
+    ActiveSupport::JSON.decode(Zlib::Inflate.inflate(model.compressed_json)).should == {"field_1" => "one"}    
+  end
+  
+  it "should have json attributes inherited by subclasses" do
+    model = JsonRecord::Test::Model.new(:name => "test name")
+    model.respond_to?(:another_field).should == false
+    sub_model = JsonRecord::Test::SubModel.new(:name => "test name", :another_field => "woo")
+    sub_model.another_field.should == "woo"
+    sub_model.save!
+    sub_model = JsonRecord::Test::SubModel.find(sub_model.id)
+    sub_model.another_field.should == "woo"
+  end
+  
+  it "should track changes on json attributes" do
+    model = JsonRecord::Test::Model.create!(:name => "test name")
+    model.changes.should == {}
+    model.name = "new name"
+    model.value = 1
+    model.changes.should == {"name" => ["test name", "new name"], "value" => [0, 1]}
+    model.name_changed?.should == true
+    model.name_was.should == "test name"
+    model.name_change.should == ["test name", "new name"]
+    model.name = "test name"
+    model.changes.should == {"value" => [0, 1]}
+    model.name_changed?.should == false
+    model.name_was.should == "test name"
+    model.name_change.should == nil
+  end
+  
+  it "should validate the presence of a json attribute" do
+    model = JsonRecord::Test::Model.new
+    model.valid?.should == false
+    model.errors.on(:name).should_not == nil
+    model.name = "woo"
+    model.valid?.should == true
+  end
+  
+  it "should validate the length of a json attribute" do
+    model = JsonRecord::Test::Model.new(:name => "this name value is way too long", :field_4 => "a", :field_5 => "b")
+    model.valid?.should == false
+    model.errors.on(:name).should_not == nil
+    model.errors.on(:field_4).should_not == nil
+    model.errors.on(:field_5).should_not == nil
+    model.name = "shorter name"
+    model.field_4 = "a much longer name that won't fit"
+    model.field_5 = "a much longer name that will fit because it is OK"
+    model.valid?.should == false
+    model.errors.on(:name).should == nil
+    model.errors.on(:field_4).should_not == nil
+    model.errors.on(:field_5).should == nil
+    model.field_4 = "just right"
+    model.valid?.should == true
+  end
+  
+  it "should validate the type of a json attribute" do
+    model = JsonRecord::Test::Model.new(:name => "test name", :value => "purple", :price => "free", :when => "2010-40-52", :verified_at => "2010-40-50T00:00:00", :viewed_at => "2010-02-01T00:90:00")
+    model.valid?.should == false
+    model.errors.on(:value).should_not == nil
+    model.errors.on(:price).should_not == nil
+    model.errors.on(:when).should_not == nil
+    model.errors.on(:verified_at).should_not == nil
+    model.errors.on(:viewed_at).should_not == nil
+    model.value = "1"
+    model.price = "100"
+    model.when = "2010-02-01"
+    model.verified_at = Time.now.to_s
+    model.viewed_at = DateTime.now.to_s
+    model.valid?.should == true
+  end
+  
+  it "should validate that a json attribute is in a range" do
+    model = JsonRecord::Test::Model.new(:name => "test name", :field_3 => "Z")
+    model.valid?.should == false
+    model.errors.on(:field_3).should_not == nil
+    model.field_3 = "B"
+    model.valid?.should == true
+  end
+  
+  it "should validate the format of a json attribute" do
+    model = JsonRecord::Test::Model.new(:name => "test name", :field_2 => "ABC")
+    model.valid?.should == false
+    model.errors.on(:field_2).should_not == nil
+    model.field_2 = "abc"
+    model.valid?.should == true
+  end
+  
+  it "should reload the json attributes when the record is reloaded" do
+    model = JsonRecord::Test::Model.new(:name => "test name", :field_1 => "ABC")
+    model.save!
+    model.name = "new name"
+    model.field_1 = "abc"
+    model.name.should == "new name"
+    model.field_1.should == "abc"
+    model.reload
+    model.name.should == "test name"
+    model.field_1.should == "ABC"
+  end
+  
+  it "should compress data if it is stored in a binary column" do
+    model = JsonRecord::Test::Model.new(:name => "test", :field_1 => "one", :field_2 => "two")
+    model.save!
+    model = JsonRecord::Test::Model.find(model.id)
+    model.field_1.should == "one"
+    model.field_2.should == "two"
+    ActiveSupport::JSON.decode(Zlib::Inflate.inflate(model.compressed_json)).should == {"field_1" => "one", "field_2" => "two"}
+  end
+  
+  it "should handle embedded documents" do
+    model = JsonRecord::Test::Model.new(:name => "test", :primary_trait => {:name => "primary", :value => "primary value"})
+    model.primary_trait.name.should == "primary"
+    model.primary_trait.value.should == "primary value"
+    model.primary_trait.parent.should == model
+    
+    model.save!
+    model = JsonRecord::Test::Model.find(model.id)
+    model.primary_trait.name.should == "primary"
+    model.primary_trait.value.should == "primary value"
+    model.primary_trait.parent.should == model
+    
+    model.primary_trait = JsonRecord::Test::Trait.new(:name => "new", :value => "val")
+    model.save!
+    model = JsonRecord::Test::Model.find(model.id)
+    model.primary_trait.name.should == "new"
+    model.primary_trait.value.should == "val"
+    model.primary_trait.parent.should == model
+  end
+  
+  it "should handle many embedded documents" do
+    model = JsonRecord::Test::Model.new(:name => "test", :traits => [{:name => "n1", :value => "v1"}, {:name => "n2", :value => "v2"}])
+    model.traits.build(:name => "n3", :value => "v3")
+    model.traits.build(JsonRecord::Test::Trait.new(:name => "n4", :value => "v4"))
+    model.traits << {"name" => "n5", "value" => "v5"}
+    model.traits << JsonRecord::Test::Trait.new("name" => "n6", "value" => "v6")
+    model.traits.concat([{"name" => "n7", "value" => "v7"}, {:name => "n8", :value => "v8"}, JsonRecord::Test::Trait.new("name" => "n9", "value" => "v9")])
+    model.traits.collect{|t| [t.name, t.value]}.should == [["n1", "v1"], ["n2", "v2"], ["n3", "v3"], ["n4", "v4"], ["n5", "v5"], ["n6", "v6"], ["n7", "v7"], ["n8", "v8"], ["n9", "v9"]]
+    model.traits.collect{|t| t.parent}.uniq.should == [model]
+    
+    model.save!
+    model = JsonRecord::Test::Model.find(model.id)
+    model.traits.collect{|t| [t.name, t.value]}.should == [["n1", "v1"], ["n2", "v2"], ["n3", "v3"], ["n4", "v4"], ["n5", "v5"], ["n6", "v6"], ["n7", "v7"], ["n8", "v8"], ["n9", "v9"]]
+    model.traits.collect{|t| t.parent}.uniq.should == [model]
+    
+    model.traits.slice!(0)
+    model.traits.pop
+    model.traits = model.traits.reverse
+    model.traits[1].name = "name7"
+    model.traits[1].value = "value7"
+    model.save!
+    model = JsonRecord::Test::Model.find(model.id)
+    model.traits.collect{|t| [t.name, t.value]}.should == [["n8", "v8"], ["name7", "value7"], ["n6", "v6"], ["n5", "v5"], ["n4", "v4"], ["n3", "v3"], ["n2", "v2"]]
+  end
+  
+  it "should handle nested embedded documents" do
+    model = JsonRecord::Test::Model.new(:name => "test")
+    trait = model.traits.build(:name => "n1", :value => "v1")
+    subtrait = trait.sub_traits.build(:name => "s1", :value => "v1")
+    model.traits.should == [trait]
+    model.traits.first.sub_traits.should == [subtrait]
+    model.save!
+    model = JsonRecord::Test::Model.find(model.id)
+  end
+  
+  it "should be able to set a many key with the values in a hash" do
+    model = JsonRecord::Test::Model.new(:name => "test")
+    model.traits = {"first" => {:name => "n1", :value => "v1"}, "second" => {:name => "n2", :value => "v2"}}
+    model.traits.size.should == 2
+    model.traits.collect{|t| t.name}.sort.should == ["n1", "n2"]
+  end
+  
+  it "should get the json field definition for a field" do
+    JsonRecord::Test::Model.json_field_definition(:value).name.should == "value"
+    JsonRecord::Test::Model.json_field_definition("value").name.should == "value"
+    JsonRecord::Test::Model.json_field_definition("nothing").should == nil
+  end
+  
+  it "should validate uniqueness of embedded documents" do
+    model = JsonRecord::Test::Model.new(:name => "test", :traits => [{:name => "n1", :value => "v1"}, {:name => "n1", :value => "v2"}])
+    model.valid?.should == false
+    model.errors.on(:traits).should_not == nil
+    model.traits.first.errors.on(:name).should == nil
+    model.traits.last.errors.on(:name).should_not == nil
+    
+    model.traits.last.name = "n2"
+    model.valid?.should == true
+    model.errors.on(:traits).should == nil
+    model.traits.first.errors.on(:name).should == nil
+    model.traits.last.errors.on(:name).should == nil
+  end
+  
+  it "should perform validations on embedded documents" do
+    model = JsonRecord::Test::Model.new(:name => "test")
+    model.primary_trait = {:name => "", :value => "v2"}
+    trait = model.traits.build(:value => "v1")
+    subtrait = trait.sub_traits.build(:name => "s1", :count => "plaid")
+    model.valid?.should == false
+    model.errors.on(:primary_trait).should_not == nil
+    model.errors.on(:traits).should_not == nil
+    model.primary_trait.errors.on(:name).should_not == nil
+    trait.errors.on(:name).should_not == nil
+    trait.errors.on(:sub_traits).should_not == nil
+    subtrait.errors.on(:count).should_not == nil
+    
+    model.primary_trait.name = "p1"
+    trait.name = "n1"
+    subtrait.count = 1
+    model.valid?.should == true
+    model.errors.on(:primary_trait).should == nil
+    model.errors.on(:traits).should == nil
+    model.primary_trait.errors.on(:name).should == nil
+    trait.errors.on(:name).should == nil
+    trait.errors.on(:sub_traits).should == nil
+    subtrait.errors.on(:count).should == nil
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+require 'rubygems'
+
+active_record_version = ENV["ACTIVE_RECORD_VERSION"] || [">= 2.2.2", "< 3.0"]
+active_record_version = [active_record_version] unless active_record_version.is_a?(Array)
+gem 'activerecord', *active_record_version
+
+require 'spec'
+require 'active_record'
+puts "Testing Against ActiveRecord #{ActiveRecord::VERSION::STRING}" if defined?(ActiveRecord::VERSION)
+ActiveRecord.load_all! if ActiveRecord.respond_to?(:load_all!)
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'json_record'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_models'))

data/spec/test_models.rb

@@ -0,0 +1,70 @@
+module JsonRecord
+  module Test
+    def self.create_tables
+      db_dir = File.expand_path(File.join(__FILE__, '..', 'tmp'))
+      Dir.mkdir(db_dir) unless File.exist?(db_dir)
+      db = File.join(db_dir, 'test_JsonRecord.sqlite3')
+      Model.establish_connection("adapter" => "sqlite3", "database" => db)
+      
+      Model.connection.create_table(:models) do |t|
+        t.text :json
+        t.binary :compressed_json
+        t.string :string_field
+      end unless Model.table_exists?
+      
+      SubModel.connection.create_table(:sub_models) do |t|
+        t.text :json
+        t.binary :compressed_json
+        t.string :string_field
+      end unless SubModel.table_exists?
+    end
+    
+    def self.drop_tables
+      db_dir = File.expand_path(File.join(__FILE__, '..', 'tmp'))
+      db = File.join(db_dir, 'test_JsonRecord.sqlite3')
+      Model.connection.disconnect!
+      File.delete(db) if File.exist?(db)
+      Dir.delete(db_dir) if File.exist?(db_dir) and Dir.entries(db_dir).reject{|f| f.match(/^\.+$/)}.empty?
+    end
+
+    class Trait < JsonRecord::EmbeddedDocument
+      key :name, :required => true
+      key :value
+      key :count, Integer
+      many :sub_traits, Trait, :unique => [:name, :value]
+    end
+    
+    class Model < ActiveRecord::Base
+      include JsonRecord::Serialized
+      serialize_to_json(:json) do |schema|
+        schema.key :name, String, :required => true, :length => 15
+        schema.key :value, Integer, :default => 0
+        schema.key :price, Float
+        schema.key :verified, Boolean
+        schema.key :when, Date
+        schema.key :verified_at, Time
+        schema.key :viewed_at, DateTime
+        schema.key :strings, Array
+        schema.key :map, Hash
+        schema.key :primary_trait, Trait
+        schema.many :traits, Trait, :unique => :name
+      end
+
+      serialize_to_json(:compressed_json) do |schema|
+        schema.key :field_1
+        schema.key :field_2, :format => /^[a-z]+$/
+        schema.key :field_3, :in => ("A".."M")
+        schema.key :field_4, :length => (4..15)
+        schema.key :field_5, :length => {:minimum => 5}
+      end
+    end
+    
+    class SubModel < Model
+      set_table_name :sub_models
+      
+      serialize_to_json(:json) do |schema|
+        schema.key :another_field
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification 
+name: json_record
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Brian Durand
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-07 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.2.2
+    - - <
+      - !ruby/object:Gem::Version 
+        version: "3.0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.9
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: 
+email: brian@embellishedvisions.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- MIT_LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- init.rb
+- json_record.gemspec
+- lib/json_record.rb
+- lib/json_record/attribute_methods.rb
+- lib/json_record/embedded_document.rb
+- lib/json_record/embedded_document_array.rb
+- lib/json_record/field_definition.rb
+- lib/json_record/json_field.rb
+- lib/json_record/schema.rb
+- lib/json_record/serialized.rb
+- spec/embedded_document_array_spec.rb
+- spec/embedded_document_spec.rb
+- spec/field_definition_spec.rb
+- spec/serialized_spec.rb
+- spec/spec_helper.rb
+- spec/test_models.rb
+has_rdoc: true
+homepage: http://github.com/bdurand/json_record
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: ActiveRecord support for mapping complex documents within a single RDBMS record via JSON serialization.
+test_files: 
+- spec/embedded_document_array_spec.rb
+- spec/embedded_document_spec.rb
+- spec/field_definition_spec.rb
+- spec/serialized_spec.rb
+- spec/spec_helper.rb
+- spec/test_models.rb