property 0.5.0

data/lib/property/properties.rb

@@ -0,0 +1,80 @@
+module Property
+  class Properties < Hash
+    attr_accessor :owner
+    include Property::DirtyProperties
+
+    def self.json_create(serialized)
+      self[serialized['data']]
+    end
+
+    def to_json(*args)
+      {
+        'json_class' => self.class.name,
+        'data' => Hash[self]
+      }.to_json(*args)
+    end
+
+    def []=(key, value)
+      if column = columns[key]
+        if value.blank?
+          if default = column.default
+            super(key, default)
+          else
+            delete(key)
+          end
+        else
+          super(key, column.type_cast(value.to_s))
+        end
+      else
+        super
+      end
+    end
+
+    # We need to write our own merge so that typecasting is called
+    def merge!(attributes)
+      raise TypeError.new("can't convert #{attributes.class} into Hash") unless attributes.kind_of?(Hash)
+      attributes.each do |key, value|
+        self[key] = value
+      end
+    end
+
+    def validate
+      columns = @owner.class.property_columns
+      column_names = @owner.class.property_column_names
+      errors = @owner.errors
+      no_errors = true
+
+      bad_keys     = keys - column_names
+      missing_keys = column_names - keys
+
+      bad_keys.each do |key|
+        errors.add("#{key}", 'property is not declared')
+      end
+
+      missing_keys.each do |key|
+        column = columns[key]
+        if column.has_default?
+          self[key] = column.default
+        end
+      end
+
+      bad_keys.empty?
+    end
+
+    def compact!
+      #keys.each do |key|
+      #  if self[key].nil?
+      #    delete(key)
+      #  end
+      #end
+    end
+
+    private
+      def write_attribute(key, value)
+      end
+
+      def columns
+        @columns ||= @owner.class.property_columns
+      end
+  end
+end

data/lib/property/serialization/json.rb

@@ -0,0 +1,38 @@
+module Property
+  module Serialization
+    # Use JSON to encode properties. This is the serialization best option. It's
+    # the fastest and does not have any binary format issues. You just have to
+    # provide 'self.create_json' and 'to_json' methods for the classes you want
+    # to serialize.
+    module JSON
+      module ClassMethods
+        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)
+          if NATIVE_TYPES.include?(klass) ||
+             (klass.respond_to?('json_create') && klass.instance_methods.include?('to_json'))
+            true
+          else
+            raise TypeError.new("Cannot serialize #{klass}. Missing 'self.create_json' and 'to_json' methods.")
+          end
+        end
+      end
+
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      # Encode properties with Marhsal
+      def encode_properties(properties)
+        properties.to_json
+      end
+
+      # Decode Marshal encoded properties
+      def decode_properties(string)
+        ::JSON.parse(string)
+      end
+
+    end # JSON
+  end # Serialization
+end # Property

data/lib/property/serialization/marshal.rb

@@ -0,0 +1,35 @@
+module Property
+  module Serialization
+    # Use Marhsal to encode properties. Unless you have very good reasons
+    # to use Marshal, you should use the JSON serialization instead:
+    #  * it's faster at reading text/date based objects
+    #  * it's human readable
+    #  * 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)
+        # we limit dump depth to 0 (object only: no instance variables)
+        # we have to protect Marshal from serializing instance variables by making a copy
+        [::Marshal::dump(Properties[properties])].pack('m*')
+      end
+
+      # Decode Marshal encoded properties
+      def decode_properties(string)
+        ::Marshal::load(string.unpack('m')[0])
+      end
+
+    end # Marshal
+  end # Serialization
+end # Property

data/lib/property/serialization/yaml.rb

@@ -0,0 +1,29 @@
+module Property
+  module Serialization
+    # 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)
+      end
+
+      # Decode properties from YAML
+      def decode_properties(string)
+        ::YAML::load(string)
+      end
+
+    end # Yaml
+  end # Serialization
+end # Property

data/test/fixtures.rb

@@ -0,0 +1,57 @@
+
+class Employee < ActiveRecord::Base
+  include Property
+  property.string 'first_name', :default => '', :indexed => true
+  property.string 'last_name',  :default => '', :indexed => true
+  property.float  'age'
+end
+
+class Developer < Employee
+  property.string 'language'
+end
+
+class WebDeveloper < Developer
+
+end
+
+class Version < ActiveRecord::Base
+  attr_accessor :backup
+  include Property
+  property.string 'foo'
+  # Other way to declare a string
+  property do |p|
+    p.string 'tic', 'comment'
+  end
+end
+
+begin
+  class PropertyMigration < ActiveRecord::Migration
+    def self.down
+      drop_table "employees"
+      drop_table "versions"
+    end
+    def self.up
+      create_table "employees" do |t|
+        t.string "type"
+        t.text   "properties"
+      end
+
+      create_table "versions" do |t|
+        t.string  "properties"
+        t.string  "title"
+        t.string  "comment"
+        t.timestamps
+      end
+
+      create_table "dummies" do |t|
+        t.text    "properties"
+      end
+    end
+  end
+
+  ActiveRecord::Base.establish_connection(:adapter=>'sqlite3', :database=>':memory:')
+  ActiveRecord::Migration.verbose = false
+  #PropertyMigration.migrate(:down)
+  PropertyMigration.migrate(:up)
+  ActiveRecord::Migration.verbose = true
+end

data/test/shoulda_macros/serialization.rb

@@ -0,0 +1,71 @@
+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
+        @obj = klass.new
+      end
+
+      should 'respond to :encode_properties' do
+        assert @obj.respond_to? :encode_properties
+      end
+
+      should 'respond to :decode_properties' do
+        assert @obj.respond_to? :decode_properties
+      end
+
+      context 'with Properties' do
+        setup do
+          @properties = Property::Properties['foo' => 'bar']
+        end
+
+        should 'encode Properties in string' do
+          assert_kind_of String, @obj.encode_properties(@properties)
+        end
+
+        should 'restore Properties from string' do
+          string = @obj.encode_properties(@properties)
+          properties = @obj.decode_properties(string)
+          assert_equal Property::Properties, properties.class
+          assert_equal @properties, properties
+        end
+
+        should 'not include instance variables' do
+          @properties.instance_eval do
+            @baz   = 'some data'
+            @owner = klass.new
+          end
+          prop = @obj.decode_properties(@obj.encode_properties(@properties))
+          assert_nil prop.instance_variable_get(:@baz)
+          assert_nil prop.instance_variable_get(:@owner)
+        end
+      end
+
+      context 'with empty Properties' do
+        setup do
+          @properties = Property::Properties.new
+        end
+
+        should 'encode and decode' do
+          string = @obj.encode_properties(@properties)
+          properties = @obj.decode_properties(string)
+          assert_equal Property::Properties, properties.class
+          assert_equal @properties, properties
+        end
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,19 @@
+require 'pathname'
+$LOAD_PATH.unshift((Pathname(__FILE__).dirname +  '..' + 'lib').expand_path)
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'active_record'
+require 'property'
+require 'shoulda_macros/serialization'
+
+class Test::Unit::TestCase
+
+  def assert_attribute(value, attr_name, object=subject)
+    assert_equal value, object.send(attr_name)
+    assert_equal value, object[attr_name]
+    assert_equal value, object.attributes[attr_name]
+    assert_equal value, object.properties=erties[attr_name]
+  end
+
+end

data/test/unit/property/attribute_test.rb

@@ -0,0 +1,334 @@
+require 'test_helper'
+require 'fixtures'
+require 'benchmark'
+
+class AttributeTest < Test::Unit::TestCase
+
+  ActiveRecord::Base.default_timezone = :utc
+  ENV['TZ'] = 'UTC'
+
+  context 'When including Property' do
+    should 'include Property::Attribute' do
+      assert Version.include?(Property::Attribute)
+    end
+
+    should 'include Property::Serialization::JSON' do
+      assert Version.include?(Property::Serialization::JSON)
+    end
+
+    should 'include Property::Dirty' do
+      assert Version.include?(Property::Dirty)
+    end
+
+    should 'include Property::Declaration' do
+      assert Version.include?(Property::Declaration)
+    end
+  end
+
+  context 'When defining new properties' do
+    should 'not allow symbols as keys' do
+      assert_raise(ArgumentError) do
+        Class.new(ActiveRecord::Base) do
+          include Property
+          property :foo, String
+        end
+      end
+    end
+  end
+
+  context 'When writing properties' do
+    subject { Version.new }
+
+    setup do
+      subject.properties = {'foo'=>'bar'}
+    end
+
+    context 'with properties=' do
+      should 'merge hash in current content' do
+        subject.properties = {'other' => 'value'}
+        assert_equal Hash['foo' => 'bar', 'other' => 'value'], subject.properties
+      end
+
+      should 'replace current values' do
+        subject.properties = {'foo' => 'baz'}
+        assert_equal Hash['foo' => 'baz'], subject.properties
+      end
+
+      should 'raise TypeError if new attributes is not a Hash' do
+        assert_raise(TypeError) { subject.properties = 'this a string' }
+      end
+    end
+
+    should 'with merge! should merge new attributes' do
+      subject.properties.merge!({'b'=>'bravo', 'c'=>'charlie'})
+      assert_equal Hash['foo' => 'bar', 'b' => 'bravo', 'c' => 'charlie'], subject.properties
+    end
+  end
+
+  context 'When writing attributes with hash access' do
+    subject { Version.new('foo' => 'bar') }
+
+    setup do
+      subject.properties['foo'] = 'babar'
+    end
+
+    should 'write a property into properties' do
+      assert_equal Hash['foo' => 'babar'], subject.properties
+    end
+
+    should 'save property in properties' do
+      subject.save
+      version = Version.find(subject.id)
+      assert_equal Hash['foo' => 'babar'], version.properties
+    end
+  end
+
+
+  context 'The properties of an object' do
+    subject { Version.new }
+
+    setup do
+      subject.properties={'foo'=>'bar', :tic=>:tac}
+    end
+
+    should 'be accessible with :properties method' do
+      assert_equal Hash['foo'=>'bar', :tic=>:tac], subject.properties
+    end
+
+    should 'be a kind of Hash' do
+      assert_kind_of Hash, subject.properties
+    end
+
+    should 'respond to delete' do
+      assert_equal 'bar', subject.properties.delete('foo')
+      assert_nil subject.properties['foo']
+    end
+
+  end
+
+  context 'Setting attributes' do
+    subject { Version.new }
+
+    setup do
+      subject.attributes = {'foo'=>'bar', 'title'=>'test', 'backup' => 'please'}
+    end
+
+    should 'set rails attributes' do
+      assert_equal 'test', subject.title
+    end
+
+    should 'set properties' do
+      assert_equal Hash['foo'=>'bar'], subject.properties
+    end
+
+    should 'call native methods' do
+      assert_equal 'please', subject.backup
+    end
+  end
+
+  context 'Initializing an object' do
+    subject { Version.new('foo'=>'bar', 'title'=>'test', 'backup' => 'please') }
+
+    should 'set rails attributes' do
+      assert_equal 'test', subject.title
+    end
+
+    should 'set properties' do
+      assert_equal Hash['foo'=>'bar'], subject.properties
+    end
+
+    should 'call native methods' do
+      assert_equal 'please', subject.backup
+    end
+  end
+
+  context 'Updating attributes' do
+    setup do
+      version = Version.create('title' => 'first', 'tic' => 'tac')
+      @version = Version.find(version.id)
+      assert subject.update_attributes('foo'=>'bar', 'title'=>'test', 'backup' => 'please')
+    end
+
+    subject { @version }
+
+    should 'update rails attributes' do
+      assert_equal 'test', subject.title
+    end
+
+    should 'update properties' do
+      assert_equal Hash['tic' => 'tac', 'foo'=>'bar'], subject.properties
+    end
+
+    should 'call native methods' do
+      assert_equal 'please', subject.backup
+    end
+  end
+
+  context 'Saving attributes' do
+    setup do
+      version  = Version.create('title'=>'test', 'foo' => 'bar', 'backup' => 'please')
+      @version = Version.find(version.id)
+    end
+
+    subject { @version }
+
+    should 'save rails attributes' do
+      assert_equal 'test', subject.title
+    end
+
+    should 'save properties' do
+      assert_equal 'bar', subject.prop['foo']
+    end
+
+    should 'destroy' do
+      assert subject.destroy
+      assert subject.frozen?
+    end
+
+    should 'delete' do
+      assert subject.delete
+      assert subject.frozen?
+    end
+  end
+
+  context 'Saving empty attributes' do
+    subject { Version.new('foo' => 'bar') }
+
+    setup do
+      subject.prop.delete('foo')
+      subject.save
+    end
+
+    should 'save nil in database' do
+      assert_nil subject['properties']
+    end
+
+    should 'save nil when last property is removed' do
+      subject = Version.create('foo' => 'bar', 'tic' => 'tac')
+      subject.attributes = {'foo' => nil}
+      subject.update_attributes('foo' => nil)
+      assert_equal ['tic'], subject.properties.keys
+      subject.properties.delete('tic')
+      subject.save
+      assert_nil subject['properties']
+    end
+  end
+
+  context 'Saving without changes to properties' do
+    setup do
+      version = Version.create('title' => 'test', 'foo' => 'bar')
+      @version = Version.find(version.id)
+      subject.update_attributes('title' => 'updated')
+    end
+
+    subject { @version }
+
+    should 'not alter properties' do
+      assert_equal Hash['foo' => 'bar'], subject.properties
+    end
+  end
+
+  context 'Find' do
+    subject { Version.create('title'=>'find me', 'foo' => 'bar') }
+
+    should 'find by id' do
+      version = Version.find(subject)
+      assert_equal 'bar', version.prop['foo']
+    end
+  end
+
+  context 'A modified version receiving :reload_properties' do
+    should 'return properties stored in database' do
+      subject = Version.create('title'=>'find me', 'foo' => 'bar')
+      subject.prop['foo'] = 'Babar'
+      assert_equal 'Babar', subject.prop['foo']
+      subject.reload_properties!
+      assert_equal 'bar', subject.prop['foo']
+    end
+  end
+
+  context 'Type cast' do
+    DataType = Class.new(ActiveRecord::Base) do
+      set_table_name 'dummies'
+      include Property
+      property do |p|
+        p.string 'mystring'
+        p.integer 'myinteger'
+        p.float 'myfloat'
+        p.datetime 'mytime'
+      end
+    end
+
+    should 'save and read String' do
+      subject = DataType.create('mystring' => 'some string')
+      subject.reload
+      assert_kind_of String, subject.prop['mystring']
+    end
+
+    should 'save and read Integer' do
+      subject = DataType.create('myinteger' => 123)
+      subject.reload
+      assert_kind_of Integer, subject.prop['myinteger']
+    end
+
+    should 'save and read Float' do
+      subject = DataType.create('myfloat' => 12.3)
+      subject.reload
+      assert_kind_of Float, subject.prop['myfloat']
+    end
+
+    should 'save and read Time' do
+      subject = DataType.create('mytime' => Time.new)
+      subject.reload
+      assert_kind_of Time, subject.prop['mytime']
+    end
+
+    context 'from a String' do
+      should 'parse integer values' do
+        subject = DataType.create('myinteger' => '123')
+        subject.reload
+        assert_kind_of Integer, subject.prop['myinteger']
+        assert_equal 123, subject.prop['myinteger']
+      end
+
+      should 'parse float values' do
+        subject = DataType.create('myfloat' => '12.3')
+        subject.reload
+        assert_kind_of Float, subject.prop['myfloat']
+        assert_equal 12.3, subject.prop['myfloat']
+      end
+
+      should 'parse time values' do
+        subject = DataType.create('mytime' => '2010-02-10 21:21')
+        subject.reload
+        assert_kind_of Time, subject.prop['mytime']
+        assert_equal Time.utc(2010,02,10,21,21), subject.prop['mytime']
+      end
+
+      context 'in the model' do
+        should 'parse integer values' do
+          subject = DataType.new
+          subject.prop['myinteger'] = '123'
+          assert_kind_of Integer, subject.prop['myinteger']
+          assert_equal 123, subject.prop['myinteger']
+        end
+
+        should 'parse float values' do
+          subject = DataType.new
+          subject.prop['myfloat'] = '12.3'
+          assert_kind_of Float, subject.prop['myfloat']
+          assert_equal 12.3, subject.prop['myfloat']
+        end
+
+        should 'parse time values' do
+          subject = DataType.new
+          subject.prop['mytime'] = '2010-02-10 21:21'
+          assert_kind_of Time, subject.prop['mytime']
+          assert_equal Time.utc(2010,02,10,21,21), subject.prop['mytime']
+        end
+      end
+    end
+  end
+
+
+end