property 0.9.1 → 1.0.0

data/lib/property/properties.rb

@@ -40,12 +40,18 @@ module Property
       errors = @owner.errors
       no_errors = true
 
+      original_hash = @original_hash || self
+
       bad_keys         = keys - column_names
       missing_keys     = column_names - keys
       keys_to_validate = keys - bad_keys
 
       bad_keys.each do |key|
-        errors.add("#{key}", 'property is not declared')
+        if original_hash[key] == self[key]
+          # ignore invalid legacy value
+        else
+          errors.add("#{key}", 'property not declared')
+        end
       end
 
       missing_keys.each do |key|

data/lib/property/redefined_method_error.rb

@@ -0,0 +1,8 @@
+require 'property/error'
+
+module Property
+  # This error is raised when a role is included into a class and this inclusion
+  # hides already defined methods (in superclass).
+  class RedefinedMethodError < Property::Error
+  end
+end

data/lib/property/redefined_property_error.rb

@@ -0,0 +1,8 @@
+require 'property/error'
+
+module Property
+  # This error is raised when a role is included into a class and this inclusion
+  # hides already defined properties.
+  class RedefinedPropertyError < Property::Error
+  end
+end

data/lib/property/role.rb

@@ -0,0 +1,30 @@
+require 'property/role_module'
+
+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.
+  class Role
+    attr_accessor :name
+    include RoleModule
+
+    def self.new(name, &block)
+      if name.kind_of?(Hash)
+        obj = super(name[:name] || name['name'])
+      else
+        obj = super(name)
+      end
+
+      if block_given?
+        obj.property(&block)
+      end
+      obj
+    end
+
+    # Initialize a new role with the given name
+    def initialize(name)
+      self.name = name
+      initialize_role_module
+    end
+  end
+end

data/lib/property/{behavior.rb → role_module.rb}

@@ -1,27 +1,35 @@
+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 behavior in a class or in an instance, you augment the said
-  # object with the behavior's property definitions.
-  class Behavior
-    attr_accessor :name, :included, :accessor_module
-
-    def self.new(name, &block)
-      obj = super
-      if block_given?
-        obj.property(&block)
-      end
-      obj
-    end
-
-    # Initialize a new behavior with the given name
-    def initialize(name)
-      @name    = name
+  # by 'including' this role in a class or in an instance, you augment the said
+  # object with the role's property definitions.
+  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 behavior
+    # List all property definitiosn for the current role
     def columns
       @columns ||= {}
     end
@@ -32,14 +40,16 @@ module Property
         c.indexed?
       end.map do |c|
         if c.index == true
-          [c.type, c.name]
+          [c.type.to_sym, c.name]
+        elsif c.index.kind_of?(Proc)
+          [c.type.to_sym, c.name, c.index]
         else
-          [c.type, c.name, c.index]
+          [c.index,       c.name]
         end
       end + @group_indices
     end
 
-    # Return true if the Behavior contains the given column (property).
+    # Return true if the Role contains the given column (property).
     def has_column?(name)
       column_names.include?(name)
     end
@@ -49,12 +59,12 @@ module Property
       columns.keys
     end
 
-    # Use this method to declare properties into a Behavior.
+    # Use this method to declare properties into a Role.
     # Example:
-    #  @behavior.property.string 'phone', :default => ''
+    #  @role.property.string 'phone', :default => ''
     #
     # You can also use a block:
-    #  @behavior.property do |p|
+    #  @role.property do |p|
     #    p.string 'phone', 'name', :default => ''
     #  end
     def property
@@ -65,8 +75,8 @@ module Property
     end
 
     # @internal
-    # This is called when the behavior is included in a schema
-    def included(schema)
+    # This is called when the role is included in a schema
+    def included_in(schema)
       @included_in_schemas << schema
     end
 
@@ -75,9 +85,10 @@ module Property
       name = column.name
 
       if columns[name]
-        raise TypeError.new("Property '#{name}' is already defined.")
+        raise RedefinedPropertyError.new("Property '#{name}' is already defined.")
       else
-        verify_not_defined_in_schemas_using_this_behavior(name)
+        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
@@ -89,12 +100,25 @@ module Property
       @group_indices << [type, nil, proc]
     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
+    # properties.
+    def used_in(object)
+      used_keys_in(object) != []
+    end
+
+    # Returns the list of column names in the current role that are used by the
+    # given object (value not blank).
+    def used_keys_in(object)
+      object.properties.keys & column_names
+    end
+
     private
       def build_accessor_module
         accessor_module = Module.new
         accessor_module.class_eval do
           class << self
-            attr_accessor :behavior
+            attr_accessor :role
 
             # def string(*args)
             #   options = args.extract_options!
@@ -106,9 +130,9 @@ module Property
               class_eval <<-EOV
                 def #{column_type}(*args)
                   options = args.extract_options!
-                  column_names = args
+                  column_names = args.flatten
                   default = options.delete(:default)
-                  column_names.each { |name| behavior.add_column(Property::Column.new(name, default, '#{column_type}', options)) }
+                  column_names.each { |name| role.add_column(Property::Column.new(name, default, '#{column_type}', options)) }
                 end
               EOV
             end
@@ -117,7 +141,7 @@ module Property
             #   p.serialize 'pet', Dog
             def serialize(name, klass, options = {})
               Property.validate_property_class(klass)
-              behavior.add_column(Property::Column.new(name, nil, klass, options))
+              role.add_column(Property::Column.new(name, nil, klass, options))
             end
 
             # This is used to create complex indices with the following syntax:
@@ -132,13 +156,13 @@ module Property
             # 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)
+              role.add_index(type, block)
             end
 
             alias actions class_eval
           end
         end
-        accessor_module.behavior = self
+        accessor_module.role = self
         accessor_module
       end
 
@@ -209,10 +233,18 @@ module Property
         accessor_module.class_eval(method_definition, __FILE__, __LINE__)
       end
 
-      def verify_not_defined_in_schemas_using_this_behavior(name)
+      def verify_not_defined_in_schemas_using_this_role(name)
         @included_in_schemas.each do |schema|
           if schema.columns[name]
-            raise TypeError.new("Property '#{name}' is already defined in #{schema.name}.")
+            raise RedefinedPropertyError.new("Property '#{name}' is already defined in #{schema.name}.")
+          end
+        end
+      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.")
           end
         end
       end

data/lib/property/schema.rb

@@ -4,49 +4,73 @@ module Property
   # to validate content and type_cast during write operations.
   #
   # The properties are not directly defined in the schema. They are stored in a
-  # Behavior instance which checks that the database is in sync with the properties
+  # Role instance which checks that the database is in sync with the properties
   # defined.
   class Schema
-    attr_reader :behaviors, :behavior, :binding
+    attr_reader :roles, :role, :binding
 
     # Create a new Schema. If a class_name is provided, the schema automatically
-    # creates a default Behavior to store definitions.
+    # creates a default Role to store definitions.
     def initialize(class_name, binding)
       @binding = binding
-      @behaviors = []
+      @roles = []
       if class_name
-        @behavior  = Behavior.new(class_name)
-        include_behavior @behavior
-        @behaviors << @behavior
+        @role  = Role.new(class_name)
+        include_role @role
+        @roles << @role
       end
     end
 
     # Return an identifier for the schema to help locate property redefinition errors.
     def name
-      @behavior ? @behavior.name : @binding.to_s
+      @role ? @role.name : @binding.to_s
+    end
+
+    # Return true if the current schema has all the roles of the given object, class or role.
+    def has_role?(thing)
+      roles = self.roles.flatten
+      test_roles = thing.class < RoleModule ? [thing] : thing.schema.roles.flatten
+      test_roles.each do |role|
+        return false unless roles.include?(role)
+      end
+      true
     end
 
     # If the parameter is a class, the schema will inherit the property definitions
-    # from the class. If the parameter is a Behavior, the properties from that
-    # behavior will be included. Any new columns added to a behavior or any new
-    # behaviors included in a class will be dynamically added to the sub-classes (just like
+    # from the class. If the parameter is a Role, the properties from that
+    # role will be included. Any new columns added to a role or any new
+    # roles included in a class will be dynamically added to the sub-classes (just like
     # Ruby class inheritance, module inclusion works).
     # If you ...
-    def behave_like(thing)
+    def has_role(thing)
       if thing.kind_of?(Class)
         if thing.respond_to?(:schema) && thing.schema.kind_of?(Schema)
-          thing.schema.behaviors.flatten.each do |behavior|
-            include_behavior behavior
+          schema_class = thing.schema.binding
+          if @binding.ancestors.include?(schema_class)
+            check_super_methods = false
+          else
+            check_super_methods = true
           end
-          self.behaviors << thing.schema.behaviors
+          thing.schema.roles.flatten.each do |role|
+            include_role role, check_super_methods
+          end
+          self.roles << thing.schema.roles
         else
-          raise TypeError.new("expected Behavior or class with schema, found #{thing}")
+          raise TypeError.new("expected Role or class with schema, found #{thing}")
         end
-      elsif thing.kind_of?(Behavior)
-        include_behavior thing
-        self.behaviors << thing
+      elsif thing.kind_of?(RoleModule)
+        include_role thing
+        self.roles << thing
       else
-        raise TypeError.new("expected Behavior or class with schema, found #{thing.class}")
+        raise TypeError.new("expected Role or class with schema, found #{thing.class}")
+      end
+    end
+
+    # Return the list of active roles. The active roles are all the Roles included
+    # in the current object for which properties have been defined (not blank).
+    def used_roles_in(object)
+      roles.flatten.uniq.reject do |role|
+        !role.used_in(object)
       end
     end
 
@@ -58,16 +82,16 @@ module Property
     # 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)
+      [@roles].flatten.each do |role|
+        return true if role.has_column?(name)
       end
       false
     end
 
-    # Return column definitions from all included behaviors.
+    # Return column definitions from all included roles.
     def columns
       columns = {}
-      @behaviors.flatten.uniq.each do |b|
+      @roles.flatten.uniq.each do |b|
         columns.merge!(b.columns)
       end
       columns
@@ -76,7 +100,7 @@ module Property
     # Return a hash with indexed types as keys and index definitions as values.
     def index_groups
       index_groups = {}
-      @behaviors.flatten.uniq.each do |b|
+      @roles.flatten.uniq.each do |b|
         b.indices.each do |list|
           (index_groups[list.first] ||= []) << list[1..-1]
         end
@@ -85,15 +109,35 @@ module Property
     end
 
     private
-      def include_behavior(behavior)
-        return if behaviors.include?(behavior)
-        columns = self.columns
-        common_keys = behavior.column_names & columns.keys
+      def include_role(role, check_methods = true)
+        return if roles.flatten.include?(role)
+
+        stored_column_names = role.column_names
+
+        check_duplicate_property_definitions(role, stored_column_names)
+        check_duplicate_method_definitions(role, stored_column_names) if check_methods
+
+        role.included_in(self)
+        @binding.send(:include, role.accessor_module)
+      end
+
+      def check_duplicate_property_definitions(role, keys)
+        common_keys = keys & self.columns.keys
         if !common_keys.empty?
-          raise TypeError.new("Cannot include behavior #{behavior.name}. Duplicate definitions: #{common_keys.join(', ')}")
+          raise RedefinedPropertyError.new("Cannot include role '#{role.name}' in '#{name}'. Duplicate definitions: #{common_keys.join(', ')}")
         end
-        behavior.included(self)
-        @binding.send(:include, behavior.accessor_module)
       end
+
+      def check_duplicate_method_definitions(role, keys)
+        common_keys = []
+        keys.each do |k|
+          common_keys << k if @binding.superclass.method_defined?(k)
+        end
+
+        if !common_keys.empty?
+          raise RedefinedMethodError.new("Cannot include role '#{role.name}' in '#{@binding}'. Would hide methods in superclass: #{common_keys.join(', ')}")
+        end
+      end
+
   end
 end

data/lib/property/stored_column.rb

@@ -0,0 +1,30 @@
+module Property
+  # This module should be inserted in an ActiveRecord class that stores a
+  # single property definition in the database and is used with StoredRole.
+  module StoredColumn
+    def self.included(base)
+      base.before_validation :set_index
+    end
+
+    # Default values not currently supported.
+    def default
+      nil
+    end
+
+    # No supported options yet.
+    def options
+      {:index => (index.blank? ? nil : index)}
+    end
+
+    private
+      def set_index
+        if index == true
+          self.index = ptype.to_s
+        elsif index.blank?
+          self.index = nil
+        else
+          self.index = self.index.to_s
+        end
+      end
+  end
+end