property 0.8.2 → 0.9.0

data/History.txt

@@ -1,41 +1,51 @@
+== 0.9.0 2010-03-20
+
+* 3 major enhancement
+  * Added simple index support.
+  * Added complex index support.
+  * Added simple hooks for indexes when properties are stored in a different model.
+
+* 1 minor enhancement
+  * Added 'has_column?' to schema.
+
 == 0.8.2 2010-02-16
 
 * 2 minor enhancements
-  * fixed a bug where properties would be dumped even if none changed
-  * fixed a bug where properties would not be dumped soon enough to mark
-    storage object as dirty
+  * Fixed a bug where properties would be dumped even if none changed.
+  * Fixed a bug where properties would not be dumped soon enough to mark
+    storage object as dirty.
 
 == 0.8.1 2010-02-14
 
 * 2 major enhancement
-  * enabled behavior method definitions
-  * enabled external storage with 'store_properties_in' method
+  * Enabled behavior method definitions.
+  * Enabled external storage with 'store_properties_in' method.
 
 == 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
+  * 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
-  * enabled instance property definitions
-  * Time is now natively parsed by json (no typecast)
+  * Enabled instance property definitions.
+  * Time is now natively parsed by json (no typecast).
 
 == 0.6.0 2010-02-11
 
 * 1 major enhancement
-  * enabled ruby accessors in model
+  * Enabled ruby accessors in model.
 
 == 0.5.0 2010-02-11
 
 * 2 major enhancement
-  * changed plugin into gem
-  * using Rails columns to handle defaults and type casting
+  * Changed plugin into gem.
+  * Using Rails columns to handle defaults and type casting.
 
 == 0.4.0 2010-02-02
 
 * 1 major enhancement
-  * initial plugin code
+  * Initial plugin code.

data/lib/property.rb

@@ -5,15 +5,21 @@ require 'property/column'
 require 'property/behavior'
 require 'property/schema'
 require 'property/declaration'
+require 'property/db'
+require 'property/index'
 require 'property/serialization/json'
 require 'property/core_ext/time'
 
 module Property
-  VERSION = '0.8.2'
+  VERSION = '0.9.0'
 
   def self.included(base)
     base.class_eval do
-      include ::Property::Attribute
+      include Attribute
+      include Serialization::JSON
+      include Declaration
+      include Dirty
+      include Index
     end
   end
 

data/lib/property/attribute.rb

@@ -17,9 +17,6 @@ module Property
 
       base.class_eval do
         include InstanceMethods
-        include Serialization::JSON
-        include Declaration
-        include Dirty
 
         store_properties_in self
 

data/lib/property/behavior.rb

@@ -17,6 +17,7 @@ module Property
     def initialize(name)
       @name    = name
       @included_in_schemas = []
+      @group_indexes   = []
       @accessor_module = build_accessor_module
     end
 
@@ -25,6 +26,24 @@ module Property
       @columns ||= {}
     end
 
+    # Return a list of index definitions in the form [type, key, proc_or_nil]
+    def indexes
+      columns.values.select do |c|
+        c.indexed?
+      end.map do |c|
+        if c.index == true
+          [c.type, c.name]
+        else
+          [c.type, c.name, c.index]
+        end
+      end + @group_indexes
+    end
+
+    # Return true if the Behavior contains the given column (property).
+    def has_column?(name)
+      column_names.include?(name)
+    end
+
     # Return the list of column names.
     def column_names
       columns.keys
@@ -64,6 +83,12 @@ module Property
       end
     end
 
+    # @internal
+    def add_index(type, proc)
+      #                 type,  key, proc
+      @group_indexes << [type, nil, proc]
+    end
+
     private
       def build_accessor_module
         accessor_module = Module.new
@@ -95,6 +120,21 @@ module Property
               behavior.add_column(Property::Column.new(name, nil, klass, options))
             end
 
+            # This is used to create complex indexes with the following syntax:
+            #
+            #   p.index(:text) do |r| # r = record
+            #     {
+            #       "high"           => "gender:#{r.gender} age:#{r.age} name:#{r.name}",
+            #       "name_#{r.lang}" => r.name, # multi-lingual index
+            #     }
+            #   end
+            #
+            # The first argument is the type (used to locate the table where the data will be stored) and the block
+            # will be yielded with the record and should return a hash of key => value pairs.
+            def index(type, &block)
+              behavior.add_index(type, block)
+            end
+
             alias actions class_eval
           end
         end

data/lib/property/column.rb

@@ -6,6 +6,8 @@ module Property
   # such as name, type and options. It is also used to typecast from strings to
   # the proper type (date, integer, float, etc).
   class Column < ::ActiveRecord::ConnectionAdapters::Column
+    attr_accessor :index
+
     SAFE_NAMES_REGEXP = %r{\A[a-zA-Z_]+\Z}
 
     def initialize(name, default, type, options={})
@@ -28,7 +30,7 @@ module Property
     end
 
     def indexed?
-      @indexed
+      @index
     end
 
     def default_for(owner)
@@ -59,7 +61,7 @@ module Property
 
     private
       def extract_property_options(options)
-        @indexed = options.delete(:indexed)
+        @index = options.delete(:index) || options.delete(:indexed)
       end
 
       def extract_default(default)

data/lib/property/db.rb

@@ -0,0 +1,52 @@
+# FIXME: we should patch the connection adapters instead of having 'case, when' evaluated each time
+# For example:
+# module ActiveRecord
+#   module ConnectionAdapters
+#     class MysqlAdapter
+#       include Zena::Db::MysqlAdditions
+#     end
+#   end
+# end
+
+
+module Property
+
+  # This module is just a helper to fetch raw data from the database and could be removed in future versions of Rails
+  # if the framework provides these methods.
+  module Db
+    extend self
+
+    def adapter
+      connection.class.to_s[/ConnectionAdapters::(.*)Adapter/,1].downcase
+    end
+
+    def execute(*args)
+      ActiveRecord::Base.connection.execute(*args)
+    end
+
+    def connection
+      ActiveRecord::Base.connection
+    end
+
+    # Insert a list of values (multicolumn insert). The values should be properly escaped before
+    # being passed to this method.
+    def insert_many(table, columns, values)
+      values = values.compact.uniq
+      case adapter
+      when 'sqlite3'
+        pre_query = "INSERT INTO #{table} (#{columns.join(',')}) VALUES "
+        values.each do |v|
+          execute pre_query + "(#{v.join(',')})"
+        end
+      else
+        values = values.map {|v| "(#{v.join(',')})"}.join(', ')
+        execute "INSERT INTO #{table} (#{columns.map{|c| "`#{c}`"}.join(',')}) VALUES #{values}"
+      end
+    end
+
+    def fetch_attributes(attributes, table_name, sql)
+      sql = "SELECT #{attributes.map{|a| connection.quote_column_name(a)}.join(',')} FROM #{table_name} WHERE #{sql}"
+      connection.select_all(sql)
+    end
+  end # Db
+end # Property

data/lib/property/declaration.rb

@@ -38,13 +38,18 @@ module Property
         schema.behave_like behavior
       end
 
-      # Use this class method to declare properties that will be used in your models.
+      # Use this class method to declare properties and indexes that will be used in your models.
       # Example:
-      #  property.string 'phone', :default => ''
+      #  property.string 'phone', :default => '', :indexed => true
       #
       # You can also use a block:
       #  property do |p|
       #    p.string 'phone', 'name', :default => ''
+      #    p.index(:string) do |r|
+      #      {
+      #        "name_#{r.lang}" => r.name,
+      #      }
+      #    end
       #  end
       def property(&block)
         schema.behavior.property(&block)

data/lib/property/index.rb

@@ -0,0 +1,131 @@
+require 'versions/after_commit' # we need Versions gem's 'after_commit'
+
+module Property
+
+  # Property::Declaration module is used to declare property definitions in a Class. The module
+  # also manages property inheritence in sub-classes.
+  module Index
+
+    def self.included(base)
+      base.class_eval do
+        extend  ClassMethods
+        include InstanceMethods
+        before_save :property_index
+        before_destroy :property_index_destroy
+      end
+    end
+
+    module ClassMethods
+    end
+
+    module InstanceMethods
+
+      private
+        # Retrieve the current indexes for a given group (:string, :text, etc)
+        def get_indexes(group_name)
+          return {} if new_record?
+          res = {}
+          Property::Db.fetch_attributes(['key', 'value'], index_table_name(group_name), index_reader_sql).each do |row|
+            res[row['key']] = row['value']
+          end
+          res
+        end
+
+        def index_reader_sql
+          index_reader.map {|k, v| "#{k} = #{self.class.connection.quote(v)}"}.join(' AND ')
+        end
+
+        def index_reader
+          {index_foreign_key => self.id}
+        end
+
+        alias index_writer index_reader
+
+        def index_table_name(group_name)
+          "i_#{group_name}_#{self.class.table_name}"
+        end
+
+        def index_foreign_key
+          self.class.table_name.singularize.foreign_key
+        end
+
+        # This method prepares the index
+        def property_index
+          connection     = self.class.connection
+          reader_sql     = index_reader_sql
+          foreign_keys   = nil
+          foreign_values = nil
+
+          schema.index_groups.each do |group_name, definitions|
+            old_indexes = get_indexes(group_name)
+            cur_indexes = {}
+            definitions.each do |key, proc|
+              if key
+                value = prop[key]
+                if !value.blank?
+                  if proc
+                    cur_indexes.merge!(proc.call(self))
+                  else
+                    cur_indexes[key] = value
+                  end
+                end
+              else
+                cur_indexes.merge!(proc.call(self))
+              end
+            end
+
+            old_keys = old_indexes.keys
+            cur_keys = cur_indexes.keys
+
+            new_keys = cur_keys - old_keys
+            del_keys = old_keys - cur_keys
+            upd_keys = cur_keys & old_keys
+
+            after_commit do
+              table_name  = index_table_name(group_name)
+
+              upd_keys.each do |key|
+                value = cur_indexes[key]
+                if value.blank?
+                  del_keys << key
+                else
+                  connection.execute "UPDATE #{table_name} SET value = #{connection.quote(cur_indexes[key])} WHERE #{reader_sql} AND key = #{connection.quote(key)}"
+                end
+              end
+
+              if !del_keys.empty?
+                connection.execute "DELETE FROM #{table_name} WHERE #{reader_sql} AND key IN (#{del_keys.map{|key| connection.quote(key)}.join(',')})"
+              end
+
+              new_keys.reject! {|k| cur_indexes[k].blank? }
+              if !new_keys.empty?
+                # we evaluate this now to have the id on record creation
+                foreign_keys   ||= index_writer.keys
+                foreign_values ||= foreign_keys.map {|k| index_writer[k]}
+
+                Property::Db.insert_many(
+                  table_name,
+                  foreign_keys + ['key', 'value'],
+                  new_keys.map do |key|
+                    foreign_values + [connection.quote(key), connection.quote(cur_indexes[key])]
+                  end
+                )
+              end
+            end
+          end
+        end
+
+        # Remove all index entries on destroy
+        def property_index_destroy
+          connection  = self.class.connection
+          foreign_key = index_foreign_key
+          current_id  = self.id
+          schema.index_groups.each do |group_name, definitions|
+            after_commit do
+              connection.execute "DELETE FROM #{index_table_name(group_name)} WHERE #{foreign_key} = #{current_id}"
+            end
+          end
+        end
+    end
+  end
+end

data/lib/property/schema.rb

@@ -55,6 +55,15 @@ module Property
       columns.keys
     end
 
+    # Return true if the schema has a property with the given name.
+    def has_column?(name)
+      name = name.to_s
+      [@behaviors].flatten.each do |behavior|
+        return true if behavior.has_column?(name)
+      end
+      false
+    end
+
     # Return column definitions from all included behaviors.
     def columns
       columns = {}
@@ -64,6 +73,17 @@ module Property
       columns
     end
 
+    # Return a hash with indexed types as keys and index definitions as values.
+    def index_groups
+      index_groups = {}
+      @behaviors.flatten.uniq.each do |b|
+        b.indexes.each do |list|
+          (index_groups[list.first] ||= []) << list[1..-1]
+        end
+      end
+      index_groups
+    end
+
     private
       def include_behavior(behavior)
         return if behaviors.include?(behavior)

data/property.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{property}
-  s.version = "0.8.2"
+  s.version = "0.9.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-16}
+  s.date = %q{2010-03-20}
   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 = [
@@ -27,8 +27,10 @@ Gem::Specification.new do |s|
      "lib/property/behavior.rb",
      "lib/property/column.rb",
      "lib/property/core_ext/time.rb",
+     "lib/property/db.rb",
      "lib/property/declaration.rb",
      "lib/property/dirty.rb",
+     "lib/property/index.rb",
      "lib/property/properties.rb",
      "lib/property/schema.rb",
      "lib/property/serialization/json.rb",
@@ -42,6 +44,9 @@ Gem::Specification.new do |s|
      "test/unit/property/behavior_test.rb",
      "test/unit/property/declaration_test.rb",
      "test/unit/property/dirty_test.rb",
+     "test/unit/property/index_complex_test.rb",
+     "test/unit/property/index_foreign_test.rb",
+     "test/unit/property/index_simple_test.rb",
      "test/unit/property/validation_test.rb",
      "test/unit/serialization/json_test.rb",
      "test/unit/serialization/marshal_test.rb",
@@ -51,7 +56,7 @@ Gem::Specification.new do |s|
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
   s.rubyforge_project = %q{property}
-  s.rubygems_version = %q{1.3.5}
+  s.rubygems_version = %q{1.3.6}
   s.summary = %q{model properties wrap into a single database column}
   s.test_files = [
     "test/fixtures.rb",
@@ -61,6 +66,9 @@ Gem::Specification.new do |s|
      "test/unit/property/behavior_test.rb",
      "test/unit/property/declaration_test.rb",
      "test/unit/property/dirty_test.rb",
+     "test/unit/property/index_complex_test.rb",
+     "test/unit/property/index_foreign_test.rb",
+     "test/unit/property/index_simple_test.rb",
      "test/unit/property/validation_test.rb",
      "test/unit/serialization/json_test.rb",
      "test/unit/serialization/marshal_test.rb",

data/test/fixtures.rb

@@ -1,8 +1,8 @@
 
 class Employee < ActiveRecord::Base
   include Property
-  property.string 'first_name', :default => '', :indexed => true
-  property.string 'last_name',  :default => '', :indexed => true
+  property.string 'first_name', :default => '', :index => true
+  property.string 'last_name',  :default => '', :index => true
   property.float  'age'
 end
 
@@ -46,25 +46,51 @@ end
 begin
   class PropertyMigration < ActiveRecord::Migration
     def self.down
-      drop_table "employees"
-      drop_table "versions"
+      drop_table 'employees'
+      drop_table 'versions'
+      drop_table 'string_index'
     end
+
     def self.up
-      create_table "employees" do |t|
-        t.string "type"
-        t.text   "properties"
+      create_table 'employees' do |t|
+        t.string 'type'
+        t.text   'properties'
       end
 
-      create_table "versions" do |t|
+      create_table 'versions' do |t|
         t.integer 'employee_id'
-        t.string  "properties"
-        t.string  "title"
-        t.string  "comment"
+        t.string  'properties'
+        t.string  'title'
+        t.string  'comment'
+        t.string  'lang'
         t.timestamps
       end
 
-      create_table "dummies" do |t|
-        t.text    "properties"
+      create_table 'dummies' do |t|
+        t.text    'properties'
+      end
+
+      # index strings in employees
+      create_table 'i_string_employees' do |t|
+        t.integer 'employee_id'
+        t.integer 'version_id'
+        t.string  'key'
+        t.string  'value'
+      end
+
+      # index integer in employees
+      create_table 'i_integer_employees' do |t|
+        t.integer 'employee_id'
+        t.integer 'version_id'
+        t.string  'key'
+        t.integer 'value'
+      end
+
+      # index text in employees
+      create_table 'i_text_employees' do |t|
+        t.integer 'employee_id'
+        t.string  'key'
+        t.text    'value'
       end
     end
   end

data/test/test_helper.rb

@@ -7,14 +7,4 @@ require 'active_record'
 require 'property'
 require 'shoulda_macros/serialization'
 require 'fixtures'
-
-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
+require 'active_support/test_case'

data/test/unit/property/behavior_test.rb

@@ -52,11 +52,17 @@ class BehaviorTest < Test::Unit::TestCase
       assert_equal 10, column.default
     end
 
-    should 'allow indexed option' do
-      subject.property.string('rolodex', :indexed => true)
+    should 'allow index option' do
+      subject.property.string('rolodex', :index => true)
       column = subject.columns['rolodex']
       assert column.indexed?
     end
+
+    should 'return a list of indexes on indexes' do
+      subject.property.string('rolodex', :index => true)
+      subject.property.integer('foobar', :index => true)
+      assert_equal %w{integer string}, subject.indexes.map {|i| i[0].to_s }.sort
+    end
   end # A Behavior
 
   context 'Adding a behavior' do

data/test/unit/property/declaration_test.rb

@@ -13,8 +13,12 @@ class DeclarationTest < Test::Unit::TestCase
         assert_equal %w{age first_name language last_name}, @klass.schema.column_names.sort
       end
 
+      should 'see its property columns in schema' do
+        assert @klass.schema.has_column?('language')
+      end
+
       should 'not back-propagate definitions to parent' do
-        assert !@klass.superclass.schema.columns.include?('language')
+        assert !@klass.superclass.schema.has_column?('language')
       end
 
       should 'inherit new definitions in parent' do
@@ -157,8 +161,8 @@ class DeclarationTest < Test::Unit::TestCase
       assert_equal 10, column.default
     end
 
-    should 'allow indexed option' do
-      subject.property.string('rolodex', :indexed => true)
+    should 'allow index option' do
+      subject.property.string('rolodex', :index => true)
       column = subject.schema.columns['rolodex']
       assert column.indexed?
     end
@@ -225,7 +229,7 @@ class DeclarationTest < Test::Unit::TestCase
                  :foreign_key => 'employee_id'
     end
 
-    Contact = Class.new(ActiveRecord::Base) do
+    class Contact < ActiveRecord::Base
       attr_accessor :assertion
       before_save :before_save_assertion
       set_table_name :employees

data/test/unit/property/index_complex_test.rb

@@ -0,0 +1,153 @@
+require 'test_helper'
+require 'fixtures'
+
+class IndexComplexTest < ActiveSupport::TestCase
+  class IndexedStringEmp < ActiveRecord::Base
+    set_table_name :i_string_employees
+  end
+
+  class IndexedIntegerEmp < ActiveRecord::Base
+    set_table_name :i_integer_employees
+  end
+
+  class IndexedTextEmp < ActiveRecord::Base
+    set_table_name :i_text_employees
+  end
+
+  # Complex index definition class
+  class Person < ActiveRecord::Base
+    include Property
+    set_table_name :employees
+
+    def save_with_raise
+      if name == 'raise'
+        raise Exception.new
+      else
+        save_without_raise
+      end
+    end
+    alias_method_chain :save, :raise
+
+    property do |p|
+      p.string  'name'
+      # only runs if 'age' is not blank
+      p.integer 'age', :index => Proc.new {|r| {'age' => r.age == 0 ? nil : r.age + 10}}
+      p.string  'gender'
+      p.string  'lang'
+
+      p.index(:text) do |r| # r = record
+        {
+          "high"           => "gender:#{r.gender} age:#{r.age} name:#{r.name}",
+          "name_#{r.lang}" => r.name, # multi-lingual index
+        }
+      end
+    end
+  end
+
+  context 'A schema from a class with complex index definitions' do
+    subject do
+      Person.schema
+    end
+
+    should 'return a Hash on index_groups' do
+      assert_kind_of Hash, subject.index_groups
+    end
+
+    should 'group indexes by type' do
+      assert_equal %w{integer text}, subject.index_groups.keys.map(&:to_s).sort
+    end
+  end
+
+  context 'A class with complex index definition' do
+    subject do
+      Person
+    end
+
+    context 'on record creation' do
+      should 'create index entries' do
+        assert_difference('IndexedTextEmp.count', 2) do
+          Person.create('name' => 'Juan', 'lang' => 'es', 'gender' => 'M', 'age' => 34)
+        end
+      end
+
+      should 'not create index entries for blank values' do
+        assert_difference('IndexedIntegerEmp.count', 0) do
+          Person.create('name' => 'Pavlov')
+        end
+      end
+
+      should 'store key and value pairs linked to the model' do
+        person = Person.create('name' => 'Juan', 'lang' => 'es', 'gender' => 'M', 'age' => 34)
+        high_index, name_index = IndexedTextEmp.all(:conditions => {:employee_id => person.id}, :order => 'key asc')
+        assert_equal 'high', high_index.key
+        assert_equal 'gender:M age:34 name:Juan', high_index.value
+        assert_equal 'name_es', name_index.key
+        assert_equal 'Juan', name_index.value
+      end
+
+      should 'execute index Proc to build value' do
+        person = Person.create('name' => 'Juan', 'lang' => 'es', 'gender' => 'M', 'age' => 34)
+        int_index = IndexedIntegerEmp.first(:conditions => {:employee_id => person.id})
+        assert_equal 44, int_index.value
+      end
+
+      should 'remove blank values built from proc execution' do
+        person = Person.create('name' => 'Juan', 'lang' => 'es', 'gender' => 'M', 'age' => 34)
+        assert_difference('IndexedIntegerEmp.count', -1) do
+          person.update_attributes('age' => 0)
+        end
+      end
+    end
+
+    context 'on record update' do
+      setup do
+        @person = Person.create('name' => 'Juan', 'lang' => 'es', 'gender' => 'M', 'age' => 34)
+      end
+
+      should 'update index entries' do
+        high_index, name_index = IndexedTextEmp.all(:conditions => {:employee_id => @person.id}, :order => 'key asc')
+        assert_difference('IndexedTextEmp.count', 0) do
+          @person.update_attributes('name' => 'Xavier')
+        end
+
+        high_index = IndexedTextEmp.find(high_index.id) # reload (make sure the record has been updated, not recreated)
+        name_index = IndexedTextEmp.find(name_index.id) # reload (make sure the record has been updated, not recreated)
+
+        assert_equal 'high', high_index.key
+        assert_equal 'gender:M age:34 name:Xavier', high_index.value
+        assert_equal 'name_es', name_index.key
+        assert_equal 'Xavier', name_index.value
+      end
+
+      context 'with key alterations' do
+        should 'remove and create new keys' do
+          high_index, name_index = IndexedTextEmp.all(:conditions => {:employee_id => @person.id}, :order => 'key asc')
+          assert_difference('IndexedTextEmp.count', 0) do
+            @person.update_attributes('lang' => 'en', 'name' => 'John')
+          end
+
+          assert IndexedTextEmp.find(high_index.id)
+          assert_nil IndexedTextEmp.find_by_id(name_index.id)
+
+          high_index, name_index = IndexedTextEmp.all(:conditions => {:employee_id => @person.id}, :order => 'key asc')
+
+          assert_equal 'high', high_index.key
+          assert_equal 'gender:M age:34 name:John', high_index.value
+          assert_equal 'name_en', name_index.key
+          assert_equal 'John', name_index.value
+        end
+      end
+    end
+
+    context 'on record destruction' do
+      should 'remove index entries' do
+        person = Person.create('name' => 'Juan', 'lang' => 'es', 'gender' => 'M', 'age' => 34)
+        assert_difference('IndexedTextEmp.count', -2) do
+          assert_difference('IndexedIntegerEmp.count', -1) do
+            person.destroy
+          end
+        end
+      end
+    end
+  end
+end

data/test/unit/property/index_foreign_test.rb

@@ -0,0 +1,232 @@
+require 'test_helper'
+require 'fixtures'
+
+class IndexForeignTest < ActiveSupport::TestCase
+  class IndexedStringEmp < ActiveRecord::Base
+    set_table_name :i_string_employees
+  end
+
+  class IndexedIntegerEmp < ActiveRecord::Base
+    set_table_name :i_integer_employees
+  end
+
+  class IndexedTextEmp < ActiveRecord::Base
+    set_table_name :i_text_employees
+  end
+
+  class Version < ActiveRecord::Base
+    belongs_to :contact, :class_name => 'IndexForeignTest::Contact',
+               :foreign_key => 'employee_id'
+  end
+
+  class Contact < ActiveRecord::Base
+    set_table_name :employees
+
+    has_many :versions, :class_name => 'IndexForeignTest::Version'
+    def version
+      @version ||= begin
+        if new_record?
+          versions.build
+        else
+          Version.first(:conditions => ['employee_id = ?', self.id]) || versions.build
+        end
+      end
+    end
+
+    def new_version!
+      @version = versions.build
+    end
+
+    def lang=(l)
+      version.lang = l
+    end
+
+    include Property
+    store_properties_in :version
+
+    property do |p|
+      p.string  'name'
+      p.integer 'age', :indexed => true
+      p.string  'gender'
+
+      p.index(:string) do |r| # r = record
+        {
+          "high"                   => "gender:#{r.gender} age:#{r.age} name:#{r.name}",
+          "name_#{r.version.lang}" => r.name, # multi-lingual index
+        }
+      end
+    end
+
+    def index_reader
+      {'version_id' => version.id}
+    end
+
+    # Foreign index: we store the 'employee_id' in the index to get back directly to non-versioned class Contact (through employee_id key).
+    def index_writer
+      {'version_id' => version.id, 'employee_id' => self.id}
+    end
+  end
+
+  context 'A class with foreign index definition' do
+    subject do
+      Contact
+    end
+
+    context 'on record creation' do
+      should 'create index entries' do
+        assert_difference('IndexedStringEmp.count', 2) do
+          Contact.create('name' => 'Juan', 'lang' => 'es', 'gender' => 'M', 'age' => 34)
+        end
+      end
+
+      should 'store key and value pairs linked to the model' do
+        person = Contact.create('name' => 'Juan', 'lang' => 'es', 'gender' => 'M', 'age' => 34)
+        high_index, name_index = IndexedStringEmp.all(:conditions => {:version_id => person.version.id}, :order => 'key asc')
+        assert_equal 'high', high_index.key
+        assert_equal 'gender:M age:34 name:Juan', high_index.value
+        assert_equal 'name_es', name_index.key
+        assert_equal 'Juan', name_index.value
+      end
+
+      should 'store key and value pairs linked to the foreign model' do
+        person = Contact.create('name' => 'Juan', 'lang' => 'es', 'gender' => 'M', 'age' => 34)
+        high_index, name_index = IndexedStringEmp.all(:conditions => {:employee_id => person.id}, :order => 'key asc')
+        assert_equal 'high', high_index.key
+        assert_equal 'gender:M age:34 name:Juan', high_index.value
+        assert_equal 'name_es', name_index.key
+        assert_equal 'Juan', name_index.value
+      end
+    end
+
+    context 'on record update' do
+      setup do
+        @person = Contact.create('name' => 'Juan', 'lang' => 'es', 'gender' => 'M', 'age' => 34)
+      end
+
+      should 'update index entries' do
+        high_index, name_index = IndexedStringEmp.all(:conditions => {:employee_id => @person.id}, :order => 'key asc')
+        assert_difference('IndexedStringEmp.count', 0) do
+          @person.update_attributes('name' => 'Xavier')
+        end
+
+        high_index = IndexedStringEmp.find(high_index.id) # reload (make sure the record has been updated, not recreated)
+        name_index = IndexedStringEmp.find(name_index.id) # reload (make sure the record has been updated, not recreated)
+
+        assert_equal 'high', high_index.key
+        assert_equal 'gender:M age:34 name:Xavier', high_index.value
+        assert_equal 'name_es', name_index.key
+        assert_equal 'Xavier', name_index.value
+      end
+
+      context 'with key alterations' do
+        should 'remove and create new keys' do
+          high_index, name_index = IndexedStringEmp.all(:conditions => {:employee_id => @person.id}, :order => 'key asc')
+          assert_difference('IndexedStringEmp.count', 0) do
+            @person.update_attributes('lang' => 'en', 'name' => 'John')
+          end
+
+          assert IndexedStringEmp.find(high_index.id)
+          assert_nil IndexedStringEmp.find_by_id(name_index.id)
+
+          high_index, name_index = IndexedStringEmp.all(:conditions => {:employee_id => @person.id}, :order => 'key asc')
+
+          assert_equal 'high', high_index.key
+          assert_equal 'gender:M age:34 name:John', high_index.value
+          assert_equal 'name_en', name_index.key
+          assert_equal 'John', name_index.value
+        end
+      end
+    end
+
+    context 'on record update with a new version' do
+      should 'create new index entries' do
+        @person = Contact.create('name' => 'Juan', 'lang' => 'es', 'gender' => 'M', 'age' => 34)
+        high_index1, name_index1 = IndexedStringEmp.all(:conditions => {:version_id => @person.version.id}, :order => 'key asc')
+        @person.new_version!
+        assert_difference('IndexedStringEmp.count', 2) do
+          @person.update_attributes('name' => 'John', 'lang' => 'en')
+        end
+
+        high_index, name_index = IndexedStringEmp.all(:conditions => {:version_id => @person.version.id}, :order => 'key asc')
+        assert_not_equal high_index1.id, high_index.id
+        assert_not_equal name_index1.id, name_index.id
+
+        assert_equal 'high', high_index.key
+        assert_equal 'gender:M age:34 name:John', high_index.value
+        assert_equal 'name_en', name_index.key
+        assert_equal 'John', name_index.value
+      end
+
+      # ========== The context below is not really a test: it is used to example the index usage to sort
+      context 'in different languages' do
+        setup do
+          Contact.destroy_all
+          # People: Jean (John) and Jim
+          # sort order:
+          # fr: Jean, Jim
+          # en: Jim, John
+          @jean = Contact.create('name' => 'Jean', 'lang' => 'fr', 'gender' => 'M', 'age' => 34)
+          @jean.new_version!
+          @jean.update_attributes('name' => 'John', 'lang' => 'en')
+          @jim  = Contact.create('name' => 'Jim', 'lang' => 'fr', 'gender' => 'M', 'age' => 17)
+          @jim.new_version!
+          @jim.update_attributes('name' => 'Jim', 'lang' => 'en')
+        end
+
+        should 'create index entries to sort multilingual values' do
+          people_fr = Contact.find(:all, :joins  => "INNER JOIN i_string_employees AS ise ON ise.employee_id = employees.id AND ise.key = 'name_fr'",
+                                          :order => "ise.value asc")
+
+          people_en = Contact.find(:all, :joins  => "INNER JOIN i_string_employees AS ise ON ise.employee_id = employees.id AND ise.key = 'name_en'",
+                                          :order => "ise.value asc")
+
+          assert_equal [@jean.id, @jim.id], people_fr.map {|r| r.id}
+          assert_equal [@jim.id, @jean.id], people_en.map {|r| r.id}
+        end
+      end
+
+      # ========== The context below is not really a test: it is used to example the index usage to sort
+      context 'in different languages with missing translations' do
+        setup do
+          Contact.destroy_all
+          # People: Jean (John) and Jim
+          # sort order:
+          # fr: Jean, Jim
+          # en: Jim, John
+          @jean = Contact.create('name' => 'Jean', 'lang' => 'fr', 'gender' => 'M', 'age' => 34)
+          @jean.new_version!
+          @jean.update_attributes('name' => 'John', 'lang' => 'en')
+          @jim  = Contact.create('name' => 'Jim', 'lang' => 'en', 'gender' => 'M', 'age' => 17)
+          # no version for @jim in 'fr'
+        end
+
+        should 'create index entries to sort multilingual values' do
+          people_fr = Contact.find(:all, :joins  => "INNER JOIN i_string_employees AS ise ON ise.employee_id = employees.id AND ise.key = 'name_fr'",
+                                          :order => "ise.value asc")
+
+          people_en = Contact.find(:all, :joins  => "INNER JOIN i_string_employees AS ise ON ise.employee_id = employees.id AND ise.key = 'name_en'",
+                                          :order => "ise.value asc")
+
+          # This is what we would like to have (once we have found an SQL trick to get the record in 'en')
+          # assert_equal [@jean.id, @jim.id], people_fr.map {|r| r.id}
+
+          # But this is what we get
+          assert_equal [@jean.id], people_fr.map {|r| r.id}
+
+          assert_equal [@jim.id, @jean.id], people_en.map {|r| r.id}
+        end
+      end
+    end
+
+    context 'on record destruction' do
+      should 'remove index entries' do
+        person = Contact.create('name' => 'Juan', 'lang' => 'es', 'gender' => 'M', 'age' => 34)
+        assert_difference('IndexedStringEmp.count', -2) do
+          assert_difference('IndexedIntegerEmp.count', -1) do
+            person.destroy
+          end
+        end
+      end
+    end
+  end
+end

data/test/unit/property/index_simple_test.rb

@@ -0,0 +1,145 @@
+require 'test_helper'
+require 'fixtures'
+
+class IndexSimpleTest < ActiveSupport::TestCase
+  class IndexedStringEmp < ActiveRecord::Base
+    set_table_name :i_string_employees
+  end
+
+  class IndexedIntegerEmp < ActiveRecord::Base
+    set_table_name :i_integer_employees
+  end
+
+  # Simple index definition class
+  class Dog < ActiveRecord::Base
+    include Property
+    set_table_name :employees
+
+    def save_with_raise
+      if name == 'raise'
+        raise Exception.new
+      else
+        save_without_raise
+      end
+    end
+    alias_method_chain :save, :raise
+
+    property do |p|
+      p.string  'name', :index   => true
+      p.integer 'age',  :indexed => true # synonym
+    end
+  end
+
+  context 'A schema from a class with index definitions' do
+    subject do
+      Dog.schema
+    end
+
+    should 'return a Hash on index_groups' do
+      assert_kind_of Hash, subject.index_groups
+    end
+
+    should 'group indexes by type' do
+      assert_equal %w{integer string}, subject.index_groups.keys.map(&:to_s).sort
+    end
+  end
+
+  context 'A class with a simple index definition' do
+    subject do
+      Dog
+    end
+
+    context 'on record creation' do
+      should 'create index entries' do
+        assert_difference('IndexedStringEmp.count', 1) do
+          Dog.create('name' => 'Pavlov')
+        end
+      end
+
+      should 'not create index entries for blank values' do
+        assert_difference('IndexedIntegerEmp.count', 0) do
+          Dog.create('name' => 'Pavlov')
+        end
+      end
+
+      should 'store a key and value pair linked to the model' do
+        dog = Dog.create('name' => 'Pavlov')
+        index_string = IndexedStringEmp.first(:conditions => {:employee_id => dog.id})
+        assert_equal 'Pavlov', index_string.value
+        assert_equal 'name', index_string.key
+      end
+    end
+
+    context 'on record update' do
+      setup do
+        @dog = Dog.create('name' => 'Pavlov')
+      end
+
+      should 'update index entries' do
+        index_string = IndexedStringEmp.first(:conditions => {:employee_id => @dog.id})
+        assert_difference('IndexedStringEmp.count', 0) do
+          @dog.update_attributes('name' => 'Médor')
+        end
+
+        index_string = IndexedStringEmp.find(index_string.id)
+        assert_equal 'Médor', index_string.value
+        assert_equal 'name', index_string.key
+      end
+
+      should 'not create index entries for blank values' do
+        assert_difference('IndexedIntegerEmp.count', 0) do
+          @dog.update_attributes('name' => 'Médor')
+        end
+      end
+      
+      should 'remove blank values' do
+        assert_difference('IndexedStringEmp.count', -1) do
+          @dog.update_attributes('name' => '')
+        end
+      end
+
+      should 'create new entries for new keys' do
+        assert_difference('IndexedIntegerEmp.count', 1) do
+          @dog.update_attributes('age' => 7)
+        end
+      end
+
+      should 'store a key and value pair linked to the model' do
+        @dog.update_attributes('age' => 7)
+        index_int = IndexedIntegerEmp.first(:conditions => {:employee_id => @dog.id})
+        assert_equal 7, index_int.value
+        assert_equal 'age', index_int.key
+      end
+
+      context 'that fails during save' do
+        setup do
+          @dog = Dog.create('name' => 'Pavlov')
+        end
+
+        should 'not alter indexes' do
+          assert_difference('IndexedIntegerEmp.count', 0) do
+            assert_raises(Exception) do
+              @dog.update_attributes('name' => 'raise')
+            end
+          end
+
+          index_string = IndexedStringEmp.first(:conditions => {:employee_id => @dog.id})
+          assert_equal 'Pavlov', index_string.value
+          assert_equal 'name', index_string.key
+        end
+
+      end
+    end
+
+    context 'on record destruction' do
+      should 'remove index entries' do
+        dog = Dog.create('name' => 'Pavlov', 'age' => 7)
+        assert_difference('IndexedStringEmp.count', -1) do
+          assert_difference('IndexedIntegerEmp.count', -1) do
+            dog.destroy
+          end
+        end
+      end
+    end
+  end
+end

data/test/unit/property/validation_test.rb

@@ -68,11 +68,11 @@ class ValidationTest < Test::Unit::TestCase
   end # When setting a property
 
   context 'On a class with default property values' do
-    Cat = Class.new(ActiveRecord::Base) do
+    class Cat < ActiveRecord::Base
       attr_accessor :encoding
-
       set_table_name 'dummies'
-      include Property::Attribute
+
+      include Property
       property do |p|
         p.string 'eat', :default => 'mouse'
         p.string 'name'

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: property
 version: !ruby/object:Gem::Version 
-  version: 0.8.2
+  prerelease: false
+  segments: 
+  - 0
+  - 9
+  - 0
+  version: 0.9.0
 platform: ruby
 authors: 
 - Renaud Kern
@@ -10,29 +15,33 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-16 00:00:00 +01:00
+date: 2010-03-20 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: shoulda
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
         version: "0"
-    version: 
+  type: :development
+  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: activerecord
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
         version: "0"
-    version: 
+  type: :runtime
+  version_requirements: *id002
 description: Wrap model properties into a single database column and declare properties from within the model.
 email: gaspard@teti.ch
 executables: []
@@ -53,8 +62,10 @@ files:
 - lib/property/behavior.rb
 - lib/property/column.rb
 - lib/property/core_ext/time.rb
+- lib/property/db.rb
 - lib/property/declaration.rb
 - lib/property/dirty.rb
+- lib/property/index.rb
 - lib/property/properties.rb
 - lib/property/schema.rb
 - lib/property/serialization/json.rb
@@ -68,6 +79,9 @@ files:
 - test/unit/property/behavior_test.rb
 - test/unit/property/declaration_test.rb
 - test/unit/property/dirty_test.rb
+- test/unit/property/index_complex_test.rb
+- test/unit/property/index_foreign_test.rb
+- test/unit/property/index_simple_test.rb
 - test/unit/property/validation_test.rb
 - test/unit/serialization/json_test.rb
 - test/unit/serialization/marshal_test.rb
@@ -85,18 +99,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: property
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: model properties wrap into a single database column
@@ -108,6 +124,9 @@ test_files:
 - test/unit/property/behavior_test.rb
 - test/unit/property/declaration_test.rb
 - test/unit/property/dirty_test.rb
+- test/unit/property/index_complex_test.rb
+- test/unit/property/index_foreign_test.rb
+- test/unit/property/index_simple_test.rb
 - test/unit/property/validation_test.rb
 - test/unit/serialization/json_test.rb
 - test/unit/serialization/marshal_test.rb