property 0.9.1 → 1.0.0

data/lib/property/stored_role.rb

@@ -0,0 +1,101 @@
+require 'property/role_module'
+require 'property/stored_column'
+
+module Property
+  # This module lets you use a custom class to store a set of property definitions inside
+  # the database. For the rest, this class behaves just like Role.
+  #
+  # 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
+  module StoredRole
+    include RoleModule
+
+    module ClassMethods
+      def stored_columns_class(columns_class)
+        has_many :stored_columns, :class_name => columns_class
+      end
+    end
+
+    def self.included(base)
+      base.class_eval do
+        after_save :update_columns
+        validates_presence_of :name
+        extend ClassMethods
+
+        def self.new(arg, &block)
+          unless arg.kind_of?(Hash)
+            arg = {:name => arg}
+          end
+
+          if block_given?
+            obj = super(arg) do
+              # Dummy block to hide our special property declaration block
+            end
+
+            obj.property(&block)
+          else
+            obj = super(arg)
+          end
+
+          obj
+        end
+
+        # Initialize a new role with the given name
+        def initialize(*args)
+          super
+          initialize_role_module
+        end
+      end
+    end # included
+
+    # List all property definitions for the current role
+    def columns
+      load_columns_from_db unless @columns_from_db_loaded
+      super
+    end
+
+    def property
+      initialize_role_module unless @accessor_module
+      super
+    end
+
+
+    private
+      def load_columns_from_db
+        initialize_role_module
+        @columns_from_db_loaded = true
+        @original_columns = {}
+        stored_columns.each do |column|
+          @original_columns[column.name] = column
+          add_column(Property::Column.new(column.name, column.default, column.ptype, column.options))
+        end
+      end
+
+      def update_columns
+        @original_columns ||= {}
+        stored_column_names  = @original_columns.keys
+        defined_column_names = self.column_names
+
+        new_columns     = defined_column_names - stored_column_names
+        updated_columns = defined_column_names & stored_column_names
+        # Not needed: there is no way to remove a property right now
+        # deleted_columns = stored_column_names - defined_column_names
+
+        new_columns.each do |name|
+          ActiveRecord::Base.logger.warn "Creating #{name} column"
+          stored_columns.create(:name => name, :ptype => columns[name].type.to_s)
+        end
+
+        updated_columns.each do |name|
+          @original_columns[name].update_attributes(:name => name, :ptype => columns[name].type.to_s)
+        end
+
+        # Not needed: there is no way to remove a property right now
+        # deleted_columns.each do |name|
+        #   @original_columns[name].destroy!
+        # end
+      end
+  end
+end

data/property.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{property}
-  s.version = "0.9.1"
+  s.version = "1.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-03-20}
+  s.date = %q{2010-05-27}
   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 = [
@@ -24,30 +24,41 @@ Gem::Specification.new do |s|
      "generators/property/property_generator.rb",
      "lib/property.rb",
      "lib/property/attribute.rb",
-     "lib/property/behavior.rb",
+     "lib/property/base.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/error.rb",
      "lib/property/index.rb",
      "lib/property/properties.rb",
+     "lib/property/redefined_method_error.rb",
+     "lib/property/redefined_property_error.rb",
+     "lib/property/role.rb",
+     "lib/property/role_module.rb",
      "lib/property/schema.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",
      "property.gemspec",
      "test/fixtures.rb",
+     "test/shoulda_macros/index.rb",
+     "test/shoulda_macros/role.rb",
      "test/shoulda_macros/serialization.rb",
      "test/test_helper.rb",
      "test/unit/property/attribute_test.rb",
-     "test/unit/property/behavior_test.rb",
+     "test/unit/property/base_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_custom_test.rb",
      "test/unit/property/index_foreign_test.rb",
      "test/unit/property/index_simple_test.rb",
+     "test/unit/property/role_test.rb",
+     "test/unit/property/stored_role_test.rb",
      "test/unit/property/validation_test.rb",
      "test/unit/serialization/json_test.rb",
      "test/unit/serialization/marshal_test.rb",
@@ -61,16 +72,20 @@ Gem::Specification.new do |s|
   s.summary = %q{model properties wrap into a single database column}
   s.test_files = [
     "test/fixtures.rb",
+     "test/shoulda_macros/index.rb",
+     "test/shoulda_macros/role.rb",
      "test/shoulda_macros/serialization.rb",
      "test/test_helper.rb",
      "test/unit/property/attribute_test.rb",
-     "test/unit/property/behavior_test.rb",
+     "test/unit/property/base_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_custom_test.rb",
      "test/unit/property/index_foreign_test.rb",
      "test/unit/property/index_simple_test.rb",
+     "test/unit/property/role_test.rb",
+     "test/unit/property/stored_role_test.rb",
      "test/unit/property/validation_test.rb",
      "test/unit/serialization/json_test.rb",
      "test/unit/serialization/marshal_test.rb",

data/test/fixtures.rb

@@ -4,6 +4,9 @@ class Employee < ActiveRecord::Base
   property.string 'first_name', :default => '', :index => true
   property.string 'last_name',  :default => '', :index => true
   property.float  'age'
+
+  def method_in_parent
+  end
 end
 
 class Developer < Employee
@@ -78,6 +81,23 @@ begin
         t.string  'value'
       end
 
+      # multilingual index strings in employees
+      create_table 'i_ml_string_employees' do |t|
+        t.integer 'employee_id'
+        t.integer 'version_id'
+        t.string  'lang'
+        t.integer 'site_id'
+        t.string  'key'
+        t.string  'value'
+      end
+
+      # index strings in employees
+      create_table 'i_special_employees' do |t|
+        t.integer 'employee_id'
+        t.string  'key'
+        t.string  'value'
+      end
+
       # index integer in employees
       create_table 'i_integer_employees' do |t|
         t.integer 'employee_id'
@@ -99,11 +119,29 @@ begin
         t.string 'name'
         t.string 'other_name'
       end
+
+      # Database stored role
+      create_table 'roles' do |t|
+        t.integer 'id'
+        t.string 'name'
+      end
+
+      create_table 'columns' do |t|
+        t.integer 'id'
+        t.integer 'role_id'
+        t.string 'name'
+        # Property Type
+        t.string 'ptype'
+        # Indexed (we store an integer so that we can have multiple index types)
+        t.string 'index'
+      end
     end
   end
 
   ActiveRecord::Base.establish_connection(:adapter=>'sqlite3', :database=>':memory:')
-#  ActiveRecord::Base.logger = Logger.new(STDOUT)
+  log_path = Pathname(__FILE__).dirname + '../log/test.log'
+  Dir.mkdir(log_path.dirname) unless File.exist?(log_path.dirname)
+  ActiveRecord::Base.logger = Logger.new(File.open(log_path, 'wb'))
   ActiveRecord::Migration.verbose = false
   #PropertyMigration.migrate(:down)
   PropertyMigration.migrate(:up)

data/test/shoulda_macros/index.rb

@@ -0,0 +1,95 @@
+module IndexMacros
+  class IndexedStringEmp < ActiveRecord::Base
+    set_table_name :i_string_employees
+  end
+
+  class MLIndexedStringEmp < ActiveRecord::Base
+    set_table_name :i_ml_string_employees
+  end
+
+  class IndexedIntegerEmp < ActiveRecord::Base
+    set_table_name :i_integer_employees
+  end
+
+  # Simple class
+  class Employee < ActiveRecord::Base
+    include Property
+
+    def index_reader(group_name)
+      if group_name.to_s == 'ml_string'
+        super.merge(:with => {'lang' => ['en', 'fr'], 'site_id' => '123'})
+      else
+        super
+      end
+    end
+  end
+end
+
+class Test::Unit::TestCase
+
+  def self.should_maintain_indices
+
+    context "assigned to an instance of Dummy" do
+      subject do
+        dummy = IndexMacros::Employee.new
+        dummy.has_role @poet
+        dummy
+      end
+
+      should 'use index_reader method' do
+        assert_equal Hash[:with=>{'lang'=>['en', 'fr'], 'site_id'=>'123'}, "employee_id"=>nil], subject.index_reader(:ml_string)
+      end
+
+      should 'create multilingual string indices on save' do
+        assert_difference('IndexMacros::MLIndexedStringEmp.count', 2) do
+          subject.poem = 'Hyperions Schicksalslied'
+          subject.save
+        end
+      end
+
+      should 'create integer indices on save' do
+        assert_difference('IndexMacros::IndexedIntegerEmp.count', 1) do
+          subject.year = 1770
+          subject.save
+        end
+      end
+
+      should 'not create blank indices on save' do
+        assert_difference('IndexMacros::IndexedStringEmp.count', 0) do
+          assert_difference('IndexMacros::IndexedIntegerEmp.count', 0) do
+            subject.save
+          end
+        end
+      end
+    end # An instance of Person
+  end
+
+  def self.should_not_maintain_indices
+
+    context "assigned to an instance of Dummy" do
+      subject do
+        dummy = IndexMacros::Employee.new
+        dummy.has_role @poet
+        dummy
+      end
+
+      should 'not create indices on save' do
+        assert_difference('IndexMacros::IndexedStringEmp.count', 0) do
+          assert_difference('IndexMacros::IndexedIntegerEmp.count', 0) do
+            subject.year = 1770
+            subject.poem = 'Hyperions Schicksalslied'
+            subject.save
+          end
+        end
+      end
+
+      should 'not create blank indices on save' do
+        assert_difference('IndexMacros::IndexedStringEmp.count', 0) do
+          assert_difference('IndexMacros::IndexedIntegerEmp.count', 0) do
+            subject.save
+          end
+        end
+      end
+    end # An instance of Person
+  end
+end

data/test/shoulda_macros/role.rb

@@ -0,0 +1,237 @@
+class Test::Unit::TestCase
+  def self.should_store_property_definitions(klass)
+    subject { klass.new('Foobar') }
+
+    should 'allow string columns' do
+      subject.property.string('weapon')
+      column = subject.columns['weapon']
+      assert_equal 'weapon', column.name
+      assert_equal String, column.klass
+      assert_equal :string, column.type
+    end
+
+    should 'treat symbol keys as strings' do
+      subject.property.string(:weapon)
+      column = subject.columns['weapon']
+      assert_equal 'weapon', column.name
+      assert_equal String, column.klass
+      assert_equal :string, column.type
+    end
+
+    should 'allow integer columns' do
+      subject.property.integer('indestructible')
+      column = subject.columns['indestructible']
+      assert_equal 'indestructible', column.name
+      assert_equal Fixnum, column.klass
+      assert_equal :integer, column.type
+    end
+
+    should 'allow float columns' do
+      subject.property.float('boat')
+      column = subject.columns['boat']
+      assert_equal 'boat', column.name
+      assert_equal Float, column.klass
+      assert_equal :float, column.type
+    end
+
+    should 'allow datetime columns' do
+      subject.property.datetime('time_weapon')
+      column = subject.columns['time_weapon']
+      assert_equal 'time_weapon', column.name
+      assert_equal Time, column.klass
+      assert_equal :datetime, column.type
+    end
+
+    should 'allow default value option' do
+      subject.property.integer('force', :default => 10)
+      column = subject.columns['force']
+      assert_equal 10, column.default
+    end
+
+    should 'allow index option' do
+      subject.property.string('rolodex', :index => true)
+      column = subject.columns['rolodex']
+      assert column.indexed?
+    end
+
+    should 'return a list of indices on indices' do
+      subject.property.string('rolodex', :index => true)
+      subject.property.integer('foobar', :index => true)
+      assert_equal %w{integer string}, subject.indices.map {|i| i[0].to_s }.sort
+    end
+
+    context 'created with a Hash' do
+      subject { klass.new(:name => 'Foobar') }
+
+      should 'set name' do
+        assert_equal 'Foobar', subject.name
+      end
+    end
+
+    context 'created with a String Hash' do
+      subject { klass.new('name' => 'Foobar') }
+
+      should 'set name' do
+        assert_equal 'Foobar', subject.name
+      end
+    end
+  end # should_store_property_definitions
+
+  def self.should_insert_properties_on_has_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'
+          end
+
+          @klass = Class.new(@parent)
+        end
+
+        should 'propagate definitions to child' do
+          @parent.has_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
+          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 }
+        end
+
+        should 'add accessor methods to child' do
+          subject = @klass.new
+          assert_raises(NoMethodError) { subject.poem = 'Poe'}
+          @parent.has_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'
+          end
+        end
+
+        should 'insert definitions' do
+          @klass.has_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
+          assert @klass.has_role?(@poet)
+        end
+
+      end
+
+      context 'to an instance' do
+        subject { Developer.new }
+
+        setup do
+          subject.has_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
+  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
+
+  def self.should_take_part_in_used_list(has_defaults = true)
+
+    context 'added' do
+      context 'to a class' do
+        setup do
+          @klass = Class.new(ActiveRecord::Base) do
+            set_table_name :dummies
+            include Property
+            property.string 'name'
+          end
+
+          @klass.has_role @poet
+        end
+
+        subject do
+          @klass.new
+        end
+
+        should 'return true on instance has_role?' do
+          assert subject.has_role?(@poet)
+        end
+
+        should 'not return role without corresponding attributes' do
+          subject.attributes = {'name' => 'hello'}
+          assert_equal [@klass.schema.role], subject.used_roles
+        end
+
+        should 'return role with corresponding attributes' do
+          subject.attributes = {'poem' => 'hello'}
+          roles = @poet.kind_of?(Class) ? @poet.schema.roles : [@poet]
+          assert_equal roles, subject.used_roles
+        end
+
+        should 'not return role only with blank attributes' do
+          subject.attributes = {'name' => ''}
+          assert_equal [], subject.used_roles
+        end
+
+        if has_defaults
+          should 'return role with default attributes after validate' do
+            subject.valid?
+            roles = @poet.kind_of?(Class) ? @poet.schema.roles : [@poet]
+            assert_equal roles, subject.used_roles
+          end
+        end
+      end # to a class
+    end # added
+  end
+end