datamapper 0.2.4 → 0.2.5

data/CHANGELOG

@@ -123,4 +123,19 @@
 * MAJOR: Resolve issue with non-unique-hash values and #dirty?; now frozen original values are stored instead
 * Added Base#update_attributes
 * MAJOR: Queries are now passed to the database drivers in a parameterized fashion
-* Updated PostgreSQL driver and adapter to current
+* Updated PostgreSQL driver and adapter to current
+
+-- 0.2.4
+* Bug fixes
+* Added paranoia
+
+-- 0.2.5
+* has_one bugfixes
+* Added syntax for setting CHECK-constraints directly in your properties (Postgres)
+* You can now set indexes with :index => true and :index => :unique
+* Support for composite indexes (thanks to Jeffrey Gelens)
+* Add composite scope to validates_uniqueness
+* Added private/protected properties
+* Remove HasOneAssociation, Make HasManyAssociation impersonate has_one relationships
+* Added #get method
+* Persistence module added, inheriting from DataMapper::Base no longer necessary

data/README

@@ -93,10 +93,10 @@ Ruby on Rails project, and have a database.yml, DataMapper should pick it up aut
 
 If you'd like to set the database connection manually before using it, do something like this:
   DataMapper::Database.setup({
-    :adapter  => 'mysql'
-    :host     => 'localhost'
-    :username => 'root'
-    :password => 'R00tPaswooooord'
+    :adapter  => 'mysql',
+    :host     => 'localhost',
+    :username => 'root',
+    :password => 'R00tPaswooooord',
     :database => 'selecta_development'
   })
   
@@ -109,7 +109,7 @@ SQLite3:: (sqlite3 adaptor)
 
 Defining your models requires a few steps.
 
-* Inherit your class from DataMapper::Base
+* Include the module DataMapper::Persistence in your class
 * Define your properties you wish to access from the database
 * Define any relationships (optional)
 
@@ -119,7 +119,9 @@ which are too numerous to go into here.
 
 Your models might end up looking something like this:
 
-  class Animal < DataMapper::Base
+  class Animal
+    include DataMapper::Persistence
+
     property :name, :string
     property :notes, :text, :lazy => true
 
@@ -187,7 +189,7 @@ This will generate the table structure for your model automatically.
 
 You can also execute the following to generate ALL of your models' tables:
 
-  DataMapper::Base.auto_migrate!
+  DataMapper::Persistence.auto_migrate!
 
 === NOTE
 Both of these methods are DESTRUCTIVE. If you are working in anything other than a pre-production environment, 
@@ -198,4 +200,4 @@ stay far away from these methods!
 Merb's coding conventions are a fantastic start: (http://merb.devjavu.com/#ContributingtoMerb)
 
 DataMapper could use some documentation help. If you'd like to contribute, the example you'll
-find on the above link is top-notch.
+find on the above link is top-notch.

data/environment.rb

@@ -41,4 +41,4 @@ DataMapper::Database.setup(:mock, :adapter => MockAdapter)
 [:default, :mock].each { |name| database(name) { load_models.call } }
 
 # Reset the test database.
-DataMapper::Base.auto_migrate! unless ENV['AUTO_MIGRATE'] == 'false'
+DataMapper::Persistence.auto_migrate! unless ENV['AUTO_MIGRATE'] == 'false'

data/example.rb

@@ -26,7 +26,8 @@ end
 
 require 'irb'
 
-database { IRB::start }
+# database { IRB::start }
+IRB::start
 
 if false
 
@@ -37,7 +38,9 @@ DataMapper::Database.setup({
   :username => 'root'
 })
 
-class Animal < DataMapper::Base #:nodoc:
+class Animal #:nodoc:
+  include DataMapper::Persistence
+  
   set_table_name 'animals' # Just as an example. Same inflector as Rails,
     # so this really isn't necessary.
     
@@ -47,17 +50,22 @@ class Animal < DataMapper::Base #:nodoc:
   has_and_belongs_to_many :exhibits
 end
 
-class Exhibit < DataMapper::Base #:nodoc:
+class Exhibit #:nodoc:
+  include DataMapper::Persistence
+
   property :name, :string
   belongs_to :zoo
 end
 
-class Zoo < DataMapper::Base #:nodoc:
+class Zoo #:nodoc:
+  include DataMapper::Persistence
+
   property :name, :string
   has_many :exhibits
 end
 
-class Person < DataMapper::Base #:nodoc:
+class Person #:nodoc:
+  include DataMapper::Persistence
 
   property :name, :string
   property :age, :integer

data/lib/data_mapper.rb

@@ -29,8 +29,10 @@ require 'data_mapper/support/silence'
 require 'data_mapper/support/inflector'
 require 'data_mapper/support/errors'
 require 'data_mapper/database'
+require 'data_mapper/persistence'
 require 'data_mapper/base'
 
+
 begin
   # This block of code is for compatibility with Ruby On Rails' or Merb's database.yml
   # file, allowing you to simply require the data_mapper.rb in your

data/lib/data_mapper/adapters/abstract_adapter.rb

@@ -29,10 +29,71 @@ module DataMapper
         raise NotImplementedError.new
       end
       
+      def get(database_context, klass, *keys)
+        raise NotImplementedError.new
+      end
+      
       def logger
         @logger || @logger = @configuration.logger
       end
       
+      protected
+      
+      def materialize(database_context, klass, values, reload, loaded_set)
+        
+        table = self.table(klass)
+        
+        instance_id = table.key.type_cast_value(values[table.key.name])
+        
+        instance_type = if table.multi_class? && table.type_column
+          values[table.type_column.name].blank? ? klass :
+            table.type_column.type_cast_value(values[table.type_column.name])
+        else
+          klass
+        end
+        
+        instance = create_instance(database_context, instance_type, instance_id, reload)
+        
+        instance_type.callbacks.execute(:before_materialize, instance)
+        
+        type_casted_values = {}
+        
+        values.each_pair do |k,v|
+          column = table[k]
+          type_cast_value = column.type_cast_value(v)
+          type_casted_values[k] = type_cast_value
+          instance.instance_variable_set(column.instance_variable_name, type_cast_value)
+        end
+        
+        instance.original_values = type_casted_values
+        instance.loaded_set = loaded_set
+
+        instance_type.callbacks.execute(:after_materialize, instance)
+
+        return instance
+        
+      #rescue => e
+      #  raise MaterializationError.new("Failed to materialize row: #{values.inspect}\n#{e.to_yaml}")
+      end
+      
+      def create_instance(database_context, instance_type, instance_id, reload)
+        instance = database_context.identity_map.get(instance_type, instance_id)
+
+        if instance.nil? || reload
+          instance = instance_type.new() if instance.nil?
+          instance.instance_variable_set(:@__key, instance_id)
+          instance.instance_variable_set(:@new_record, false)
+          database_context.identity_map.set(instance)
+        elsif instance.new_record?
+          instance.instance_variable_set(:@__key, instance_id)
+          instance.instance_variable_set(:@new_record, false)
+        end
+
+        instance.database_context = database_context
+
+        return instance
+      end
+      
     end # class AbstractAdapter
     
   end # module Adapters

data/lib/data_mapper/adapters/data_object_adapter.rb

@@ -138,6 +138,17 @@ module DataMapper
         db.close
       end      
       
+      def execute(*args)
+        db = create_connection
+        command = db.create_command(args.shift)
+        return command.execute_non_query(*args)
+      rescue => e
+        logger.error { e }
+        raise e
+      ensure
+        db.close
+      end
+      
       def handle_error(error)
         raise error
       end
@@ -186,14 +197,15 @@ module DataMapper
         case instance
         when Class then table(instance).create!
         when Mappings::Table then instance.create!
-        when DataMapper::Base then
-          return false unless instance.new_record? || instance.dirty?
-          
+        when DataMapper::Persistence then          
           event = instance.new_record? ? :create : :update
           
           return false if validate && !instance.validate_recursively(event, Set.new)
           
           callback(instance, :before_save)
+          
+          return false unless instance.new_record? || instance.dirty?
+          
           result = send(event, database_context, instance)
           
           instance.database_context = database_context
@@ -249,7 +261,7 @@ module DataMapper
 
         table = self.table(instance)
         attributes = instance.dirty_attributes
-        
+
         if table.multi_class?
           instance.instance_variable_set(
             table[:type].instance_variable_name,
@@ -263,7 +275,7 @@ module DataMapper
           keys << table[key].to_sql
           values << value
         end
-    
+
         sql = if keys.size > 0
           "INSERT INTO #{table.to_sql} (#{keys.join(', ')}) VALUES ?"
         else
@@ -283,10 +295,25 @@ module DataMapper
         self.class::Commands::LoadCommand.new(self, database_context, klass, options).call
       end
       
+      def get(database_context, klass, keys)
+        table = self.table(klass)
+        sql = "SELECT #{table.columns.map { |column| column.to_sql }.join(', ')} FROM #{table.to_sql} WHERE #{table.keys.map { |key| "#{key.to_sql} = ?" }.join(' AND ')}"
+        
+        connection do |db|
+          db.create_command(sql).execute_reader(*keys) do |reader|
+            values = {}
+            table.columns.each_with_index do |column, i|
+              values[column.name] = reader.item(i)
+            end
+            materialize(database_context, klass, values, false, [])
+          end
+        end
+      end
+      
       def table(instance)
         case instance
         when DataMapper::Adapters::Sql::Mappings::Table then instance
-        when DataMapper::Base then schema[instance.class]
+        when DataMapper::Persistence then schema[instance.class]
         when Class, String then schema[instance]
         else raise "Don't know how to map #{instance.inspect} to a table."
         end

data/lib/data_mapper/adapters/mysql_adapter.rb

@@ -13,6 +13,11 @@ module DataMapper
   module Adapters
     
     class MysqlAdapter < DataObjectAdapter
+      
+      TRUE_ALIASES << "T".freeze << "\004\bT".freeze
+      FALSE_ALIASES << "F".freeze << "\004\bF".freeze
+      
+      
       def create_connection
         
         connection_string = ""

data/lib/data_mapper/adapters/postgresql_adapter.rb

@@ -149,6 +149,10 @@ module DataMapper
             "SERIAL"
           end
           
+          def check_declaration
+          	"CHECK (" << check << ")"
+          end
+          
           def to_alter_sql
             "ALTER TABLE " <<  table.to_sql << " ALTER COLUMN " << to_alter_form
           end
@@ -221,6 +225,14 @@ module DataMapper
                 if default && !default_declaration.blank?
                   @to_long_form << " #{default_declaration}"
                 end
+                
+                if unique? && !unique_declaration.blank?
+                  @to_long_form << " #{unique_declaration}"
+                end
+                
+                if check && !check_declaration.blank?
+                  @to_long_form << " #{check_declaration}"
+                end
               end
                       
               @to_long_form

data/lib/data_mapper/adapters/sql/commands/load_command.rb

@@ -38,7 +38,6 @@ module DataMapper
             end
 
             def materialize(values)
-
               instance_id = @key.type_cast_value(values[@key_index])
               instance = create_instance(instance_id,
                 if @type_override_present
@@ -47,28 +46,23 @@ module DataMapper
                   @klass
                 end
               )
-
+              
               @klass.callbacks.execute(:before_materialize, instance)
 
-              original_values = instance.original_values
-
+              type_casted_values = {}
+              
               @columns.each_pair do |index, column|
                 # This may be a little confusing, but we're
                 # setting both the original_value, and the
                 # instance-variable through method chaining to avoid
                 # lots of extra short-lived local variables.
-                type_cast_value = instance.instance_variable_set(
+                type_casted_values[column.name] = instance.instance_variable_set(
                   column.instance_variable_name,
                   column.type_cast_value(values[index])
                 )
-                
-                original_values[column.name] = case type_cast_value
-                  when String, Date, Time then type_cast_value.dup
-                  when column.type == :object then Marshal.dump(type_cast_value)
-                  else type_cast_value
-                end
               end
-
+              
+              instance.original_values = type_casted_values
               instance.instance_variable_set(:@loaded_set, @set)
               @set << instance
 
@@ -85,8 +79,6 @@ module DataMapper
             end
 
             private
-              
-              class MaterializationError < StandardError; end
                 
               def create_instance(instance_id, instance_type)
                 instance = @database_context.identity_map.get(@klass, instance_id)

data/lib/data_mapper/adapters/sql/mappings/column.rb

@@ -6,8 +6,8 @@ module DataMapper
         # TODO: There are of course many more options to add here.
         # Ordinal, Length/Size, Nullability are just a few.
         class Column
-          
-          attr_reader :type, :name
+          attr_reader :type, :name, :ordinal, :size, :default, :check
+          attr_writer :lazy, :index
           attr_accessor :table, :options
           
           def initialize(adapter, table, name, type, ordinal, options = {})
@@ -21,6 +21,21 @@ module DataMapper
             @lazy = @options.has_key?(:lazy) ? @options[:lazy] : (@type == :text && !@key)
             @serial = @options[:serial] == true
             @default = @options[:default]
+            @unique = @options.has_value?(:unique)
+            @index = @options[:index]
+            @check = @options[:check] # only for postgresql
+            
+            @size = if @options.has_key?(:size)
+              @options[:size]
+            elsif @options.has_key?(:length)
+              @options[:length]
+            else
+              case type
+                when :integer then 11
+                when :string, :class then 50
+                else nil
+              end
+            end
           end
           
           def type=(value)
@@ -38,15 +53,7 @@ module DataMapper
             flush_sql_caches!
             @name = value
           end
-          
-          def ordinal
-            @ordinal
-          end
-    
-          def lazy=(value)
-            @lazy = value
-          end
-    
+
           # Determines if the field should be lazy loaded.
           # You can set this explicitly, or accept the default,
           # which is false for all but text fields.
@@ -66,10 +73,14 @@ module DataMapper
             @serial
           end
           
-          def default
-            @default
+          def unique?
+          	@unique
           end
           
+          def index?
+          	@index
+          end
+
           def default=(value)
             self.flush_sql_caches!
             @default = value
@@ -100,18 +111,10 @@ module DataMapper
               @to_sql || (@to_sql = @adapter.quote_column_name(column_name).freeze)
             end
           end
-      
-          def size
-            @size || begin
-              return @size = @options[:size] if @options.has_key?(:size)
-              return @size = @options[:length] if @options.has_key?(:length)
-          
-              @size = case type
-                when :integer then 11
-                when :string, :class then 50
-                else nil
-              end
-            end
+
+          def size=(val)
+            self.flush_sql_caches!
+            @size = val
           end
       
           def inspect
@@ -207,7 +210,11 @@ module DataMapper
               unless default.nil? || (value = default_declaration).blank?
                 @to_long_form << " #{value}"
               end
-        
+              
+              if unique? && !unique_declaration.blank?
+                @to_long_form << " #{unique_declaration}"
+              end
+              
               @to_long_form
             end
           end
@@ -244,6 +251,10 @@ module DataMapper
             "AUTO_INCREMENT"
           end
           
+          def unique_declaration
+          	"UNIQUE"
+          end
+          
           def default_declaration
             @adapter.connection { |db| db.create_command("DEFAULT ?").escape_sql([default]) }
           end