property 2.0.0 → 2.1.0

data/History.txt

@@ -1,4 +1,9 @@
-== 2.0.0
+== 2.1.0 2010-11-15
+
+* Major enhancements
+  * Added support for custom Schema classes through SchemaModule and StoredSchema.
+  
+== 2.0.0 2010-11-10
 
 * Major enhancements
   * Rewrite of the core engine to remove all the metaclass and anonymous module codes (generated memory leaks).

data/lib/property.rb

@@ -3,6 +3,7 @@ require 'property/dirty'
 require 'property/properties'
 require 'property/column'
 require 'property/role_module'
+require 'property/schema_module'
 require 'property/role'
 require 'property/schema'
 require 'property/declaration'
@@ -12,6 +13,7 @@ require 'property/serialization/json'
 require 'property/core_ext/time'
 require 'property/base'
 require 'property/stored_role'
+require 'property/stored_schema'
 
 module Property
   def self.included(base)

data/lib/property/attribute.rb

@@ -92,8 +92,8 @@ module Property
 
       private
         def attributes_with_properties=(attributes, guard_protected_attributes = true)
-          property_columns = self.schema.column_names
-          
+          property_columns = schema.column_names
+
           properties = {}
 
           attributes.keys.each do |k|

data/lib/property/role_module.rb

@@ -101,7 +101,7 @@ module Property
 
     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}>"
+      "#<#{self.class}:#{sprintf("0x%x", object_id)} #{defined_columns.keys.inspect}>"
     end
 
     protected

data/lib/property/schema.rb

@@ -2,95 +2,13 @@ module Property
   # 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
+    include Property::SchemaModule
 
     # 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
-      end
-
-      if superschema
-        include_role superschema
-      end
-    end
-
-    # 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
-    end
-
-    # Return a hash with indexed types as keys and index definitions as values.
-    def index_groups
-      index_groups = {}
-      @roles.flatten.uniq.each do |b|
-        b.indices.each do |list|
-          (index_groups[list.first] ||= []) << list[1..-1]
-        end
-      end
-      index_groups
+      initialize_schema_module(opts)
     end
 
-    # 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
-
-    # 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
-
-    # 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 # Property

data/lib/property/schema_module.rb

@@ -0,0 +1,99 @@
+module Property
+  # The SchemaModule enables a class to act as a Schema.
+  module SchemaModule
+    def initialize_schema_module(opts)
+      @klass = opts[:class]
+
+      @roles = [self]
+
+      # Schema inheritance
+      unless superschema = opts[:superschema]
+        if @klass && @klass.superclass.respond_to?(:schema)
+          superschema = @klass.superclass.schema
+        end
+      end
+
+      if superschema
+        include_role superschema
+      end
+    end
+
+    def klass
+      @klass
+    end
+
+    def roles
+      @roles
+    end
+
+    # Add a set of property definitions to the schema.
+    def include_role(role)
+      # @columns = nil # clear cache
+      if role.kind_of?(SchemaModule)
+        # 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
+    end
+
+    # Return a hash with indexed types as keys and index definitions as values.
+    def index_groups
+      index_groups = {}
+      @roles.flatten.uniq.each do |b|
+        b.indices.each do |list|
+          (index_groups[list.first] ||= []) << list[1..-1]
+        end
+      end
+      index_groups
+    end
+
+    # 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
+
+    # 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
+
+    # 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 # SchemaModule
+end # Property

data/lib/property/stored_role.rb

@@ -22,6 +22,10 @@ module Property
       base.class_eval do
         after_save :update_columns
         validates_presence_of :name
+        def after_initialize
+          initialize_role_module
+        end
+        
         extend ClassMethods
 
         def self.new(arg, &block)
@@ -59,7 +63,7 @@ module Property
     def property
       super
     end
-    
+
     # Overwrite name reader in RoleModule
     def name
       self[:name]

data/lib/property/stored_schema.rb

@@ -0,0 +1,20 @@
+require 'property/role_module'
+require 'property/stored_column'
+
+module Property
+  # This module lets you use a custom class to store a schema inside
+  # the database. The custom class must also include StoredRole.
+  module StoredSchema
+    include SchemaModule
+
+    def self.included(base)
+      base.class_eval do
+        attr_writer :class, :superschema
+        
+        def after_initialize
+          initialize_schema_module(:class => @class, :superschema => @superschema)
+        end
+      end
+    end
+  end
+end

data/lib/property/version.rb

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

data/property.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{property}
-  s.version = "2.0.0"
+  s.version = "2.1.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-11-10}
+  s.date = %q{2010-11-15}
   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 = [
@@ -38,11 +38,13 @@ Gem::Specification.new do |s|
      "lib/property/role.rb",
      "lib/property/role_module.rb",
      "lib/property/schema.rb",
+     "lib/property/schema_module.rb",
      "lib/property/serialization/json.rb",
      "lib/property/serialization/marshal.rb",
      "lib/property/serialization/yaml.rb",
      "lib/property/stored_column.rb",
      "lib/property/stored_role.rb",
+     "lib/property/stored_schema.rb",
      "lib/property/version.rb",
      "property.gemspec",
      "test/database.rb",

data/test/unit/property/stored_role_test.rb

@@ -10,8 +10,16 @@ class StoredRoleTest < ActiveSupport::TestCase
     include Property::StoredRole
     stored_columns_class 'StoredRoleTest::Column'
   end
+  
+  class Schema < Role
+    include Property::StoredSchema
+  end
 
   should_store_property_definitions(Role)
+  
+  context 'A Schema class' do
+    should_store_property_definitions(Schema)
+  end
 
   context 'A stored Role' do
 
@@ -24,92 +32,8 @@ class StoredRoleTest < ActiveSupport::TestCase
         @poet = Role.find(role.id)
       end
 
+      should_insert_properties_on_include_role_poet
       
-      # ========================== should_insert_properties_on_include_role_poet
-      
-        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'
-
-                def muse
-                  'I am your muse'
-                end
-              end
-
-              @klass = Class.new(@parent)
-            end
-
-            should 'propagate definitions to child' do
-              @parent.include_role @poet
-              assert_equal %w{name poem year}, @klass.schema.column_names.sort
-            end
-
-            should 'return true on has_role?' do
-              @parent.include_role @poet
-              assert @klass.has_role?(@poet)
-            end
-
-            should 'not raise an exception on double inclusion' do
-              @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.include_role @poet
-
-              assert_nothing_raised { subject.poem = 'Poe'}
-            end
-          end
-
-          context 'to a class' do
-            setup do
-              @klass = Class.new(ActiveRecord::Base) do
-                set_table_name :dummies
-                include Property
-                property.string 'name'
-
-                def muse
-                  'I am your muse'
-                end
-              end
-            end
-
-            should 'insert definitions' do
-              @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.include_role @poet
-              assert @klass.has_role?(@poet)
-            end
-
-            should 'return role from column' do
-              @klass.include_role @poet
-              assert_equal (@poet.kind_of?(Class) ? @poet.schema : @poet), @klass.schema.columns['poem'].role
-            end
-          end
-
-          context 'to an instance' do
-            subject { Developer.new }
-
-            setup do
-              subject.include_role @poet
-            end
-
-            should 'merge property definitions' do
-              assert_equal %w{age first_name language last_name poem year}, subject.schema.column_names.sort
-            end
-          end
-        end
-      # ==========================
       should_take_part_in_used_list(false)
       should_not_maintain_indices # no indexed column defined
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: property
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 11
   prerelease: false
   segments: 
   - 2
+  - 1
   - 0
-  - 0
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors: 
 - Renaud Kern
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-10 00:00:00 +01:00
+date: 2010-11-15 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -78,11 +78,13 @@ files:
 - lib/property/role.rb
 - lib/property/role_module.rb
 - lib/property/schema.rb
+- lib/property/schema_module.rb
 - lib/property/serialization/json.rb
 - lib/property/serialization/marshal.rb
 - lib/property/serialization/yaml.rb
 - lib/property/stored_column.rb
 - lib/property/stored_role.rb
+- lib/property/stored_schema.rb
 - lib/property/version.rb
 - property.gemspec
 - test/database.rb