property 0.6.0 → 0.7.0

data/History.txt

@@ -1,3 +1,9 @@
+== 0.7.0 2010-02-11
+
+* 2 major enhancement
+  * enabled instance property definitions
+  * Time is now natively parsed by json (no typecast)
+
 == 0.6.0 2010-02-11
 
 * 1 major enhancement

data/lib/property.rb

@@ -4,9 +4,10 @@ require 'property/properties'
 require 'property/column'
 require 'property/declaration'
 require 'property/serialization/json'
+require 'property/core_ext/time'
 
 module Property
-  VERSION = '0.6.0'
+  VERSION = '0.7.0'
 
   def self.included(base)
     base.class_eval do

data/lib/property/attribute.rb

@@ -50,7 +50,7 @@ module Property
 
       private
         def attributes_with_properties=(attributes, guard_protected_attributes = true)
-          property_columns = self.class.property_columns
+          property_columns = self.properties.columns
           properties = {}
 
           attributes.keys.each do |k|

data/lib/property/column.rb

@@ -26,8 +26,24 @@ module Property
       @indexed
     end
 
-    def extract_property_options(options)
-      @indexed = options.delete(:indexed)
+    def default_for(owner)
+      if default.kind_of?(Proc)
+        default.call
+      elsif default.kind_of?(Symbol)
+        owner.send(default)
+      else
+        default
+      end
     end
+
+    private
+      def extract_property_options(options)
+        @indexed = options.delete(:indexed)
+      end
+
+      def extract_default(default)
+        (default.kind_of?(Proc) || default.kind_of?(Symbol)) ? default : type_cast(default)
+      end
+
   end # Column
 end # Property

data/lib/property/core_ext/time.rb

@@ -0,0 +1,19 @@
+# We provide our own 'to_json' version because the default is just an alias for 'to_s' and we
+# do not get the correct type back.
+#
+# In order to keep speed up, we have done some compromizes: all time values are considered to
+# be UTC: we do not encode the timezone. We also ignore micro seconds.
+class Time
+  JSON_REGEXP = /\A(\d{4})-(\d\d)-(\d\d) (\d\d):(\d\d):(\d\d)\z/
+  JSON_FORMAT = "%Y-%m-%d %H:%M:%S"
+
+  def self.json_create(serialized)
+    if serialized['data'] =~ JSON_REGEXP
+      Time.utc $1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i
+    end
+  end
+
+  def to_json(*args)
+    { 'json_class' => self.class.name, 'data' => strftime(JSON_FORMAT) }.to_json(*args)
+  end
+end

data/lib/property/declaration.rb

@@ -18,66 +18,84 @@ module Property
       end
     end
 
-    module ClassMethods
-      class DefinitionProxy
-        def initialize(klass)
-          @klass = klass
+    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
 
-        def column(name, default, type, options)
-          if columns[name.to_s]
-            raise TypeError.new("Property '#{name}' is already defined.")
-          else
-            new_column = Property::Column.new(name, default, type, options)
-            own_columns[new_column.name] = new_column
-            @klass.define_property_methods(new_column) if new_column.should_create_accessors?
+      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) }
           end
+        EOV
+      end
+
+      private
+        def own_columns
+          @klass.own_property_columns ||= {}
         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) }
-            end
-          EOV
+        def columns
+          @klass.property_columns
         end
 
-        private
-          def own_columns
-            @klass.own_property_columns ||= {}
-          end
+    end
 
-          def columns
-            @klass.property_columns
-          end
+    class InstanceDefinitionProxy < DefinitionProxy
+      def initialize(instance)
+        @properties = instance.prop
+      end
+
+      def add_column(column)
+        columns[column.name] = column
+      end
 
+      def columns
+        @properties.columns
       end
+    end
 
-      # Use this class method to declare properties that will be used in your models. Note
-      # that you must provide string keys. Example:
+    module ClassMethods
+
+      # Use this class method to declare properties that will be used in your models.
+      # Example:
       #  property.string 'phone', :default => ''
       #
       # You can also use a block:
@@ -92,6 +110,10 @@ module Property
         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
@@ -180,20 +202,28 @@ module Property
 
         # Evaluate the definition for an attribute related method
         def evaluate_attribute_property_method(attr_name, method_definition, method_name=attr_name)
-          begin
-            class_eval(method_definition, __FILE__, __LINE__)
-          rescue SyntaxError => err
-            if logger
-              logger.warn "Exception occurred during method compilation."
-              logger.warn "Maybe #{attr_name} is not a valid Ruby identifier?"
-              logger.warn err.message
-            end
-          end
+          class_eval(method_definition, __FILE__, __LINE__)
         end
     end # ClassMethods
 
     module InstanceMethods
 
+      # 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
+      end
+
       protected
         def properties_validation
           properties.validate

data/lib/property/properties.rb

@@ -14,7 +14,7 @@ module Property
     def []=(key, value)
       if column = columns[key]
         if value.blank?
-          if default = column.default
+          if default = column.default_for(@owner)
             super(key, default)
           else
             delete(key)
@@ -36,8 +36,7 @@ module Property
     end
 
     def validate
-      columns = @owner.class.property_columns
-      column_names = @owner.class.property_column_names
+      column_names = columns.keys
       errors = @owner.errors
       no_errors = true
 
@@ -52,20 +51,29 @@ module Property
       missing_keys.each do |key|
         column = columns[key]
         if column.has_default?
-          self[key] = column.default
+          self[key] = column.default_for(@owner)
         end
       end
 
       keys_to_validate.each do |key|
-        columns[key].validate(self[key], errors)
+        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
       end
 
       bad_keys.empty?
     end
 
-    private
-      def columns
-        @columns ||= @owner.class.property_columns
-      end
+    def columns
+      @columns ||= @owner.class.property_columns
+    end
   end
 end

data/property.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{property}
-  s.version = "0.6.0"
+  s.version = "0.7.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Renaud Kern", "Gaspard Bucher"]
@@ -25,6 +25,7 @@ Gem::Specification.new do |s|
      "lib/property.rb",
      "lib/property/attribute.rb",
      "lib/property/column.rb",
+     "lib/property/core_ext/time.rb",
      "lib/property/declaration.rb",
      "lib/property/dirty.rb",
      "lib/property/properties.rb",

data/test/unit/property/attribute_test.rb

@@ -97,11 +97,11 @@ class AttributeTest < Test::Unit::TestCase
     subject { Version.new }
 
     setup do
-      subject.properties={'foo'=>'bar', :tic=>:tac}
+      subject.properties={'foo'=>'bar'}
     end
 
     should 'be accessible with :properties method' do
-      assert_equal Hash['foo'=>'bar', :tic=>:tac], subject.properties
+      assert_equal Hash['foo'=>'bar'], subject.properties
     end
 
     should 'be accessible with native methods' do
@@ -127,6 +127,96 @@ class AttributeTest < Test::Unit::TestCase
 
   end
 
+  context 'Retrieving' do
+    context 'a saved string' do
+      subject do
+        klass = Class.new(ActiveRecord::Base) do
+          include Property
+          set_table_name :dummies
+          property.string 'mystring'
+        end
+
+        obj = klass.create('mystring' => 'some data')
+        klass.find(obj)
+      end
+
+      should 'find a string' do
+        assert_kind_of String, subject.prop['mystring']
+      end
+
+      should 'find same value' do
+        assert_equal 'some data', subject.prop['mystring']
+      end
+    end
+
+    context 'a saved integer' do
+      subject do
+        klass = Class.new(ActiveRecord::Base) do
+          include Property
+          set_table_name :dummies
+          property.integer 'myinteger'
+        end
+
+        obj = klass.create('myinteger' => 789)
+        klass.find(obj)
+      end
+
+      should 'find an integer' do
+        assert_kind_of Fixnum, subject.prop['myinteger']
+      end
+
+      should 'find same value' do
+        assert_equal 789, subject.prop['myinteger']
+      end
+    end
+
+    context 'a saved float' do
+      subject do
+        klass = Class.new(ActiveRecord::Base) do
+          include Property
+          set_table_name :dummies
+          property.float 'myfloat'
+        end
+
+        obj = klass.create('myfloat' => 78.9)
+        klass.find(obj)
+      end
+
+      should 'find an float' do
+        assert_kind_of Float, subject.prop['myfloat']
+      end
+
+      should 'find same value' do
+        assert_equal 78.9, subject.prop['myfloat']
+      end
+    end
+
+    context 'a saved datetime' do
+      setup do
+        @now = Time.utc(2010,02,11,17,50,18)
+      end
+
+      subject do
+        klass = Class.new(ActiveRecord::Base) do
+          include Property
+          set_table_name :dummies
+          property.datetime 'mydatetime'
+        end
+
+        obj = klass.create('mydatetime' => @now)
+        klass.find(obj)
+      end
+
+      should 'find an datetime' do
+        assert_kind_of Time, subject.prop['mydatetime']
+      end
+
+      should 'find same value' do
+        assert_equal @now, subject.prop['mydatetime']
+      end
+    end
+  end
+
   context 'Setting attributes' do
     subject { Version.new }
 

data/test/unit/property/declaration_test.rb

@@ -54,6 +54,7 @@ class DeclarationTest < Test::Unit::TestCase
 
   context 'Property declaration' do
     Superhero = Class.new(ActiveRecord::Base) do
+      set_table_name :dummies
       include Property
     end
 
@@ -132,6 +133,26 @@ class DeclarationTest < Test::Unit::TestCase
       column = subject.property_columns['rolodex']
       assert column.indexed?
     end
+
+    context 'in an instance singleton' do
+      setup do
+        @instance = subject.new
+        @instance.property do |p|
+          p.string 'instance_only'
+        end
+      end
+
+      should 'behave like any other property column' do
+        @instance.attributes = {'instance_only' => 'hello'}
+        assert @instance.save
+        @instance = subject.find(@instance.id)
+        assert_equal Hash['instance_only' => 'hello'], @instance.prop
+      end
+
+      should 'not affect instance class' do
+        assert !subject.property_column_names.include?('instance_only')
+      end
+    end
   end
 
   context 'Property columns' do

data/test/unit/property/validation_test.rb

@@ -62,21 +62,47 @@ class ValidationTest < Test::Unit::TestCase
 
   context 'On a class with default property values' do
     Cat = Class.new(ActiveRecord::Base) do
+      attr_accessor :encoding
+
       set_table_name 'dummies'
       include Property::Attribute
       property do |p|
         p.string 'eat', :default => 'mouse'
         p.string 'name'
+        p.datetime 'seen_at', :default => Proc.new { Time.now }
+        p.string 'encoding', :default => :get_encoding
+      end
+
+      def get_encoding
+        @encoding
       end
     end
 
-    should 'insert default values' do
+    should 'insert default literal values' do
       subject = Cat.create
       subject.reload
       assert_equal 'mouse', subject.prop['eat']
     end
 
-    should 'insert accept other values' do
+    should 'call procs to get default if missing' do
+      subject = Cat.create
+      assert_kind_of Time, subject.prop['seen_at']
+    end
+
+    should 'call procs to get default if empty' do
+      subject = Cat.new('seen_at' => '')
+      assert_kind_of Time, subject.prop['seen_at']
+    end
+
+    should 'call owner methods to get default' do
+      subject = Cat.new
+      subject.encoding = 'yooupla/boom'
+      assert subject.save
+
+      assert_equal 'yooupla/boom', subject.prop['encoding']
+    end
+
+    should 'accept other values' do
       subject = Cat.create('eat' => 'birds')
       subject.reload
       assert_equal 'birds', subject.prop['eat']

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: property
 version: !ruby/object:Gem::Version 
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors: 
 - Renaud Kern
@@ -51,6 +51,7 @@ files:
 - lib/property.rb
 - lib/property/attribute.rb
 - lib/property/column.rb
+- lib/property/core_ext/time.rb
 - lib/property/declaration.rb
 - lib/property/dirty.rb
 - lib/property/properties.rb