property 1.2.0 → 2.0.0

data/lib/property/schema.rb

@@ -1,100 +1,41 @@
-
 module Property
-  # This class holds all the properties of a given class or instance. It is used
-  # to validate content and type_cast during write operations.
-  #
-  # The properties are not directly defined in the schema. They are stored in a
-  # Role instance which checks that the database is in sync with the properties
-  # defined.
-  class Schema
-    attr_reader :roles, :role, :binding
-
-    # Create a new Schema. If a class_name is provided, the schema automatically
-    # creates a default Role to store definitions.
-    def initialize(class_name, binding)
-      @binding = binding
-      @roles = []
-      if class_name
-        @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
-      @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 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 has_role(thing)
-      if thing.kind_of?(Class)
-        if thing.respond_to?(:schema) && thing.schema.kind_of?(Schema)
-          schema_class = thing.schema.binding
-          if @binding.ancestors.include?(schema_class)
-            check_super_methods = false
-          else
-            check_super_methods = true
-          end
-          thing.schema.roles.flatten.each do |role|
-            include_role role, check_super_methods
-          end
-          self.roles << thing.schema.roles
-        else
-          raise TypeError.new("expected Role or class with schema, found #{thing}")
+  # A schema contains all the property definitions for a given class. If Role is a module,
+  # then schema is a Class.
+  class Schema < Role
+    attr_accessor :roles, :klass
+
+    # Initialize a new schema with a name and the klass linked to the schema.
+    def initialize(name, opts = {})
+      super
+      @klass = opts[:class]
+
+      @roles = [self]
+
+      # Schema inheritance
+      unless superschema = opts[:superschema]
+        if @klass && @klass.superclass.respond_to?(:schema)
+          superschema = @klass.superclass.schema
         end
-      elsif thing.kind_of?(RoleModule)
-        include_role thing
-        self.roles << thing
-      else
-        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
 
-    # Return the list of column names.
-    def column_names
-      columns.keys
-    end
-
-    # Return true if the schema has a property with the given name.
-    def has_column?(name)
-      name = name.to_s
-      [@roles].flatten.each do |role|
-        return true if role.has_column?(name)
+      if superschema
+        include_role superschema
       end
-      false
     end
 
-    # Return column definitions from all included roles.
-    def columns
-      columns = {}
-      @roles.flatten.uniq.each do |b|
-        columns.merge!(b.columns)
+    # Add a set of property definitions to the schema.
+    def include_role(role)
+      @columns = nil # clear cache
+      if role.kind_of?(Schema)
+        # Superclass inheritance
+        @roles << role.roles
+      elsif role.kind_of?(RoleModule)
+        @roles << role
+      elsif role.respond_to?(:schema) && role.schema.kind_of?(Role)
+        @roles << role.schema.roles
+      else
+        raise TypeError.new("Cannot include role #{role} (invalid type).")
       end
-      columns
     end
 
     # Return a hash with indexed types as keys and index definitions as values.
@@ -108,38 +49,48 @@ module Property
       index_groups
     end
 
-    private
-      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 RedefinedPropertyError.new("Cannot include role '#{role.name}' in '#{name}'. Duplicate definitions: #{common_keys.join(', ')}")
+    # Return a hash with the column definitions defined in the schema and in the included
+    # roles.
+    def columns
+      # FIXME: can we memoize this list on the first call ? Do we need to update properties after such a call ?
+      # @columns ||=
+      begin
+        res = {}
+        @roles.flatten.uniq.each do |role|
+          # TODO: we could check for property redefinitions.
+          res.merge!(role.defined_columns)
         end
+        res
       end
+    end
 
-      def check_duplicate_method_definitions(role, keys)
-        common_keys = []
-        # we are in an instance's metaclass, find the class
-        superclass  = @binding.ancestors.detect {|a| a.kind_of?(Class)}
-        keys.each do |k|
-          common_keys << k if superclass.method_defined?(k)
-        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.select do |role|
+        role.used_in(object)
+      end
+    end
 
-        if !common_keys.empty?
-          raise RedefinedMethodError.new("Cannot include role '#{role.name}' in '#{@binding}'. Would hide methods in superclass (#{superclass}): #{common_keys.join(', ')}")
-        end
+    # Return true if the role has been included or is included in any superclass.
+    def has_role?(role)
+      if role.kind_of?(Schema)
+        role.roles.flatten - @roles.flatten == []
+      elsif role.kind_of?(RoleModule)
+        @roles.flatten.include?(role)
+      elsif role.respond_to?(:schema) && role.schema.kind_of?(Role)
+        has_role?(role.schema)
+      else
+        false
       end
+    end
 
+    # When a column is added in a Schema: define accessors in related class
+    def add_column(column)
+      super
+      if @klass
+        @klass.define_property_methods(column) if column.should_create_accessors?
+      end
+    end
   end
-end
+end # Property

data/lib/property/stored_role.rb

@@ -8,7 +8,7 @@ module Property
   # Once this module is included, you need to set the has_many association to the class that
   # contains the columns definitions with something like:
   #
-  #   has_many :stored_columns, :class_name => NameOfColumnsClass
+  #   stored_columns_class NameOfColumnsClass
   module StoredRole
     include RoleModule
 
@@ -50,16 +50,20 @@ module Property
       end
     end # included
 
-    # List all property definitions for the current role
-    def columns
+    # Get all property definitions defined for this role
+    def defined_columns
       load_columns_from_db unless @columns_from_db_loaded
       super
     end
 
     def property
-      initialize_role_module unless @accessor_module
       super
     end
+    
+    # Overwrite name reader in RoleModule
+    def name
+      self[:name]
+    end
 
 
     private
@@ -74,9 +78,12 @@ module Property
       end
 
       def update_columns
-        @original_columns ||= {}
+        return unless @defined_columns # no change
+        unless @original_columns
+          load_columns_from_db
+        end
         stored_column_names  = @original_columns.keys
-        defined_column_names = self.column_names
+        defined_column_names = column_names
 
         new_columns     = defined_column_names - stored_column_names
         updated_columns = defined_column_names & stored_column_names

data/lib/property/version.rb

@@ -1,3 +1,3 @@
 module Property
-  VERSION = '1.2.0'
+  VERSION = '2.0.0'
 end

data/property.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{property}
-  s.version = "1.2.0"
+  s.version = "2.0.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-09-26}
+  s.date = %q{2010-11-10}
   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 = [
@@ -58,6 +58,7 @@ Gem::Specification.new do |s|
      "test/unit/property/dirty_test.rb",
      "test/unit/property/index_complex_test.rb",
      "test/unit/property/index_custom_test.rb",
+     "test/unit/property/index_field_test.rb",
      "test/unit/property/index_foreign_test.rb",
      "test/unit/property/index_simple_test.rb",
      "test/unit/property/role_test.rb",
@@ -71,7 +72,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.6}
+  s.rubygems_version = %q{1.3.7}
   s.summary = %q{model properties wrap into a single database column}
   s.test_files = [
     "test/database.rb",
@@ -87,6 +88,7 @@ Gem::Specification.new do |s|
      "test/unit/property/dirty_test.rb",
      "test/unit/property/index_complex_test.rb",
      "test/unit/property/index_custom_test.rb",
+     "test/unit/property/index_field_test.rb",
      "test/unit/property/index_foreign_test.rb",
      "test/unit/property/index_simple_test.rb",
      "test/unit/property/role_test.rb",
@@ -101,7 +103,7 @@ Gem::Specification.new do |s|
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_development_dependency(%q<shoulda>, [">= 0"])
       s.add_runtime_dependency(%q<activerecord>, [">= 0"])
     else

data/test/database.rb

@@ -11,6 +11,7 @@ begin
       create_table 'employees' do |t|
         t.string 'type'
         t.text   'properties'
+        t.float  'idx_float1'
       end
 
       create_table 'versions' do |t|

data/test/fixtures.rb

@@ -17,6 +17,7 @@ class WebDeveloper < Developer
 
 end
 
+
 class Version < ActiveRecord::Base
   attr_accessor :backup
   include Property

data/test/shoulda_macros/index.rb

@@ -3,7 +3,10 @@ module IndexMacros
   class Client < ActiveRecord::Base
     set_table_name :employees
     include Property
-
+    
+    def muse
+      'I am your muse'
+    end
     def index_reader(group_name)
       if group_name.to_s == 'ml_string'
         super.merge(:with => {'lang' => ['en', 'fr'], 'site_id' => '123'})
@@ -21,7 +24,7 @@ class Test::Unit::TestCase
     context "assigned to an instance of Dummy" do
       subject do
         dummy = IndexMacros::Client.new
-        dummy.has_role @poet
+        dummy.include_role @poet
         dummy
       end
 
@@ -58,7 +61,7 @@ class Test::Unit::TestCase
     context "assigned to an instance of Dummy" do
       subject do
         dummy = IndexMacros::Client.new
-        dummy.has_role @poet
+        dummy.include_role @poet
         dummy
       end
 

data/test/shoulda_macros/role.rb

@@ -77,7 +77,7 @@ class Test::Unit::TestCase
     end
   end # should_store_property_definitions
 
-  def self.should_insert_properties_on_has_role_poet
+  def self.should_insert_properties_on_include_role_poet
     context 'added' do
 
       context 'to a parent class' do
@@ -86,35 +86,34 @@ class Test::Unit::TestCase
             set_table_name :dummies
             include Property
             property.string 'name'
+
+            def muse
+              'I am your muse'
+            end
           end
 
           @klass = Class.new(@parent)
         end
 
         should 'propagate definitions to child' do
-          @parent.has_role @poet
+          @parent.include_role @poet
           assert_equal %w{name poem year}, @klass.schema.column_names.sort
         end
 
         should 'return true on has_role?' do
-          @parent.has_role @poet
+          @parent.include_role @poet
           assert @klass.has_role?(@poet)
         end
 
-        should 'raise an exception if class contains same definitions' do
-          @parent.property.string 'poem'
-          assert_raise(Property::RedefinedPropertyError) { @parent.has_role @poet }
-        end
-
         should 'not raise an exception on double inclusion' do
-          @parent.has_role @poet
-          assert_nothing_raised { @parent.has_role @poet }
+          @parent.include_role @poet
+          assert_nothing_raised { @parent.include_role @poet }
         end
 
         should 'add accessor methods to child' do
           subject = @klass.new
           assert_raises(NoMethodError) { subject.poem = 'Poe'}
-          @parent.has_role @poet
+          @parent.include_role @poet
 
           assert_nothing_raised { subject.poem = 'Poe'}
         end
@@ -126,22 +125,26 @@ class Test::Unit::TestCase
             set_table_name :dummies
             include Property
             property.string 'name'
+
+            def muse
+              'I am your muse'
+            end
           end
         end
 
         should 'insert definitions' do
-          @klass.has_role @poet
+          @klass.include_role @poet
           assert_equal %w{name poem year}, @klass.schema.column_names.sort
         end
 
         should 'return true on class has_role?' do
-          @klass.has_role @poet
+          @klass.include_role @poet
           assert @klass.has_role?(@poet)
         end
 
         should 'return role from column' do
-          @klass.has_role @poet
-          assert_equal (@poet.kind_of?(Class) ? @poet.schema.role : @poet), @klass.schema.columns['poem'].role
+          @klass.include_role @poet
+          assert_equal (@poet.kind_of?(Class) ? @poet.schema : @poet), @klass.schema.columns['poem'].role
         end
       end
 
@@ -149,7 +152,7 @@ class Test::Unit::TestCase
         subject { Developer.new }
 
         setup do
-          subject.has_role @poet
+          subject.include_role @poet
         end
 
         should 'merge property definitions' do
@@ -157,38 +160,7 @@ class Test::Unit::TestCase
         end
       end
     end
-  end # should_insert_properties_on_has_role
-
-  def self.should_add_role_methods
-    context 'added' do
-      context 'to a parent class' do
-        setup do
-          @parent = Class.new(ActiveRecord::Base) do
-            set_table_name :dummies
-            include Property
-            property.string 'name'
-          end
-
-          @klass = Class.new(@parent)
-        end
-
-        should 'add role methods to child' do
-          subject = @klass.new
-          assert_raises(NoMethodError) { subject.muse }
-          @parent.has_role @poet
-
-          assert_nothing_raised { subject.muse }
-        end
-
-        should 'use role methods for defaults' do
-          subject = @klass.new
-          @parent.has_role @poet
-          assert subject.save
-          assert_equal 'I am your muse', subject.poem
-        end
-      end
-    end
-  end # should_add_role_methods
+  end # should_insert_properties_on_include_role_poet
 
   def self.should_take_part_in_used_list(has_defaults = true)
 
@@ -199,9 +171,13 @@ class Test::Unit::TestCase
             set_table_name :dummies
             include Property
             property.string 'name'
+
+            def muse
+              'I am your muse'
+            end
           end
 
-          @klass.has_role @poet
+          @klass.include_role @poet
         end
 
         subject do
@@ -214,7 +190,7 @@ class Test::Unit::TestCase
 
         should 'not return role without corresponding attributes' do
           subject.attributes = {'name' => 'hello'}
-          assert_equal [@klass.schema.role], subject.used_roles
+          assert_equal [@klass.schema], subject.used_roles
         end
 
         should 'return role with corresponding attributes' do