datamapper 0.2.2 → 0.2.3

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

@@ -31,6 +31,10 @@ module DataMapper
             end
           end
           
+          def schema
+            @schema || @schema = @adapter.schema
+          end
+          
           def multi_class?
             @multi_class
           end
@@ -53,7 +57,7 @@ module DataMapper
           end
           
           def drop!
-            @adapter.drop(database, self) if exists?
+            @adapter.drop(database, self)
           end
           
           def create!(force = false)
@@ -133,8 +137,8 @@ module DataMapper
             @to_exists_sql || @to_exists_sql = <<-EOS.compress_lines
               SELECT TABLE_NAME
               FROM INFORMATION_SCHEMA.TABLES
-              WHERE TABLE_NAME = #{@adapter.quote_value(name)}
-                AND TABLE_SCHEMA = #{@adapter.quote_value(@adapter.schema.name)}
+              WHERE TABLE_NAME = ?
+                AND TABLE_SCHEMA = ?
             EOS
           end
           

data/lib/data_mapper/adapters/sql/quoting.rb

@@ -18,59 +18,6 @@ module DataMapper
           name.ensure_wrapped_with(self.class::COLUMN_QUOTING_CHARACTER)
         end
 
-        def quote_value(value)
-          return 'NULL' if value.nil?
-
-          case value
-            when Numeric then quote_numeric(value)
-            when String then quote_string(value)
-            when Class then quote_class(value)
-            when Time then quote_time(value)
-            when DateTime then quote_datetime(value)
-            when Date then quote_date(value)
-            when TrueClass, FalseClass then quote_boolean(value)
-            when Array then quote_array(value)
-            else 
-              if value.respond_to?(:to_sql)
-                value.to_sql
-              else
-                raise "Don't know how to quote #{value.inspect}"
-              end
-          end
-        end
-        
-        def quote_numeric(value)
-          value.to_s
-        end
-        
-        def quote_string(value)
-          "'#{value.gsub("'", "''")}'"
-        end
-        
-        def quote_class(value)
-          "'#{value.name}'"
-        end
-        
-        def quote_time(value)
-          "'#{value.xmlschema}'"
-        end
-        
-        def quote_datetime(value)
-          "'#{value}'"
-        end
-        
-        def quote_date(value)
-          "'#{value.strftime("%Y-%m-%d")}'"
-        end
-        
-        def quote_boolean(value)
-          value.to_s.upcase
-        end
-        
-        def quote_array(value)
-          "(#{value.map { |entry| quote_value(entry) }.join(', ')})"
-        end
-
       end # module Quoting
     end
   end

data/lib/data_mapper/adapters/sqlite3_adapter.rb

@@ -26,6 +26,7 @@ module DataMapper
       
       def create_connection
         conn = DataObject::Sqlite3::Connection.new("dbname=#{@configuration.database}")
+        conn.logger = self.logger
         conn.open
         return conn
       end
@@ -43,7 +44,7 @@ module DataMapper
               SELECT "name"
               FROM "sqlite_master"
               WHERE "type" = "table"
-                AND "name" = #{@adapter.quote_value(name)}
+                AND "name" = ?
             EOS
           end
         end # class Table

data/lib/data_mapper/base.rb

@@ -184,6 +184,21 @@ module DataMapper
       @new_record.nil? || @new_record
     end
     
+    def ^(other)
+      results = {}
+      
+      self_attributes, other_attributes = attributes, other.attributes
+      
+      self_attributes.each_pair do |k,v|
+        other_value = other_attributes[k]
+        unless v == other_value
+          results[k] = [v, other_value]
+        end
+      end
+      
+      results      
+    end
+    
     def loaded_attributes
       pairs = {}
       
@@ -194,6 +209,11 @@ module DataMapper
       pairs
     end
     
+    def update_attributes(update_hash)
+      self.attributes = update_hash
+      self.save
+    end
+    
     def attributes
       pairs = {}
       
@@ -224,11 +244,7 @@ module DataMapper
     def dirty?(name = nil)
       if name.nil?
         session.table(self).columns.any? do |column|
-          if value = self.instance_variable_get(column.instance_variable_name)
-            value.hash != original_hashes[column.name]
-          else
-            false
-          end
+          self.instance_variable_get(column.instance_variable_name) != original_values[column.name]
         end || loaded_associations.any? do |loaded_association|
           if loaded_association.respond_to?(:dirty?)
             loaded_association.dirty?
@@ -238,7 +254,7 @@ module DataMapper
         end
       else
         key = name.kind_of?(Symbol) ? name : name.to_sym
-        self.instance_variable_get("@#{name}").hash != original_hashes[key]
+        self.instance_variable_get("@#{name}") != original_values[key]
       end
     end
 
@@ -253,7 +269,7 @@ module DataMapper
         end
       else
         session.table(self).columns.each do |column|
-          if (value = instance_variable_get(column.instance_variable_name)).hash != original_hashes[column.name]
+          if (value = instance_variable_get(column.instance_variable_name)) != original_values[column.name]
             pairs[column.name] = value
           end
         end
@@ -262,8 +278,8 @@ module DataMapper
       pairs
     end
     
-    def original_hashes
-      @original_hashes || (@original_hashes = {})
+    def original_values
+      @original_values || (@original_values = {})
     end
     
     def protected_attribute?(key)

data/lib/data_mapper/context.rb

@@ -94,8 +94,8 @@ module DataMapper
       @adapter.table(klass)
     end
     
-    def log
-      @adapter.log
+    def logger
+      @logger || @logger = @adapter.logger
     end
 
   end

data/lib/data_mapper/database.rb

@@ -205,16 +205,16 @@ module DataMapper
     end
     
     # Default Logger from Ruby's logger.rb
-    def log
-      @log = Logger.new(@log_stream, File::WRONLY | File::APPEND | File::CREAT)
-      @log.level = @log_level
-      at_exit { @log.close }
+    def logger
+      @logger = Logger.new(@log_stream, File::WRONLY | File::APPEND | File::CREAT)
+      @logger.level = @log_level
+      at_exit { @logger.close }
       
       class << self
-        attr_reader :log
+        attr_reader :logger
       end
       
-      return @log
+      return @logger
     end
     
   end

data/lib/data_mapper/support/active_record_impersonation.rb

@@ -12,7 +12,7 @@ module DataMapper
       end
       
       def reload!
-        session.first(self.class, key, :select => original_hashes.keys, :reload => true)
+        session.first(self.class, key, :select => original_values.keys, :reload => true)
       end
       
       def reload

data/lib/data_mapper/support/serialization.rb

@@ -46,7 +46,7 @@ module DataMapper
           next if column.key?
           value = send(column.name)
           node = root.add_element(column.to_s)
-          node << REXML::Text.new(value.to_s) unless value.nil?
+          node << REXML::Text.new(copy_frozen_value(value).to_s) unless value.nil?
         end
         
         doc.to_s
@@ -58,12 +58,20 @@ module DataMapper
         result = '{ '
         
         result << table.columns.map do |column|
-          "#{column.name.to_json}: #{send(column.name).to_json(*a)}"
+          "#{column.name.to_json}: #{copy_frozen_value(send(column.name)).to_json(*a)}"
         end.join(', ')
         
         result << ' }'
         result
       end
+      
+      def copy_frozen_value(value)
+        case value
+        when Date, DateTime, Time, String then value.dup
+        when Fixnum, Class then value
+        else value
+        end
+      end
     end
   end # module Support
 end # module DataMapper

data/lib/data_mapper/support/silence.rb

@@ -0,0 +1,10 @@
+module Kernel
+  def silence_warnings 
+     old_verbose, $VERBOSE = $VERBOSE, nil 
+     begin 
+       yield 
+     ensure 
+       $VERBOSE = old_verbose 
+     end 
+  end
+end

data/lib/data_mapper/support/string.rb

@@ -4,7 +4,18 @@ module DataMapper
       
       # I set the constant on the String itself to avoid inheritance chain lookups.
       def self.included(base)
-        base.const_set('EMPTY', ''.freeze)
+        base.extend(ClassMethods)
+      end
+      
+      module ClassMethods
+        # Overwrite this method to provide your own translations.
+        def translate(value)
+          translations[value] || value
+        end
+        
+        def translations
+          @translations || @translations = {}
+        end
       end
       
       def ensure_starts_with(part)
@@ -52,6 +63,15 @@ module DataMapper
         end
       end
       
+      # Formats String for easy translation. Replaces an arbitrary number of 
+      # values using numeric identifier replacement.
+      # 
+      #   "%s %s %s" % %w(one two three) #=> "one two three"
+      #   "%3$s %2$s %1$s" % %w(one two three) #=> "three two one"
+      def t(*values)
+        self.class::translate(self) % values
+      end
+      
     end # module String
   end # module Support
 end # module DataMapper

data/lib/data_mapper/validations/confirmation_validator.rb

@@ -13,10 +13,8 @@ module DataMapper
       end
       
       def call(target)
-        field = Inflector.humanize(@field_name)
-
         unless valid?(target)
-          error_message = validation_error_message(ERROR_MESSAGES[:confirmation], nil, binding)        
+          error_message = '%s does not match the confirmation'.t(Inflector.humanize(@field_name))
           add_error(target, error_message , @field_name)
           return false
         end

data/lib/data_mapper/validations/format_validator.rb

@@ -8,11 +8,6 @@ module DataMapper
       # Seems to me that all this email garbage belongs somewhere else...  Where's the best
       # place to stick it?
       include DataMapper::Validations::Helpers::Email
-
-      ERROR_MESSAGES = {
-        :invalid => '#{field} is invalid',
-        :invalid_email => '#{value} is not a valid email address'
-      }
             
       FORMATS = {
         :email_address => [lambda { |email_address| email_address =~ DataMapper::Validations::Helpers::Email::RFC2822::EmailAddress }, :invalid_email]
@@ -52,7 +47,12 @@ module DataMapper
           field = Inflector.humanize(@field_name)
           value = target.instance_variable_get("@#{@field_name}")
           
-          error_message = validation_error_message(ERROR_MESSAGES[message_key], nil, binding)        
+          error_message = if message_key == :invalid
+            '%s is invalid'.t(field)
+          else
+            '%s is not a valid email address'.t(value)
+          end
+          
           add_error(target, error_message , @field_name)
         end
         

data/lib/data_mapper/validations/generic_validator.rb

@@ -9,11 +9,6 @@ module DataMapper
         target.errors.add(attribute, message)
       end
       
-      # Gets the proper error message
-      def validation_error_message(default, custom_message, validation_binding)
-        eval("\"#{(custom_message || default)}\"", validation_binding)
-      end
-      
       # Call the validator. We use "call" so the operation
       # is BoundMethod and Block compatible.
       # The result should always be TRUE or FALSE.

data/lib/data_mapper/validations/length_validator.rb

@@ -3,13 +3,6 @@ module DataMapper
     
     class LengthValidator < GenericValidator
       
-      ERROR_MESSAGES = {
-        :range => '#{field} must be between #{min} and #{max} characters long',
-        :min => '#{field} must be more than #{min} characters long',
-        :max => '#{field} must be less than #{max} characters long',
-        :equals => '#{field} must be #{equal} characters long'
-      }
-      
       def initialize(field_name, options)
         @field_name = field_name
         @options = options
@@ -35,17 +28,25 @@ module DataMapper
         max = @range ? @range.max : @max
         equal = @equal
 
-        error_message = validation_error_message(ERROR_MESSAGES[@validation_method], nil, binding)
+        error_message = nil
         
-        valid = case @validation_method
+        case @validation_method
         when :range then
-          @range.include?(field_value.size)
+          unless valid = @range.include?(field_value.size)
+            error_message = '%s must be between %s and %s characters long'.t(field, min, max)
+          end
         when :min then
-          field_value.size >= min
+          unless valid = field_value.size >= min
+            error_message = '%s must be more than %s characters long'.t(field, min)
+          end
         when :max then
-          field_value.size <= max
+          unless valid = field_value.size <= max
+            error_message = '%s must be less than %s characters long'.t(field, max)
+          end
         when :equals then
-          field_value.size == equal
+          unless valid = field_value.size == equal
+            error_message = '%s must be %s characters long'.t(field, equal)
+          end
         end
         
         add_error(target, error_message, @field_name) unless valid

data/lib/data_mapper/validations/required_field_validator.rb

@@ -2,11 +2,7 @@ module DataMapper
   module Validations
     
     class RequiredFieldValidator < GenericValidator
-      
-      ERROR_MESSAGES = {
-        :required => '#{field} must not be blank'
-      }
-      
+
       def initialize(field_name)
         @field_name = field_name
       end
@@ -15,9 +11,7 @@ module DataMapper
         field_value = !target.instance_variable_get("@#{@field_name}").nil?
         return true if field_value
         
-        field = Inflector.humanize(@field_name)
-        
-        error_message = validation_error_message(ERROR_MESSAGES[:required], nil, binding)        
+        error_message = "%s must not be blank".t(Inflector.humanize(@field_name))
         add_error(target, error_message , @field_name)
         
         return false

data/lib/data_mapper/validations/unique_validator.rb

@@ -3,20 +3,14 @@ module DataMapper
     
     class UniqueValidator < GenericValidator
       
-      ERROR_MESSAGES = {
-        :unique => '#{field} has already been taken'
-      }
-      
       def initialize(field_name, options = {})
         @options = options
         @field_name = field_name.to_sym
       end
       
       def call(target)
-        field = Inflector.humanize(@field_name)
-
         unless valid?(target)
-          error_message = validation_error_message(ERROR_MESSAGES[:unique], nil, binding)        
+          error_message = '%s has already been taken'.t(Inflector.humanize(@field_name))
           add_error(target, error_message , @field_name)
           return false
         end