property 0.7.0 → 0.8.0

data/History.txt

@@ -1,3 +1,10 @@
+== 0.8.0 2010-02-11
+
+* 3 major enhancements
+  * enabled Behaviors that can be added on an instance
+  * enabled non-DB types
+  * 100% test coverage
+
 == 0.7.0 2010-02-11
 
 * 2 major enhancement

data/README.rdoc

@@ -46,3 +46,25 @@ And set them with:
   @contact.prop['name'] = 'Gandhi'
   @contact.name = 'Gandhi'
 
+== Behaviors
+
+Properties would not be really fun if you could not add new properties to your instances depending
+on some flags. First define the behaviors:
+
+  @a_picture = Property::Behavior.new do |p|
+    p.integer :width,  :default => :get_width
+    p.integer :height, :default => :get_height
+    p.string  'camera'
+    p.string  'location'
+  end
+
+And then, either when creating new pictures or updating them, you need to include the behavior:
+
+  @model.behave_like @a_picture
+
+The model now has the picture's properties defined, with accessors like @model.camera and default
+values will be fetched on save.
+
+Note that you do not need to include a behavior just to read the data as long as you use the 'prop'
+accessor.
+

data/lib/property.rb

@@ -2,16 +2,29 @@ require 'property/attribute'
 require 'property/dirty'
 require 'property/properties'
 require 'property/column'
+require 'property/behavior'
+require 'property/schema'
 require 'property/declaration'
 require 'property/serialization/json'
 require 'property/core_ext/time'
 
 module Property
-  VERSION = '0.7.0'
+  VERSION = '0.8.0'
 
   def self.included(base)
     base.class_eval do
       include ::Property::Attribute
     end
   end
+
+  def self.validators
+    @@validators ||= []
+  end
+
+  def self.validate_property_class(type)
+    @@validators.each do |validator|
+      return false unless validator.validate(type)
+    end
+    true
+  end
 end

data/lib/property/behavior.rb

@@ -0,0 +1,167 @@
+module Property
+  # This class holds a set of property definitions. This is like a Module in ruby:
+  # by 'including' this behavior in a class or in an instance, you augment the said
+  # object with the behavior's property definitions.
+  class Behavior
+    attr_accessor :name, :included, :accessor_module
+
+    def self.new(name)
+      obj = super
+      if block_given?
+        yield obj
+      end
+      obj
+    end
+
+    # Initialize a new behavior with the given name
+    def initialize(name)
+      @name    = name
+      @included_in_schemas = []
+      @accessor_module = Module.new
+    end
+
+    # List all property definitiosn for the current behavior
+    def columns
+      @columns ||= {}
+    end
+
+    # Return the list of column names.
+    def column_names
+      columns.keys
+    end
+
+    # Use this method to declare properties into a Behavior.
+    # Example:
+    #  @behavior.property.string 'phone', :default => ''
+    #
+    # You can also use a block:
+    #  @behavior.property do |p|
+    #    p.string 'phone', 'name', :default => ''
+    #  end
+    def property
+      if block_given?
+        yield self
+      end
+      self
+    end
+
+    # def string(*args)
+    #   options = args.extract_options!
+    #   column_names = args
+    #   default = options.delete(:default)
+    #   column_names.each { |name| column(name, default, 'string', options) }
+    # end
+    %w( string text integer float decimal datetime timestamp time date binary boolean ).each do |column_type|
+      class_eval <<-EOV
+        def #{column_type}(*args)
+          options = args.extract_options!
+          column_names = args
+          default = options.delete(:default)
+          column_names.each { |name| add_column(Property::Column.new(name, default, '#{column_type}', options)) }
+        end
+      EOV
+    end
+
+    # This is used to serialize a non-native DB type. Use:
+    #   p.serialize 'pet', Dog
+    def serialize(name, klass, options = {})
+      Property.validate_property_class(klass)
+      add_column(Property::Column.new(name, nil, klass, options))
+    end
+
+    # @internal
+    # This is called when the behavior is included in a schema
+    def included(schema)
+      @included_in_schemas << schema
+    end
+
+    private
+
+      def define_property_methods(column)
+        name = column.name
+
+        #if create_time_zone_conversion_attribute?(name, column)
+        #  define_read_property_method_for_time_zone_conversion(name)
+        #else
+        define_read_property_method(name.to_sym, name, column)
+        #end
+
+        #if create_time_zone_conversion_attribute?(name, column)
+        #  define_write_property_method_for_time_zone_conversion(name)
+        #else
+        define_write_property_method(name.to_sym)
+        #end
+
+        define_question_property_method(name)
+      end
+
+      # Define a property reader method.  Cope with nil column.
+      def define_read_property_method(symbol, attr_name, column)
+        # Unlike rails, we do not cast on read
+        evaluate_attribute_property_method attr_name, "def #{symbol}; prop['#{attr_name}']; end"
+      end
+
+      # Defined for all +datetime+ and +timestamp+ attributes when +time_zone_aware_attributes+ are enabled.
+      # This enhanced read method automatically converts the UTC time stored in the database to the time zone stored in Time.zone.
+      # def define_read_property_method_for_time_zone_conversion(attr_name)
+      #   method_body = <<-EOV
+      #     def #{attr_name}(reload = false)
+      #       cached = @attributes_cache['#{attr_name}']
+      #       return cached if cached && !reload
+      #       time = properties['#{attr_name}']
+      #       @attributes_cache['#{attr_name}'] = time.acts_like?(:time) ? time.in_time_zone : time
+      #     end
+      #   EOV
+      #   evaluate_attribute_property_method attr_name, method_body
+      # end
+
+      # Defines a predicate method <tt>attr_name?</tt>.
+      def define_question_property_method(attr_name)
+        evaluate_attribute_property_method attr_name, "def #{attr_name}?; prop['#{attr_name}']; end", "#{attr_name}?"
+      end
+
+      def define_write_property_method(attr_name)
+        evaluate_attribute_property_method attr_name, "def #{attr_name}=(new_value);prop['#{attr_name}'] = new_value; end", "#{attr_name}="
+      end
+
+      # Defined for all +datetime+ and +timestamp+ attributes when +time_zone_aware_attributes+ are enabled.
+      # This enhanced write method will automatically convert the time passed to it to the zone stored in Time.zone.
+      # def define_write_property_method_for_time_zone_conversion(attr_name)
+      #   method_body = <<-EOV
+      #     def #{attr_name}=(time)
+      #       unless time.acts_like?(:time)
+      #         time = time.is_a?(String) ? Time.zone.parse(time) : time.to_time rescue time
+      #       end
+      #       time = time.in_time_zone rescue nil if time
+      #       prop['#{attr_name}'] = time
+      #     end
+      #   EOV
+      #   evaluate_attribute_property_method attr_name, method_body, "#{attr_name}="
+      # end
+
+      # Evaluate the definition for an attribute related method
+      def evaluate_attribute_property_method(attr_name, method_definition, method_name=attr_name)
+        accessor_module.class_eval(method_definition, __FILE__, __LINE__)
+      end
+
+      def add_column(column)
+        name = column.name
+
+        if columns[name]
+          raise TypeError.new("Property '#{name}' is already defined.")
+        else
+          verify_not_defined_in_schemas_using_this_behavior(name)
+          define_property_methods(column) if column.should_create_accessors?
+          columns[column.name] = column
+        end
+      end
+
+      def verify_not_defined_in_schemas_using_this_behavior(name)
+        @included_in_schemas.each do |schema|
+          if schema.columns[name]
+            raise TypeError.new("Property '#{name}' is already defined in #{schema.name}.")
+          end
+        end
+      end
+  end
+end

data/lib/property/column.rb

@@ -11,11 +11,16 @@ module Property
     def initialize(name, default, type, options={})
       name = name.to_s
       extract_property_options(options)
+      if type.kind_of?(Class)
+        @klass = type
+      end
       super(name, default, type, options)
     end
 
     def validate(value, errors)
-      # Do nothing for the moment
+      if @klass && !value.kind_of?(@klass)
+        errors.add(name, "cannot cast #{value.class} to #{@klass}")
+      end
     end
 
     def should_create_accessors?
@@ -36,6 +41,21 @@ module Property
       end
     end
 
+    def klass
+      @klass || super
+    end
+
+    def type_cast(value)
+      if type == :string
+        value = value.to_s
+        value.blank? ? nil : value
+      elsif @klass
+        value
+      else
+        super
+      end
+    end
+
     private
       def extract_property_options(options)
         @indexed = options.delete(:indexed)

data/lib/property/declaration.rb

@@ -10,90 +10,34 @@ module Property
         include InstanceMethods
 
         class << self
-          attr_accessor :own_property_columns
-          attr_accessor :property_definition_proxy
-        end
-
-        validate :properties_validation, :if => :properties
-      end
-    end
-
-    class DefinitionProxy
-      def initialize(klass)
-        @klass = klass
-      end
-
-      def column(name, default, type, options)
-        if columns[name.to_s]
-          raise TypeError.new("Property '#{name}' is already defined.")
-        else
-          add_column(Property::Column.new(name, default, type, options))
-        end
-      end
+          attr_accessor :schema
 
-      def add_column(column)
-        own_columns[column.name] = column
-        @klass.define_property_methods(column) if column.should_create_accessors?
-      end
-
-      # If someday we find the need to insert other native classes directly in the DB, we
-      # could use this:
-      # p.serialize MyClass, xxx, xxx
-      # def serialize(klass, name, options={})
-      #   if @klass.super_property_columns[name.to_s]
-      #     raise TypeError.new("Property '#{name}' is already defined in a superclass.")
-      #   elsif !@klass.validate_property_class(type)
-      #     raise TypeError.new("Custom type '#{type}' cannot be serialized.")
-      #   else
-      #     # Find a way to insert the type (maybe with 'serialize'...)
-      #     # (@klass.own_property_columns ||= {})[name] = Property::Column.new(name, type, options)
-      #   end
-      # end
-
-      # def string(*args)
-      #   options = args.extract_options!
-      #   column_names = args
-      #   default = options.delete(:default)
-      #   column_names.each { |name| column(name, default, 'string', options) }
-      # end
-      %w( string text integer float decimal datetime timestamp time date binary boolean ).each do |column_type|
-        class_eval <<-EOV
-          def #{column_type}(*args)
-            options = args.extract_options!
-            column_names = args
-            default = options.delete(:default)
-            column_names.each { |name| column(name, default, '#{column_type}', options) }
+          def schema
+            @schema ||= make_schema
           end
-        EOV
-      end
 
-      private
-        def own_columns
-          @klass.own_property_columns ||= {}
-        end
-
-        def columns
-          @klass.property_columns
+          private
+            def make_schema
+              schema = Property::Schema.new(self.to_s, self)
+              if superclass.respond_to?(:schema)
+                schema.behave_like superclass
+              end
+              schema
+            end
         end
 
-    end
-
-    class InstanceDefinitionProxy < DefinitionProxy
-      def initialize(instance)
-        @properties = instance.prop
-      end
-
-      def add_column(column)
-        columns[column.name] = column
-      end
-
-      def columns
-        @properties.columns
+        validate :properties_validation, :if => :properties
       end
     end
 
     module ClassMethods
 
+      # Include a new set of property definitions (Behavior) into the current class schema.
+      # You can also provide a class to simulate multiple inheritance.
+      def behave_like(behavior)
+        schema.behave_like behavior
+      end
+
       # Use this class method to declare properties that will be used in your models.
       # Example:
       #  property.string 'phone', :default => ''
@@ -103,131 +47,44 @@ module Property
       #    p.string 'phone', 'name', :default => ''
       #  end
       def property
-        proxy = self.property_definition_proxy ||= DefinitionProxy.new(self)
-        if block_given?
-          yield proxy
-        end
-        proxy
-      end
-
-      # @internal.
-      # If you need the list of columns (including instance columns), you should use
-      #   properties.columns
-      #
-      # Return the list of all properties defined for the current class, including the properties
-      # defined in the parent class.
-      def property_columns
-        super_property_columns.merge(self.own_property_columns || {})
-      end
-
-      def property_column_names
-        property_columns.keys
-      end
-
-      def super_property_columns
-        if superclass.respond_to?(:property_columns)
-          superclass.property_columns
-        else
-          {}
-        end
-      end
-
-      def define_property_methods(column)
-        name = column.name
-        unless instance_method_already_implemented?(name)
-          if create_time_zone_conversion_attribute?(name, column)
-            define_read_property_method_for_time_zone_conversion(name)
-          else
-            define_read_property_method(name.to_sym, name, column)
-          end
-        end
+        setter = schema.behavior
 
-        unless instance_method_already_implemented?("#{name}=")
-          if create_time_zone_conversion_attribute?(name, column)
-            define_write_property_method_for_time_zone_conversion(name)
-          else
-            define_write_property_method(name.to_sym)
-          end
+        if block_given?
+          yield setter
         end
 
-        unless instance_method_already_implemented?("#{name}?")
-          define_question_property_method(name)
-        end
+        setter
       end
-
-      private
-        # Define a property reader method.  Cope with nil column.
-        def define_read_property_method(symbol, attr_name, column)
-          # Unlike rails, we do not cast on read
-          evaluate_attribute_property_method attr_name, "def #{symbol}; prop['#{attr_name}']; end"
-        end
-
-        # Defined for all +datetime+ and +timestamp+ attributes when +time_zone_aware_attributes+ are enabled.
-        # This enhanced read method automatically converts the UTC time stored in the database to the time zone stored in Time.zone.
-        def define_read_property_method_for_time_zone_conversion(attr_name)
-          method_body = <<-EOV
-            def #{attr_name}(reload = false)
-              cached = @attributes_cache['#{attr_name}']
-              return cached if cached && !reload
-              time = properties['#{attr_name}']
-              @attributes_cache['#{attr_name}'] = time.acts_like?(:time) ? time.in_time_zone : time
-            end
-          EOV
-          evaluate_attribute_property_method attr_name, method_body
-        end
-
-        # Defines a predicate method <tt>attr_name?</tt>.
-        def define_question_property_method(attr_name)
-          evaluate_attribute_property_method attr_name, "def #{attr_name}?; prop['#{attr_name}']; end", "#{attr_name}?"
-        end
-
-        def define_write_property_method(attr_name)
-          evaluate_attribute_property_method attr_name, "def #{attr_name}=(new_value);prop['#{attr_name}'] = new_value; end", "#{attr_name}="
-        end
-
-        # Defined for all +datetime+ and +timestamp+ attributes when +time_zone_aware_attributes+ are enabled.
-        # This enhanced write method will automatically convert the time passed to it to the zone stored in Time.zone.
-        def define_write_property_method_for_time_zone_conversion(attr_name)
-          method_body = <<-EOV
-            def #{attr_name}=(time)
-              unless time.acts_like?(:time)
-                time = time.is_a?(String) ? Time.zone.parse(time) : time.to_time rescue time
-              end
-              time = time.in_time_zone rescue nil if time
-              prop['#{attr_name}'] = time
-            end
-          EOV
-          evaluate_attribute_property_method attr_name, method_body, "#{attr_name}="
-        end
-
-        # Evaluate the definition for an attribute related method
-        def evaluate_attribute_property_method(attr_name, method_definition, method_name=attr_name)
-          class_eval(method_definition, __FILE__, __LINE__)
-        end
     end # ClassMethods
 
     module InstanceMethods
+      # Instance's schema (can be different from the instance's class schema if behaviors have been
+      # added to the instance.
+      def schema
+        @own_schema || self.class.schema
+      end
 
-      # Use this method to declare properties *for the current* instance.
-      # Example:
-      #  @obj.property.string 'phone', :default => ''
-      #
-      # You can also use a block:
-      #  @obj.property do |p|
-      #    p.string 'phone', 'name', :default => ''
-      #  end
-      def property
-        proxy = @instance_definition_proxy ||= InstanceDefinitionProxy.new(self)
-        if block_given?
-          yield proxy
-        end
-        proxy
+      # Include a new set of property definitions (Behavior) into the current instance's schema.
+      # You can also provide a class to simulate multiple inheritance.
+      def behave_like(behavior)
+        own_schema.behave_like behavior
       end
 
       protected
         def properties_validation
           properties.validate
         end
+
+        def own_schema
+          @own_schema ||= make_own_schema
+        end
+      private
+        def make_own_schema
+          this = class << self; self; end
+          schema = Property::Schema.new(nil, this)
+          schema.behave_like self.class
+          schema
+        end
     end # InsanceMethods
   end # Declaration
 end # Property

data/lib/property/properties.rb

@@ -20,7 +20,7 @@ module Property
             delete(key)
           end
         else
-          super(key, column.type_cast(value.to_s))
+          super(key, column.type_cast(value))
         end
       else
         super
@@ -56,24 +56,14 @@ module Property
       end
 
       keys_to_validate.each do |key|
-        value  = self[key]
-        column = columns[key]
-        if value.blank?
-          if column.has_default?
-            self[key] = column.default_for(@owner)
-          else
-            delete(key)
-          end
-        else
-          columns[key].validate(self[key], errors)
-        end
+        columns[key].validate(self[key], errors)
       end
 
       bad_keys.empty?
     end
 
     def columns
-      @columns ||= @owner.class.property_columns
+      @columns ||= @owner.schema.columns
     end
   end
 end

data/lib/property/schema.rb

@@ -0,0 +1,79 @@
+
+module Property
+  # This class holds all the properties of a given class or instance. It is used
+  # to validate content and type_cast during write operations.
+  #
+  # The properties are not directly defined in the schema. They are stored in a
+  # Behavior instance which checks that the database is in sync with the properties
+  # defined.
+  class Schema
+    attr_reader :behaviors, :behavior, :binding
+
+    # Create a new Schema. If a class_name is provided, the schema automatically
+    # creates a default Behavior to store definitions.
+    def initialize(class_name, binding)
+      @binding = binding
+      @behaviors = []
+      if class_name
+        @behavior  = Behavior.new(class_name)
+        include_behavior @behavior
+        @behaviors << @behavior
+      end
+    end
+
+    # Return an identifier for the schema to help locate property redefinition errors.
+    def name
+      @behavior ? @behavior.name : @binding.to_s
+    end
+
+    # If the parameter is a class, the schema will inherit the property definitions
+    # from the class. If the parameter is a Behavior, the properties from that
+    # behavior will be included. Any new columns added to a behavior or any new
+    # behaviors included in a class will be dynamically added to the sub-classes (just like
+    # Ruby class inheritance, module inclusion works).
+    # If you ...
+    def behave_like(thing)
+      if thing.kind_of?(Class)
+        if thing.respond_to?(:schema) && thing.schema.kind_of?(Schema)
+          thing.schema.behaviors.flatten.each do |behavior|
+            include_behavior behavior
+          end
+          self.behaviors << thing.schema.behaviors
+        else
+          raise TypeError.new("expected Behavior or class with schema, found #{thing}")
+        end
+      elsif thing.kind_of?(Behavior)
+        include_behavior thing
+        self.behaviors << thing
+      else
+        raise TypeError.new("expected Behavior or class with schema, found #{thing.class}")
+      end
+    end
+
+    # Return the list of column names.
+    def column_names
+      columns.keys
+    end
+
+    # Return column definitions from all included behaviors.
+    def columns
+      columns = {}
+      @behaviors.flatten.uniq.each do |b|
+        columns.merge!(b.columns)
+      end
+      columns
+    end
+
+    private
+      def include_behavior(behavior)
+        return if behaviors.include?(behavior)
+        columns = self.columns
+        common_keys = behavior.column_names & columns.keys
+        if !common_keys.empty?
+          raise TypeError.new("Cannot include behavior #{behavior.name}. Duplicate definitions: #{common_keys.join(', ')}")
+        end
+        behavior.included(self)
+        @binding.send(:include, behavior.accessor_module)
+      end
+  end
+end

data/lib/property/serialization/json.rb

@@ -5,11 +5,11 @@ module Property
     # provide 'self.create_json' and 'to_json' methods for the classes you want
     # to serialize.
     module JSON
-      module ClassMethods
+      module Validator
         NATIVE_TYPES = [Hash, Array, Integer, Float, String, TrueClass, FalseClass, NilClass]
 
-        # Returns true if the given class can be serialized with JSON
-        def validate_property_class(klass)
+        # Should raise an exception if the type is not serializable.
+        def self.validate(klass)
           if NATIVE_TYPES.include?(klass) ||
              (klass.respond_to?('json_create') && klass.instance_methods.include?('to_json'))
             true
@@ -20,10 +20,10 @@ module Property
       end
 
       def self.included(base)
-        base.extend ClassMethods
+        Property.validators << Validator
       end
 
-      # Encode properties with Marhsal
+      # Encode properties with JSON
       def encode_properties(properties)
         properties.to_json
       end

data/lib/property/serialization/marshal.rb

@@ -7,16 +7,6 @@ module Property
     #  * no corruption risk if the version of Marshal changes
     #  * it can be accessed by other languages then ruby
     module Marshal
-      module ClassMethods
-        # Returns true if the given class can be serialized with Marshal
-        def validate_property_class(klass)
-          true
-        end
-      end
-
-      def self.included(base)
-        base.extend ClassMethods
-      end
 
       # Encode properties with Marhsal
       def encode_properties(properties)

data/lib/property/serialization/yaml.rb

@@ -3,17 +3,6 @@ module Property
     # Use YAML to encode properties. This method is the slowest of all
     # and you should use JSON if you haven't got good reasons not to.
     module YAML
-      module ClassMethods
-        # Returns true if the given class can be serialized with YAML
-        def validate_property_class(klass)
-          true
-        end
-      end
-
-      def self.included(base)
-        base.extend ClassMethods
-      end
-
       # Encode properties with YAML
       def encode_properties(properties)
         ::YAML.dump(properties)

data/property.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{property}
-  s.version = "0.7.0"
+  s.version = "0.8.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Renaud Kern", "Gaspard Bucher"]
-  s.date = %q{2010-02-11}
+  s.date = %q{2010-02-12}
   s.description = %q{Wrap model properties into a single database column and declare properties from within the model.}
   s.email = %q{gaspard@teti.ch}
   s.extra_rdoc_files = [
@@ -24,11 +24,13 @@ Gem::Specification.new do |s|
      "generators/property/property_generator.rb",
      "lib/property.rb",
      "lib/property/attribute.rb",
+     "lib/property/behavior.rb",
      "lib/property/column.rb",
      "lib/property/core_ext/time.rb",
      "lib/property/declaration.rb",
      "lib/property/dirty.rb",
      "lib/property/properties.rb",
+     "lib/property/schema.rb",
      "lib/property/serialization/json.rb",
      "lib/property/serialization/marshal.rb",
      "lib/property/serialization/yaml.rb",
@@ -37,6 +39,7 @@ Gem::Specification.new do |s|
      "test/shoulda_macros/serialization.rb",
      "test/test_helper.rb",
      "test/unit/property/attribute_test.rb",
+     "test/unit/property/behavior_test.rb",
      "test/unit/property/declaration_test.rb",
      "test/unit/property/dirty_test.rb",
      "test/unit/property/validation_test.rb",
@@ -55,6 +58,7 @@ Gem::Specification.new do |s|
      "test/shoulda_macros/serialization.rb",
      "test/test_helper.rb",
      "test/unit/property/attribute_test.rb",
+     "test/unit/property/behavior_test.rb",
      "test/unit/property/declaration_test.rb",
      "test/unit/property/dirty_test.rb",
      "test/unit/property/validation_test.rb",

data/test/fixtures.rb

@@ -24,6 +24,25 @@ class Version < ActiveRecord::Base
   end
 end
 
+# To test custom class serialization
+class Dog
+  attr_accessor :name, :toy
+  def self.json_create(data)
+    Dog.new(data['name'], data['toy'])
+  end
+  def initialize(name, toy)
+    @name, @toy = name, toy
+  end
+  def to_json(*args)
+    { 'json_class' => self.class.to_s,
+      'name' => @name, 'toy' => @toy
+    }.to_json(*args)
+  end
+  def ==(other)
+    other.kind_of?(Dog) && @name == other.name && @toy == other.toy
+  end
+end
+
 begin
   class PropertyMigration < ActiveRecord::Migration
     def self.down

data/test/shoulda_macros/serialization.rb

@@ -2,17 +2,6 @@ class Test::Unit::TestCase
 
   def self.should_encode_and_decode_properties
     klass = self.name.gsub(/Test$/,'').constantize
-    context klass do
-      should 'respond to validate_property_class' do
-        assert klass.respond_to? :validate_property_class
-      end
-
-      [Property::Properties, String, Integer, Float].each do |a_class|
-        should "accept to serialize #{a_class}" do
-          assert klass.validate_property_class(a_class)
-        end
-      end
-    end
 
     context "Instance of #{klass}" do
       setup do
@@ -29,7 +18,13 @@ class Test::Unit::TestCase
 
       context 'with Properties' do
         setup do
-          @properties = Property::Properties['foo' => 'bar']
+          @properties = Property::Properties[
+            'string'     => 'bar',
+            'serialized' => Dog.new('Pavlov', 'Freud'),
+            'datetime'   => Time.utc(2010, 02, 12, 21, 31, 25),
+            'float'      => 4.3432,
+            'integer'    => 4
+          ]
         end
 
         should 'encode Properties in string' do

data/test/test_helper.rb

@@ -6,6 +6,7 @@ require 'shoulda'
 require 'active_record'
 require 'property'
 require 'shoulda_macros/serialization'
+require 'fixtures'
 
 class Test::Unit::TestCase
 

data/test/unit/property/attribute_test.rb

@@ -1,6 +1,4 @@
 require 'test_helper'
-require 'fixtures'
-require 'benchmark'
 
 class AttributeTest < Test::Unit::TestCase
 
@@ -215,6 +213,32 @@ class AttributeTest < Test::Unit::TestCase
         assert_equal @now, subject.prop['mydatetime']
       end
     end
+
+
+    context 'a saved serialized class' do
+      setup do
+        @dog = Dog.new('Pavlov', 'Freud')
+      end
+
+      subject do
+        klass = Class.new(ActiveRecord::Base) do
+          include Property
+          set_table_name :dummies
+          property.serialize 'myserialized', Dog
+        end
+
+        obj = klass.create('myserialized' => @dog)
+        klass.find(obj)
+      end
+
+      should 'find class back' do
+        assert_kind_of Dog, subject.prop['myserialized']
+      end
+
+      should 'find same value' do
+        assert_equal @dog, subject.prop['myserialized']
+      end
+    end
   end
 
   context 'Setting attributes' do

data/test/unit/property/behavior_test.rb

@@ -0,0 +1,119 @@
+require 'test_helper'
+require 'fixtures'
+
+class BehaviorTest < Test::Unit::TestCase
+
+  context 'A Behavior' do
+    subject { Property::Behavior.new('Foobar') }
+
+    should 'allow string columns' do
+      subject.property.string('weapon')
+      column = subject.columns['weapon']
+      assert_equal 'weapon', column.name
+      assert_equal String, column.klass
+      assert_equal :string, column.type
+    end
+
+    should 'treat symbol keys as strings' do
+      subject.property.string(:weapon)
+      column = subject.columns['weapon']
+      assert_equal 'weapon', column.name
+      assert_equal String, column.klass
+      assert_equal :string, column.type
+    end
+
+    should 'allow integer columns' do
+      subject.property.integer('indestructible')
+      column = subject.columns['indestructible']
+      assert_equal 'indestructible', column.name
+      assert_equal Fixnum, column.klass
+      assert_equal :integer, column.type
+    end
+
+    should 'allow float columns' do
+      subject.property.float('boat')
+      column = subject.columns['boat']
+      assert_equal 'boat', column.name
+      assert_equal Float, column.klass
+      assert_equal :float, column.type
+    end
+
+    should 'allow datetime columns' do
+      subject.property.datetime('time_weapon')
+      column = subject.columns['time_weapon']
+      assert_equal 'time_weapon', column.name
+      assert_equal Time, column.klass
+      assert_equal :datetime, column.type
+    end
+
+    should 'allow default value option' do
+      subject.property.integer('force', :default => 10)
+      column = subject.columns['force']
+      assert_equal 10, column.default
+    end
+
+    should 'allow indexed option' do
+      subject.property.string('rolodex', :indexed => true)
+      column = subject.columns['rolodex']
+      assert column.indexed?
+    end
+  end # A Behavior
+
+  context 'Adding a behavior' do
+    setup do
+      @poet = Property::Behavior.new('Poet') do |p|
+        p.string 'poem'
+      end
+    end
+
+    context 'to a class' do
+      setup do
+        @parent = Class.new(ActiveRecord::Base) do
+          set_table_name :dummies
+          include Property
+          property.string 'name'
+        end
+
+        @klass = Class.new(@parent)
+      end
+
+      should 'propagate definitions to child' do
+        @parent.behave_like @poet
+        assert_equal %w{name poem}, @klass.schema.column_names.sort
+      end
+
+      should 'raise an exception if class contains same definitions' do
+        @parent.property.string 'poem'
+        assert_raise(TypeError) { @parent.behave_like @poet }
+      end
+
+      should 'not raise an exception on double inclusion' do
+        @parent.behave_like @poet
+        assert_nothing_raised { @parent.behave_like @poet }
+      end
+
+      should 'add accessor methods to child' do
+        subject = @klass.new
+        assert_raises(NoMethodError) { subject.poem = 'Poe'}
+        @parent.behave_like @poet
+
+        assert_nothing_raised { subject.poem = 'Poe'}
+      end
+    end
+
+    context 'to a parent class' do
+    end
+
+    context 'to an instance' do
+      subject { Developer.new }
+
+      setup do
+        subject.behave_like @poet
+      end
+
+      should 'merge property definitions' do
+        assert_equal %w{age first_name language last_name poem}, subject.schema.column_names.sort
+      end
+    end
+  end
+end

data/test/unit/property/declaration_test.rb

@@ -9,29 +9,31 @@ class DeclarationTest < Test::Unit::TestCase
         @klass = Developer
       end
 
-      should 'inherit property columsn from parent class' do
-        assert_equal %w{age first_name language last_name}, @klass.property_column_names.sort
+      should 'inherit property columns from parent class' do
+        assert_equal %w{age first_name language last_name}, @klass.schema.column_names.sort
       end
 
       should 'not back-propagate definitions to parent' do
-        assert !@klass.superclass.property_columns.include?('language')
+        assert !@klass.superclass.schema.columns.include?('language')
       end
 
-      should 'inherit current definitions from parent' do
+      should 'inherit new definitions in parent' do
         class ParentClass < ActiveRecord::Base
           include Property
           property.string 'name'
         end
+
         @klass = Class.new(ParentClass) do
           property.integer 'age'
         end
-        assert_equal %w{age name}, @klass.property_column_names.sort
+
+        assert_equal %w{age name}, @klass.schema.column_names.sort
 
         ParentClass.class_eval do
           property.string 'first_name'
         end
 
-        assert_equal %w{age first_name name}, @klass.property_column_names.sort
+        assert_equal %w{age first_name name}, @klass.schema.column_names.sort
       end
 
       should 'not be allowed to overwrite a property from the parent class' do
@@ -62,7 +64,7 @@ class DeclarationTest < Test::Unit::TestCase
 
     should 'create Property::Column definitions' do
       subject.property.string('weapon')
-      assert_kind_of Property::Column, subject.property_columns['weapon']
+      assert_kind_of Property::Column, subject.schema.columns['weapon']
     end
 
     should 'create ruby accessors' do
@@ -84,7 +86,7 @@ class DeclarationTest < Test::Unit::TestCase
 
     should 'allow string columns' do
       subject.property.string('weapon')
-      column = subject.property_columns['weapon']
+      column = subject.schema.columns['weapon']
       assert_equal 'weapon', column.name
       assert_equal String, column.klass
       assert_equal :string, column.type
@@ -92,7 +94,7 @@ class DeclarationTest < Test::Unit::TestCase
 
     should 'treat symbol keys as strings' do
       subject.property.string(:weapon)
-      column = subject.property_columns['weapon']
+      column = subject.schema.columns['weapon']
       assert_equal 'weapon', column.name
       assert_equal String, column.klass
       assert_equal :string, column.type
@@ -100,7 +102,7 @@ class DeclarationTest < Test::Unit::TestCase
 
     should 'allow integer columns' do
       subject.property.integer('indestructible')
-      column = subject.property_columns['indestructible']
+      column = subject.schema.columns['indestructible']
       assert_equal 'indestructible', column.name
       assert_equal Fixnum, column.klass
       assert_equal :integer, column.type
@@ -108,7 +110,7 @@ class DeclarationTest < Test::Unit::TestCase
 
     should 'allow float columns' do
       subject.property.float('boat')
-      column = subject.property_columns['boat']
+      column = subject.schema.columns['boat']
       assert_equal 'boat', column.name
       assert_equal Float, column.klass
       assert_equal :float, column.type
@@ -116,41 +118,67 @@ class DeclarationTest < Test::Unit::TestCase
 
     should 'allow datetime columns' do
       subject.property.datetime('time_weapon')
-      column = subject.property_columns['time_weapon']
+      column = subject.schema.columns['time_weapon']
       assert_equal 'time_weapon', column.name
       assert_equal Time, column.klass
       assert_equal :datetime, column.type
     end
+    
+    should 'allow serialized columns' do
+      Dog = Struct.new(:name, :toy) do
+        def self.json_create(data)
+          Dog.new(data['name'], data['toy'])
+        end
+        def to_json(*args)
+          { 'json_class' => self.class.to_s,
+            'name' => @name, 'toy' => @toy
+          }.to_json(*args)
+        end
+      end
+      
+      subject.property.serialize('pet', Dog)
+      column = subject.schema.columns['pet']
+      assert_equal 'pet', column.name
+      assert_equal Dog, column.klass
+      assert_equal nil, column.type
+    end
 
     should 'allow default value option' do
       subject.property.integer('force', :default => 10)
-      column = subject.property_columns['force']
+      column = subject.schema.columns['force']
       assert_equal 10, column.default
     end
 
     should 'allow indexed option' do
       subject.property.string('rolodex', :indexed => true)
-      column = subject.property_columns['rolodex']
+      column = subject.schema.columns['rolodex']
       assert column.indexed?
     end
 
-    context 'in an instance singleton' do
+    context 'through a Behavior on an instance' do
       setup do
         @instance = subject.new
-        @instance.property do |p|
-          p.string 'instance_only'
+        @poet = Property::Behavior.new('Poet')
+        @poet.property do |p|
+          p.string 'poem'
         end
+
+        @instance.behave_like @poet
       end
 
       should 'behave like any other property column' do
-        @instance.attributes = {'instance_only' => 'hello'}
+        @instance.attributes = {'poem' => 'hello'}
+        @instance.poem = 'shazam'
         assert @instance.save
         @instance = subject.find(@instance.id)
-        assert_equal Hash['instance_only' => 'hello'], @instance.prop
+        assert_equal Hash['poem' => 'shazam'], @instance.prop
       end
 
       should 'not affect instance class' do
-        assert !subject.property_column_names.include?('instance_only')
+        assert !subject.schema.column_names.include?('poem')
+        assert_raise(NoMethodError) do
+          subject.new.poem = 'not a poet'
+        end
       end
     end
   end
@@ -162,12 +190,24 @@ class DeclarationTest < Test::Unit::TestCase
     end
 
     should 'return empty Hash if no property columsn are declared' do
-      assert_equal Hash[], Dummy.property_columns
+      assert_equal Hash[], Dummy.schema.columns
     end
 
     should 'return list of property columns from class' do
-      assert_kind_of Hash, Employee.property_columns
-      assert_kind_of Property::Column, Employee.property_columns['first_name']
+      assert_kind_of Hash, Employee.schema.columns
+      assert_kind_of Property::Column, Employee.schema.columns['first_name']
+    end
+  end
+
+  context 'On a class with a schema' do
+    subject { Developer }
+
+    should 'raise an exception if we ask to behave like a class without schema' do
+      assert_raise(TypeError) { subject.behave_like String }
+    end
+
+    should 'raise an exception if we ask to behave like an object' do
+      assert_raise(TypeError) { subject.behave_like 'me' }
     end
   end
 end

data/test/unit/property/validation_test.rb

@@ -9,6 +9,7 @@ class ValidationTest < Test::Unit::TestCase
       include Property
       property.float 'boat'
       property.string 'bird_name'
+      property.serialize 'dog', Dog
     end
 
     subject { Pirate.create }
@@ -39,6 +40,12 @@ class ValidationTest < Test::Unit::TestCase
         assert_kind_of String, subject.prop['bird_name']
         assert_equal '1337', subject.prop['bird_name']
       end
+
+      should 'show an error for serialized types' do
+        subject.update_attributes('dog' => 'Medor')
+        assert !subject.valid?
+        assert_equal 'cannot cast String to Dog', subject.errors['dog']
+      end
     end
 
     context 'to a blank value' do

data/test/unit/serialization/json_test.rb

@@ -9,4 +9,29 @@ class MyJSONTest < Test::Unit::TestCase
 
   should_encode_and_decode_properties
 
+  context 'JSON validator' do
+    subject { Property::Serialization::JSON::Validator }
+
+    should 'respond to validate' do
+      assert subject.respond_to? :validate
+    end
+
+    [Property::Properties, String, Integer, Float].each do |a_class|
+      should "accept to serialize #{a_class}" do
+        assert subject.validate(a_class)
+      end
+    end
+  end
+
+  context 'on a class with properties as custom type' do
+    subject do
+      Class.new(ActiveRecord::Base) do
+        include Property
+      end
+    end
+
+    should 'raise an exception if we try to encode an invalid class' do
+      assert_raise(TypeError) { subject.property.serialize 'not_json', Regexp }
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: property
 version: !ruby/object:Gem::Version 
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors: 
 - Renaud Kern
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-11 00:00:00 +01:00
+date: 2010-02-12 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -50,11 +50,13 @@ files:
 - generators/property/property_generator.rb
 - lib/property.rb
 - lib/property/attribute.rb
+- lib/property/behavior.rb
 - lib/property/column.rb
 - lib/property/core_ext/time.rb
 - lib/property/declaration.rb
 - lib/property/dirty.rb
 - lib/property/properties.rb
+- lib/property/schema.rb
 - lib/property/serialization/json.rb
 - lib/property/serialization/marshal.rb
 - lib/property/serialization/yaml.rb
@@ -63,6 +65,7 @@ files:
 - test/shoulda_macros/serialization.rb
 - test/test_helper.rb
 - test/unit/property/attribute_test.rb
+- test/unit/property/behavior_test.rb
 - test/unit/property/declaration_test.rb
 - test/unit/property/dirty_test.rb
 - test/unit/property/validation_test.rb
@@ -102,6 +105,7 @@ test_files:
 - test/shoulda_macros/serialization.rb
 - test/test_helper.rb
 - test/unit/property/attribute_test.rb
+- test/unit/property/behavior_test.rb
 - test/unit/property/declaration_test.rb
 - test/unit/property/dirty_test.rb
 - test/unit/property/validation_test.rb