json_record 1.0.0

data/lib/json_record/schema.rb

@@ -0,0 +1,128 @@
+module JsonRecord
+  # Definition of a document schema. Defining a schema will define accessor methods for each field and potentially some
+  # validators.
+  class Schema
+    attr_reader :fields, :json_field_name
+    
+    # Create a schema on the class for a particular field.
+    def initialize (klass, json_field_name)
+      @json_field_name = json_field_name
+      @klass = klass
+      @fields = {}
+    end
+    
+    # Define a single valued field in the schema.
+    # The first argument should be the field name. This must be unique for the class accross all attributes.
+    #
+    # The optional second argument can be used to specify the class of the field values. It will default to
+    # String if not specified. Valid types are String, Integer, Float, Date, Time, DateTime, Boolean, Array, Hash,
+    # or any class that inherits from EmbeddedDocument.
+    #
+    # The last argument can be a hash with any of these keys:
+    # * :default -
+    # * :required -
+    # * :length -
+    # * :format -
+    # * :in -
+    def key (name, *args)
+      options = args.extract_options!
+      name = name.to_s
+      json_type = args.first || String
+      
+      raise ArgumentError.new("too many arguments (must be 1 or 2 plus an options hash)") if args.length > 1
+        
+      field = FieldDefinition.new(name, :type => json_type, :default => options[:default])
+      fields[name] = field
+      add_json_validations(field, options)
+      define_json_accessor(field, json_field_name)
+    end
+    
+    def many (name, *args)
+      name = name.to_s
+      options = args.extract_options!
+      type = args.first || name.singularize.classify.constantize
+      field = FieldDefinition.new(name, :type => type, :multivalued => true)
+      fields[name] = field
+      add_json_validations(field, options)
+      define_many_json_accessor(field, json_field_name)
+    end
+    
+    private
+    
+    def add_json_validations (field, options)
+      @klass.validates_presence_of(field.name) if options[:required]
+      @klass.validates_format_of(field.name, :with => options[:format], :allow_blank => true) if options[:format]
+      
+      if options[:length]
+        case options[:length]
+        when Fixnum
+          @klass.validates_length_of(field.name, :maximum => options[:length], :allow_blank => true)
+        when Range
+          @klass.validates_length_of(field.name, :in => options[:length], :allow_blank => true)
+        when Hash
+          @klass.validates_length_of(field.name, options[:length].merge(:allow_blank => true))
+        end
+      end
+      
+      if options[:in]
+        @klass.validates_inclusion_of(field.name, :in => options[:in], :allow_blank => true)
+      end
+      
+      if field.type == Integer
+        @klass.validates_numericality_of(field.name, :only_integer => true, :allow_blank => true)
+      elsif field.type == Float
+        @klass.validates_numericality_of(field.name, :allow_blank => true)
+      elsif [Date, Time, DateTime].include?(field.type)
+        @klass.validates_each(field.name) do |record, name, value|
+          unless value.is_a?(field.type) or value.blank?
+            record.errors.add(name, :invalid, :value => value)
+          end
+        end
+      end
+      
+      if field.multivalued?
+        @klass.validates_each(field.name) do |record, name, value|
+          record.errors.add(name, :invalid) unless value.all?{|v| v.valid?}
+        end
+      elsif field.type < EmbeddedDocument
+        @klass.validates_each(field.name) do |record, name, value|
+          if value.is_a?(field.type)
+            record.errors.add(name, :invalid) unless value.valid?
+          end
+        end
+      end
+      
+      if field.multivalued? and !options[:unique].blank?
+        @klass.validates_each(field.name) do |record, name, value|
+          used = {}
+          error_found = false
+          value.each do |v|
+            fval = v.attributes[options[:unique].to_s]
+            if used[fval]
+              v.errors.add(options[:unique].to_s, :taken, :value => fval)
+              error_found = true
+            else
+              used[fval] = true
+            end
+          end
+          record.errors.add(name, :invalid) if error_found
+        end
+      end
+    end
+    
+    def define_json_accessor (field, json_field_name)
+      @klass.send(:define_method, field.name) {read_json_attribute(json_field_name, field)}
+      @klass.send(:define_method, "#{field.name}?") {!!read_json_attribute(json_field_name, field)} if field.type == Boolean
+      @klass.send(:define_method, "#{field.name}=") {|val| write_json_attribute(json_field_name, field, val, true)}
+      @klass.send(:define_method, "#{field.name}_changed?") {self.send(:attribute_changed?, field.name)}
+      @klass.send(:define_method, "#{field.name}_change") {self.send(:attribute_change, field.name)}
+      @klass.send(:define_method, "#{field.name}_was") {self.send(:attribute_was, field.name)}
+      @klass.send(:define_method, "#{field.name}_before_type_cast") {self.read_attribute_before_type_cast(field.name)}
+    end
+    
+    def define_many_json_accessor (field, json_field_name)
+      @klass.send(:define_method, field.name) {self.read_json_attribute(json_field_name, field)}
+      @klass.send(:define_method, "#{field.name}=") {|val| self.write_json_attribute(json_field_name, field, val, true)}
+    end
+  end
+end

data/lib/json_record/serialized.rb

@@ -0,0 +1,106 @@
+module JsonRecord
+  # Adds the serialized JSON behavior to ActiveRecord.
+  module Serialized
+    def self.included (base)
+      base.class_inheritable_accessor :json_serialized_fields
+      base.extend(ClassMethods)
+    end
+    
+    module ClassMethods
+      # Specify a field name that contains serialized JSON. The block will be yielded to with a
+      # Schema object that can then be used to define the fields in the JSON document. A class
+      # can have multiple fields that store JSON documents if necessary.
+      def serialize_to_json (field_name, &block)
+        field_name = field_name.to_s
+        self.json_serialized_fields ||= {}
+        include InstanceMethods unless include?(InstanceMethods)
+        schema = Schema.new(self, field_name)
+        field_schemas = json_serialized_fields[field_name]
+        if field_schemas
+          field_schemas = field_schemas.dup
+        else
+          field_schemas = []
+        end
+        json_serialized_fields[field_name] = field_schemas
+        field_schemas << schema
+        block.call(schema) if block
+      end
+      
+      # Get the field definition of the JSON field from the schema it is defined in.
+      def json_field_definition (name)
+        field = nil
+        if json_serialized_fields
+          name = name.to_s
+          json_serialized_fields.values.flatten.each{|schema| field = schema.fields[name]; break if field}
+        end
+        return field
+      end
+    end
+    
+    module InstanceMethods
+      def self.included (base)
+        base.before_save :serialize_json_attributes
+        base.alias_method_chain :reload, :serialized_json
+        base.alias_method_chain :attributes, :serialized_json
+      end
+      
+      # Get the JsonField objects for the record.
+      def json_fields
+        unless @json_fields
+          @json_fields = {}
+          json_serialized_fields.each_pair do |name, schemas|
+            @json_fields[name] = JsonField.new(self, name, schemas)
+          end
+        end
+        @json_fields
+      end
+      
+      def reload_with_serialized_json (*args)
+        @json_fields = nil
+        reload_without_serialized_json(*args)
+      end
+      
+      def attributes_with_serialized_json
+        attrs = json_attributes.reject{|k,v| !json_field_names.include?(k)}
+        attrs.merge!(attributes_without_serialized_json)
+        json_serialized_fields.keys.each{|name| attrs.delete(name)}
+        return attrs
+      end
+      
+      protected
+      
+      # Returns a hash of all the JsonField objects merged together.
+      def json_attributes
+        attrs = {}
+        json_fields.values.each do |field|
+          attrs.merge!(field.json_attributes)
+        end
+        attrs
+      end
+      
+      def json_field_names
+        @json_field_names = json_serialized_fields.values.flatten.collect{|s| s.fields.keys}.flatten
+      end
+      
+      # Read a field value from a JsonField
+      def read_json_attribute (json_field_name, field)
+        json_fields[json_field_name].read_attribute(field, self)
+      end
+      
+      # Write a field value to a JsonField
+      def write_json_attribute (json_field_name, field, value, track_changes)
+        json_fields[json_field_name].write_attribute(field, value, track_changes, self)
+      end
+      
+      # Serialize the JSON in the record into JsonField objects.
+      def serialize_json_attributes
+        json_fields.values.each{|field| field.serialize} if @json_fields
+      end
+      
+      # Write out the JSON representation of the JsonField objects to the database fields.
+      def deserialize_json_attributes
+        json_fields.values.each{|field| field.deserialize} if @json_fields
+      end
+    end
+  end
+end

data/lib/json_record.rb

@@ -0,0 +1,20 @@
+require 'active_record'
+
+begin
+  require 'json'
+rescue LoadError
+  ActiveRecord::Base.logger.warn("*** You really should install the json gem for optimal performance with json_record ***")
+end
+
+unless defined?(Boolean)
+  class Boolean
+  end
+end
+
+require File.expand_path(File.join(File.dirname(__FILE__), 'json_record', 'attribute_methods'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'json_record', 'embedded_document'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'json_record', 'embedded_document_array'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'json_record', 'field_definition'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'json_record', 'json_field'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'json_record', 'schema'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'json_record', 'serialized'))

data/spec/embedded_document_array_spec.rb

@@ -0,0 +1,64 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+describe JsonRecord::EmbeddedDocumentArray do
+  it "should be an Array" do
+    a = JsonRecord::EmbeddedDocumentArray.new(JsonRecord::Test::Trait, nil)
+    a.is_a?(Array).should == true
+  end
+  
+  it "should convert hashes to objects on initialize and set the parent" do
+    parent = JsonRecord::Test::Trait.new(:name => "name")
+    obj = JsonRecord::Test::Trait.new(:name => "n1", :value => "v1")
+    hash = {:name => "n2", :value => "v2"}
+    a = JsonRecord::EmbeddedDocumentArray.new(JsonRecord::Test::Trait, parent, [obj, hash])
+    obj.parent.should == parent
+    a.collect{|t| [t.name, t.value, t.parent]}.should == [["n1", "v1", parent], ["n2", "v2", parent]]
+  end
+  
+  it "should convert hashes to objects on concat and set the parent" do
+    parent = JsonRecord::Test::Trait.new(:name => "name")
+    obj = JsonRecord::Test::Trait.new(:name => "n1", :value => "v1")
+    hash = {:name => "n2", :value => "v2"}
+    a = JsonRecord::EmbeddedDocumentArray.new(JsonRecord::Test::Trait, parent)
+    a.concat([obj, hash])
+    obj.parent.should == parent
+    a.collect{|t| [t.name, t.value, t.parent]}.should == [["n1", "v1", parent], ["n2", "v2", parent]]
+  end
+  
+  it "should convert hashes to objects on append and set the parent" do
+    parent = JsonRecord::Test::Trait.new(:name => "name")
+    obj = JsonRecord::Test::Trait.new(:name => "n1", :value => "v1")
+    hash = {:name => "n2", :value => "v2"}
+    a = JsonRecord::EmbeddedDocumentArray.new(JsonRecord::Test::Trait, parent)
+    a << obj
+    a << hash
+    obj.parent.should == parent
+    a.collect{|t| [t.name, t.value, t.parent]}.should == [["n1", "v1", parent], ["n2", "v2", parent]]
+  end
+  
+  it "should have a build method that appends the values and set the parent" do
+    parent = JsonRecord::Test::Trait.new(:name => "name")
+    obj = JsonRecord::Test::Trait.new(:name => "n1", :value => "v1")
+    hash = {:name => "n2", :value => "v2"}
+    a = JsonRecord::EmbeddedDocumentArray.new(JsonRecord::Test::Trait, parent)
+    a.build(obj).should == obj
+    obj.parent.should == parent
+    obj_2 = a.build(hash)
+    obj_2.name.should == "n2"
+    obj_2.value.should == "v2"
+    obj_2.parent.should == parent
+    a.collect{|t| [t.name, t.value, t.parent]}.should == [["n1", "v1", parent], ["n2", "v2", parent]]
+  end
+  
+  it "should not accept objects that are not the correct class" do
+    parent = JsonRecord::Test::Trait.new(:name => "name")
+    obj = JsonRecord::Test::Trait.new(:name => "n1", :value => "v1")
+    hash = {:name => "n2", :value => "v2"}
+    lambda{a = JsonRecord::EmbeddedDocumentArray.new(JsonRecord::Test::Trait, parent, "bad object")}.should raise_error(ArgumentError)
+    a = JsonRecord::EmbeddedDocumentArray.new(JsonRecord::Test::Trait, parent)
+    lambda{a.concat(["bad object"])}.should raise_error(ArgumentError)
+    lambda{a << "bad object"}.should raise_error(ArgumentError)
+    lambda{a.build("bad object")}.should raise_error(ArgumentError)
+  end
+  
+end

data/spec/embedded_document_spec.rb

@@ -0,0 +1,65 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+describe JsonRecord::EmbeddedDocument do
+    
+  it "should have a schema" do
+    JsonRecord::Test::Trait.schema.should_not == nil
+  end
+  
+  it "should have a parent object" do
+    trait = JsonRecord::Test::Trait.new(:name => "n1", :value => "v1")
+    trait.parent.should == nil
+    trait.parent = :parent
+    trait.parent.should == :parent
+  end
+  
+  it "should have attributes" do
+    trait = JsonRecord::Test::Trait.new(:name => "n1", :value => "v1")
+    trait.name.should == "n1"
+    trait.value.should == "v1"
+    trait.attributes.should == {"name" => "n1", "value" => "v1"}
+    trait.name = "n2"
+    trait.value = "v2"
+    trait.name.should == "n2"
+    trait.value.should == "v2"
+    trait.attributes.should == {"name" => "n2", "value" => "v2"}
+  end
+  
+  it "should have attributes before type cast" do
+    trait = JsonRecord::Test::Trait.new
+    trait.name = 1
+    trait.count = "12"
+    trait.name_before_type_cast.should == 1
+    trait.count_before_type_cast.should == "12"
+    trait.name.should == "1"
+    trait.count.should == 12
+  end
+  
+  it "should track changes to attributes" do
+    trait = JsonRecord::Test::Trait.new
+    trait.name = "test"
+    trait.name_was.should == nil
+    trait.name_changed?.should == true
+    trait.name_change.should == [nil, "test"]
+    trait.changes.should == {"name" => [nil, "test"]}
+    trait.name = nil
+    trait.name_changed?.should == false
+    trait.name_was.should == nil
+    trait.name_change.should == nil
+    trait.changes.should == {}
+  end
+  
+  it "should convert to attributes to json" do
+    trait = JsonRecord::Test::Trait.new(:name => "n1", :value => "v1")
+    ActiveSupport::JSON.decode(trait.to_json).should == {"name" => "n1", "value" => "v1"}
+  end
+  
+  it "should consider it equal to another EmbeddedDocument with the same attributes and parent" do
+    trait_1 = JsonRecord::Test::Trait.new(:name => "n1", :value => "v1")
+    trait_2 = JsonRecord::Test::Trait.new(:name => "n1", :value => "v1")
+    (trait_1 == trait_2).should == true
+    trait_1.eql?(trait_2).should == true
+    (trait_1.hash == trait_2.hash).should == true
+  end
+  
+end

data/spec/field_definition_spec.rb

@@ -0,0 +1,29 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+describe JsonRecord::FieldDefinition do
+  
+  it "should have a name that is a string" do
+    field = JsonRecord::FieldDefinition.new("name", :type => Integer)
+    field.name.should == "name"
+  end
+  
+  it "should have a type" do
+    field = JsonRecord::FieldDefinition.new("name", :type => Integer)
+    field.type.should == Integer
+  end
+  
+  it "should have a default" do
+    field = JsonRecord::FieldDefinition.new("name", :type => Integer)
+    field.default.should == nil
+    field = JsonRecord::FieldDefinition.new("name", :type => Integer, :default => 10)
+    field.default.should == 10
+  end
+  
+  it "can be multivalued" do
+    field = JsonRecord::FieldDefinition.new("name", :type => Integer)
+    field.multivalued?.should == false
+    field = JsonRecord::FieldDefinition.new("name", :type => Integer, :multivalued => true)
+    field.multivalued?.should == true
+  end
+  
+end