property 1.2.0 → 2.0.0

data/History.txt

@@ -1,3 +1,17 @@
+== 2.0.0
+
+* Major enhancements
+  * Rewrite of the core engine to remove all the metaclass and anonymous module codes (generated memory leaks).
+  * Removed "actions" to create methods in a Role (you have to define them in the host class instead).
+  * Not defining accessor methods in Roles (using method missing instead). Accessors in Schema are defined directly in the class.
+  * Not checking for redefined methods anymore.
+
+== 1.3.0 2010-11-9 (not released)
+
+* Major enhancements
+  * Removed 'included_in' check (the same property can now be redefined)
+  * Added support for field indices (as columns in the owner table).
+
 == 1.2.0 2010-09-26
 
 * Major enhancements

data/README.rdoc

@@ -14,11 +14,15 @@ changes detections and migrations.
 == Usage
 
 You first need to create a migration to add a 'text' field named 'properties' to
-your model. Something like this:
+your model. Choose a text format that is really long (otherwize your data will be truncated and the property will fail to decode => error). Do something like this:
 
  class AddPropertyToContact < ActiveRecord::Migration
    def self.up
-     add_column :contacts, :properties, :text
+     if ActiveRecord::Base.configurations[RAILS_ENV]['adapter'] == 'mysql'
+       execute "ALTER TABLE contacts ADD COLUMN properties LONGTEXT"
+     else
+       add_column :contacts, :properties, :text
+     end
    end
 
    def self.down

data/lib/property.rb

@@ -2,8 +2,8 @@ require 'property/attribute'
 require 'property/dirty'
 require 'property/properties'
 require 'property/column'
+require 'property/role_module'
 require 'property/role'
-require 'property/stored_role'
 require 'property/schema'
 require 'property/declaration'
 require 'property/db'
@@ -11,6 +11,7 @@ require 'property/index'
 require 'property/serialization/json'
 require 'property/core_ext/time'
 require 'property/base'
+require 'property/stored_role'
 
 module Property
   def self.included(base)

data/lib/property/attribute.rb

@@ -19,7 +19,7 @@ module Property
       end
     end
 
-    # This is just a helper module that includes necessary code for property access, but without
+    # This is just a helper module that includes the necessary code for property access, but without
     # the validation/save hooks.
     module Base
       def self.included(base)
@@ -92,7 +92,8 @@ module Property
 
       private
         def attributes_with_properties=(attributes, guard_protected_attributes = true)
-          property_columns = self.properties.columns
+          property_columns = self.schema.column_names
+          
           properties = {}
 
           attributes.keys.each do |k|

data/lib/property/declaration.rb

@@ -1,7 +1,8 @@
 module Property
 
-  # Property::Declaration module is used to declare property definitions in a Class. The module
-  # also manages property inheritence in sub-classes.
+  # This module is used to manage property definitions (the schema) in a Class. The module
+  # also manages property inheritence in sub-classes by linking the schema in the sub-class with
+  # the schema in the superclass.
   module Declaration
     def self.included(base)
       base.class_eval do
@@ -10,6 +11,8 @@ module Property
       end
     end
 
+    # This is just a helper module that includes the necessary code for property definition, but without
+    # the validation/save hooks.
     module Base
       def self.included(base)
         base.class_eval do
@@ -17,6 +20,7 @@ module Property
           include InstanceMethods
 
           class << self
+            # Every class has it's own schema.
             attr_accessor :schema
 
             def schema
@@ -24,12 +28,9 @@ module Property
             end
 
             private
+              # Build schema and manage inheritance.
               def make_schema
-                schema = Property::Schema.new(self.to_s, self)
-                if superclass.respond_to?(:schema)
-                  schema.has_role superclass
-                end
-                schema
+                Property::Schema.new(self.to_s, :class => self)
               end
           end
         end
@@ -40,11 +41,11 @@ module Property
 
       # Include a new set of property definitions (Role) into the current class schema.
       # You can also provide a class to simulate multiple inheritance.
-      def has_role(role)
-        schema.has_role role
+      def include_role(role)
+        schema.include_role role
       end
 
-      # Return true if the current object has all the roles of the given object, class or role.
+      # Return true if the current object has all the roles of the given schema or role.
       def has_role?(role)
         schema.has_role? role
       end
@@ -63,7 +64,27 @@ module Property
       #    end
       #  end
       def property(&block)
-        schema.role.property(&block)
+        schema.property(&block)
+      end
+
+      # Define property methods in a class. This is only triggered when properties are declared directly in the
+      # class and not through Role inclusion.
+      def define_property_methods(column)
+        attr_name = column.name
+
+        class_eval(%Q{
+          def #{attr_name}                       # def title
+            prop['#{attr_name}']                 #   prop['title']
+          end                                    # end
+                                                 #
+          def #{attr_name}?                      # def title?
+            prop['#{attr_name}']                 #   prop['title']
+          end                                    # end
+                                                 #
+          def #{attr_name}=(new_value)           # def title=(new_value)
+            prop['#{attr_name}'] = new_value     #   prop['title'] = new_value
+          end                                    # end
+        }, __FILE__, __LINE__)
       end
     end # ClassMethods
 
@@ -76,8 +97,8 @@ module Property
 
       # Include a new set of property definitions (Role) into the current instance's schema.
       # You can also provide a class to simulate multiple inheritance.
-      def has_role(role)
-        own_schema.has_role role
+      def include_role(role)
+        own_schema.include_role role
       end
 
       # Return the list of active roles. The active roles are all the Roles included
@@ -99,12 +120,39 @@ module Property
         def own_schema
           @own_schema ||= make_own_schema
         end
+
+        # When roles are dynamically added to a model, we use method_missing to mimic property
+        # accessors. Since this has a cost, it is better to use 'prop' based accessors in production
+        # code (this is mostly helpful for testing/debugging).
+        def method_missing(meth, *args, &block)
+          method = meth.to_s
+          if args.empty?
+            if method[-1..-1] == '?'
+              # predicate
+              key = method[0..-2]
+            else
+              # reader
+              key = method
+            end
+
+            if schema.has_column?(key)
+              return prop[key]
+            end
+          elsif args.size == 1 && method[-1..-1] == '='
+            # writer
+            key = method[0..-2]
+            if schema.has_column?(key)
+              return prop[key] = args.first
+            end
+          end
+          # Not a property method
+          super
+        end
+
       private
+        # Create a schema for the instance and inherit from the class
         def make_own_schema
-          this = class << self; self; end
-          schema = Property::Schema.new(nil, this)
-          schema.has_role self.class
-          schema
+          Property::Schema.new(nil, :superschema => self.class.schema)
         end
     end # InsanceMethods
   end # Declaration

data/lib/property/index.rb

@@ -4,12 +4,14 @@ module Property
   # also manages property inheritence in sub-classes.
   module Index
     KEY = Property::Db.connection.quote_column_name('key')
+    FIELD_INDEX_REGEXP = %r{\A\.(.*)\Z}
 
     def self.included(base)
       base.class_eval do
         extend  ClassMethods
         include InstanceMethods
-        after_save :property_index
+        before_save :property_field_index
+        after_save  :property_index
         after_destroy :property_index_destroy
       end
     end
@@ -25,6 +27,12 @@ module Property
     module InstanceMethods
 
       def rebuild_index!
+        property_field_index
+
+        if changed_without_properties?
+          update_without_callbacks # no validation, no callbacks
+        end
+
         property_index
       end
 
@@ -144,9 +152,21 @@ module Property
           self.class.connection.execute "DELETE FROM #{index_table_name(group_name)} WHERE #{index_reader_sql(group_name)} AND #{KEY} IN (#{keys.map{|key| connection.quote(key)}.join(',')})"
         end
 
+        # This method prepares the index
+        def property_field_index
+          schema.index_groups.each do |group_name, definitions|
+            if group_name =~ FIELD_INDEX_REGEXP
+              # write attribute in owner
+              key = definitions.first.first
+              self[$1] = prop[key]
+            end
+          end
+        end
+
         # This method prepares the index
         def property_index
           schema.index_groups.each do |group_name, definitions|
+            next if group_name =~ FIELD_INDEX_REGEXP
             cur_indices = {}
             definitions.each do |key, proc|
               if key

data/lib/property/properties.rb

@@ -69,7 +69,7 @@ module Property
     end
 
     def columns
-      @columns ||= @owner.schema.columns
+      @owner.schema.columns
     end
   end
 end

data/lib/property/role.rb

@@ -1,18 +1,24 @@
-require 'property/role_module'
+require 'property/redefined_property_error'
+require 'property/redefined_method_error'
 
 module Property
-  # This class holds a set of property definitions. This is like a Module in ruby:
-  # by 'including' this role in a class or in an instance, you augment the said
-  # object with the role's property definitions.
+  # The Role holds information on a group of property columns. The "Role" is used
+  # in the same way as the ruby Module: as a mixin. The Schema class "includes" roles.
   class Role
-    attr_accessor :name
     include RoleModule
 
-    def self.new(name, &block)
+    # Create a new role. If a block is provided, this block can be used
+    # to define properties:
+    #
+    # Example:
+    #  @role = Role.new('Poet') do |p|
+    #    p.string :muse
+    #  end
+    def self.new(name, opts = nil, &block)
       if name.kind_of?(Hash)
-        obj = super(name[:name] || name['name'])
+        obj = super(name[:name] || name['name'], opts)
       else
-        obj = super(name)
+        obj = super(name, opts)
       end
 
       if block_given?
@@ -22,8 +28,8 @@ module Property
     end
 
     # Initialize a new role with the given name
-    def initialize(name)
-      self.name = name
+    def initialize(name, opts = nil)
+      @name = name
       initialize_role_module
     end
   end

data/lib/property/role_module.rb

@@ -1,49 +1,13 @@
-require 'property/redefined_property_error'
-require 'property/redefined_method_error'
-
 module Property
-  # This class holds a set of property definitions. This is like a Module in ruby:
-  # by 'including' this role in a class or in an instance, you augment the said
-  # object with the role's property definitions.
+  # The RoleModule enables a class to hold information on a group of property columns.
+  # This enables classes to act in the same way as the ruby Module: as a mixin.
+  # The Schema class "includes" roles.
   module RoleModule
-    attr_accessor :included, :accessor_module
-
-    # We cannot use attr_accessor to define these because we are in a module
-    # when the module is included in an ActiveRecord class.
-    #%W{name included accessor_module}.each do |name|
-    #  class_eval %Q{
-    #    def #{name}
-    #      @#{name}
-    #    end
-    #
-    #    def #{name}=(value)
-    #      @#{name} = value
-    #    end
-    #  }
-    #end
-
-    # Initialize module (should be called from within including class's initialize method).
-    def initialize_role_module
-      @included_in_schemas = []
-      @group_indices   = []
-      @accessor_module = build_accessor_module
-    end
-
-    # List all property definitiosn for the current role
-    def columns
-      @columns ||= {}
-    end
-
-    # Return a list of index definitions in the form [type, key, proc_or_nil]
-    def indices
-      columns.values.select do |c|
-        c.indexed?
-      end.map do |c|
-        [c.index, c.name, c.index_proc]
-      end + @group_indices
+    def name
+      @name
     end
 
-    # Return true if the Role contains the given column (property).
+    # Return true if the role contains the given column (property).
     def has_column?(name)
       column_names.include?(name)
     end
@@ -53,52 +17,71 @@ module Property
       columns.keys
     end
 
-    # Use this method to declare properties into a Role.
+    # List all property columns defined for this role
+    def columns
+      defined_columns
+    end
+
+    # Use this method to declare properties into a Role or Schema.
+    #
     # Example:
     #  @role.property.string 'phone', :default => ''
     #
+    # You can also use the "property" method in the class to access the schema:
+    #
+    # Example:
+    #  Page.property.string 'phone', :default => ''
+    #
     # You can also use a block:
-    #  @role.property do |p|
+    #  Page.property do |p|
     #    p.string 'phone', 'name', :default => ''
     #  end
     def property
       if block_given?
-        yield accessor_module
+        yield self
       end
-      accessor_module
+      self
     end
 
-    # @internal
-    # This is called when the role is included in a schema
-    def included_in(schema)
-      @included_in_schemas << schema
+    %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.flatten
+          default = options.delete(:default)
+          column_names.each { |name| add_column(Property::Column.new(name, default, '#{column_type}', options.merge(:role => self))) }
+        end
+      EOV
     end
 
-    # @internal
-    def add_column(column)
-      name = column.name
-
-      if columns[name]
-        raise RedefinedPropertyError.new("Property '#{name}' is already defined.")
-      else
-        verify_not_defined_in_schemas_using_this_role(name)
-        verify_method_not_defined_in_classes_using_this_role(name)
-        define_property_methods(column) if column.should_create_accessors?
-        columns[column.name] = column
-      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.merge(:role => self)))
     end
 
-    # @internal
-    def add_index(type, proc)
+    # This is used to create complex indices 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)
       #                 type,  key, proc
-      @group_indices << [type, nil, proc]
+      @group_indices << [type, nil, block]
     end
 
-    # Returns true if the current role is used by the given object. A Role is
-    # considered to be used if any of it's attributes is not blank in the object's
+    # Returns true if the role is used by the given object. A role is
+    # considered to be used if any of it's defined columns is not blank in the object's
     # properties.
     def used_in(object)
-      used_keys_in(object) != []
+      object.properties.keys & defined_columns.keys != []
     end
 
     # Returns the list of column names in the current role that are used by the
@@ -107,140 +90,44 @@ module Property
       object.properties.keys & column_names
     end
 
-    private
-      def build_accessor_module
-        accessor_module = Module.new
-        accessor_module.class_eval do
-          class << self
-            attr_accessor :role
-
-            # 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.flatten
-                  default = options.delete(:default)
-                  column_names.each { |name| role.add_column(Property::Column.new(name, default, '#{column_type}', options.merge(:role => role))) }
-                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)
-              role.add_column(Property::Column.new(name, nil, klass, options.merge(:role => role)))
-            end
-
-            # This is used to create complex indices 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)
-              role.add_index(type, block)
-            end
-
-            alias actions class_eval
-          end
-        end
-        accessor_module.role = self
-        accessor_module
-      end
-
-      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
+    # Return a list of index definitions in the form [type, key, proc_or_nil]
+    def indices
+      columns.values.select do |c|
+        c.indexed?
+      end.map do |c|
+        [c.index, c.name, c.index_proc]
+      end + @group_indices
+    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
+    def inspect
+      # "#<#{self.class}:#{sprintf("0x%x", object_id)} #{@name.inspect} @klass = #{@klass.inspect} @defined_columns = #{@defined_columns.inspect}>"
+      "#<#{self.class}:#{sprintf("0x%x", object_id)} #{column_names.inspect}>"
+    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__)
+    protected
+      def initialize_role_module
+        @group_indices = []
       end
 
-      def verify_not_defined_in_schemas_using_this_role(name)
-        @included_in_schemas.each do |schema|
-          if schema.columns[name]
-            raise RedefinedPropertyError.new("Property '#{name}' is already defined in #{schema.name}.")
-          end
-        end
+      # List all property columns defined for this role
+      def defined_columns
+        @defined_columns ||= {}
       end
 
-      def verify_method_not_defined_in_classes_using_this_role(name)
-        @included_in_schemas.each do |schema|
-          if schema.binding.superclass.method_defined?(name)
-            raise RedefinedMethodError.new("Method '#{name}' is already defined in #{schema.binding.superclass} or ancestors.")
+      # @internal
+      def add_column(column)
+        name = column.name
+        # we do not use self.defined_columns because this triggers the load_columns_from_db in StoredRole (= inf loop).
+        defined_columns = (@defined_columns ||= {})
+
+        if defined_columns[name]
+          raise RedefinedPropertyError.new("Property '#{name}' is already defined.")
+        else
+          defined_columns[column.name] = column
+          if @klass && column.should_create_accessors?
+            @klass.define_property_methods(column)
           end
         end
       end
-  end
-end
+  end # RoleModule
+end # Property