datamapper 0.2.0 → 0.2.1

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

@@ -9,10 +9,11 @@ module DataMapper
     
           attr_accessor :table, :name, :type, :options
     
-          def initialize(adapter, table, name, type, options = {})
+          def initialize(adapter, table, name, type, ordinal, options = {})
             @adapter = adapter
             @table = table
             @name, @type, @options = name.to_sym, type, options
+            @ordinal = ordinal
             
             @key = (@options[:key] == true)
             @nullable = @options.has_key?(:nullable) ? @options[:nullable] : !@key
@@ -26,6 +27,10 @@ module DataMapper
               end
             EOS
           end
+          
+          def ordinal
+            @ordinal
+          end
     
           def lazy=(value)
             @lazy = value
@@ -121,6 +126,18 @@ module DataMapper
             end
           end
           
+          def <=>(other)
+            ordinal <=> other.ordinal
+          end
+          
+          def hash
+            name.hash
+          end
+          
+          def eql?(other)
+            name == other.name
+          end
+          
           private
           
           def primary_key_declaration

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

@@ -17,9 +17,8 @@ module DataMapper
             @klass_or_name = klass_or_name
             
             @adapter = adapter
-            @columns = []
-            @columns_hash = Hash.new { |h,k| h[k] = @columns.find { |c| c.name == k } }
-            @columns_by_column_name = Hash.new { |h,k| h[k.to_s] = @columns.find { |c| c.column_name == k.to_s } }
+            @columns = SortedSet.new
+            @columns_hash = Hash.new { |h,k| h[k] = columns.find { |c| c.name == k } }
             
             @associations = AssociationsSet.new
             
@@ -65,40 +64,36 @@ module DataMapper
           end
       
           def key
-            if @key.nil?
-              key_column = @columns.find { |c| c.key? }
-              @key = if key_column.nil?
-                column = add_column(:id, :integer, :key => true)
+            @key || begin
+              @key = @columns.find { |column| column.key? }
+              
+              if @key.nil?
+                @key = add_column(:id, :integer, :key => true, :ordinal => -1)
                 @klass.send(:attr_reader, :id) unless @klass.methods.include?(:id)
-                column
-              else
-                key_column
               end
+              
+              @key
             end
-          
-            @key
           end
       
           def add_column(column_name, type, options)
-            column = @columns.find { |c| c.name == column_name.to_sym }
-        
-            if column.nil?
-              reset_derived_columns!
-              column = @adapter.class::Mappings::Column.new(@adapter, self, column_name, type, options)
-              @columns.send(column_name == :id ? :unshift : :push, column)
-              @multi_class = true if column_name == :type
+
+            column_ordinal = if options.is_a?(Hash) && options.has_key?(:ordinal)
+              options.delete(:ordinal)
+            else
+              @columns.size
             end
+            
+            column = @adapter.class::Mappings::Column.new(@adapter, self, column_name, type, column_ordinal, options)
+            @columns << column
+            
+            @multi_class = true if column_name == :type
         
             return column
           end
       
           def [](column_name)
-            return key if column_name == :id
-            @columns_hash[column_name.kind_of?(Symbol) ? column_name : column_name.to_sym]
-          end
-      
-          def find_by_column_name(column_name)
-            @columns_by_column_name[column_name.kind_of?(String) ? column_name : column_name.to_s]
+            @columns_hash[column_name.to_sym]
           end
       
           def name
@@ -157,13 +152,6 @@ module DataMapper
             ]
           end
       
-          private
-          def reset_derived_columns!
-            @columns_hash.clear
-            @columns_by_column_name.clear
-            @key = nil
-          end
-      
         end
     
       end

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

@@ -22,13 +22,14 @@ module DataMapper
           return 'NULL' if value.nil?
 
           case value
-            when Numeric then value.to_s
-            when String then "'#{value.gsub("'", "''")}'"
-            when Class then "'#{value.name}'"
-            when Date then "'#{value.to_s}'"
-            when Time, DateTime then "'#{value.utc.strftime("%Y-%m-%d %H:%M:%S")}'"
-            when TrueClass, FalseClass then value.to_s.upcase
-            when Array then "(#{value.map { |entry| quote_value(entry) }.join(', ')})"
+            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
@@ -37,6 +38,38 @@ module DataMapper
               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

data/lib/data_mapper/adapters/sqlite3_adapter.rb

@@ -1,7 +1,7 @@
 require 'data_mapper/adapters/data_object_adapter'
 begin
   require 'do_sqlite3'
-rescue
+rescue LoadError
   STDERR.puts <<-EOS
 You must install the DataObjects::SQLite3 driver.
   rake dm:install:sqlite3
@@ -29,6 +29,12 @@ module DataMapper
         conn.open
         return conn
       end
+      
+      def truncate(session, name)
+        result = execute("DELETE FROM #{table(name).to_sql}")
+        session.identity_map.clear!(name)
+        result.to_i > 0
+      end
           
       module Mappings
         class Table

data/lib/data_mapper/associations/has_and_belongs_to_many_association.rb

@@ -150,7 +150,12 @@ module DataMapper
                 
                 # Locate the column for the left-key.
                 unless left_key_index
-                  left_key_index = columns.index(association.left_foreign_key)
+                  columns.each_with_index do |column, index|
+                    if column.name == association.left_foreign_key.name
+                      left_key_index = index
+                      break
+                    end
+                  end
                 end
                 
                 if instance.kind_of?(association_constant)

data/lib/data_mapper/associations/has_many_association.rb

@@ -109,7 +109,7 @@ module DataMapper
         end # def items
         
         def inspect
-          @entries.inspect
+          entries.inspect
         end
       end
 

data/lib/data_mapper/context.rb

@@ -35,9 +35,11 @@ module DataMapper
         raise ArgumentError.new('Session#first takes a class, and optional type_or_id and/or options arguments')
       end
       
-      options.merge!(b.to_hash) if block_given?
+      # Account for undesired behaviour in MySQL that returns the
+      # last inserted row when the WHERE clause contains a "#{primary_key} IS NULL".
+      return nil if options.has_key?(:id) && options[:id] == nil
       
-      @adapter.load(self, klass, options)
+      @adapter.load(self, klass, options).first
     end
     
     def all(klass, options = {})

data/lib/data_mapper/database.rb

@@ -87,7 +87,6 @@ module DataMapper
   class Database
     
     @databases = {}
-    @context = []
     
     # Allows you to access any of the named databases you have already setup.
     #
@@ -101,7 +100,7 @@ module DataMapper
     #
     # This is what gives us thread safety, boys and girls
     def self.context
-      @context
+      Thread::current[:context] || Thread::current[:context] = []
     end
     
     # Setup creates a database and sets all of your properties for that database.
@@ -157,11 +156,10 @@ module DataMapper
     # Creates a new database object with the name you specify, and a default set of options.
     #
     # The default options are as follows:
-    #   {:single_threaded => true, :host => 'localhost', :database => nil, :username => 'root', :password => '', :adapter = nil }
+    #   { :host => 'localhost', :database => nil, :username => 'root', :password => '', :adapter = nil }
     def initialize(name)
       @name = name
       
-      @single_threaded = true
       @adapter = nil
       @host = 'localhost'
       @database = nil
@@ -175,16 +173,8 @@ module DataMapper
     end
     
     attr_reader :name, :adapter
-    attr_writer :single_threaded
     attr_accessor :host, :database, :schema_search_path, :username, :password, :log_stream, :log_level, :index_path, :socket
     
-    # Returns true or false
-    #
-    # NOTE: single_threaded is true unless explicitly set to false.
-    def single_threaded?
-      @single_threaded
-    end
-    
     # Allows us to set the adapter for this database object. It can only be set once, and expects two types of values.
     #
     # You may pass in either a class inheriting from DataMapper::Adapters::AbstractAdapter

data/lib/data_mapper/support/active_record_impersonation.rb

@@ -12,7 +12,7 @@ module DataMapper
       end
       
       def reload!
-        session.first(self.class, key, :select => session.mappings[self.class].columns.map(&:name), :reload => true)
+        session.first(self.class, key, :select => original_hashes.keys, :reload => true)
       end
       
       def reload

data/lib/data_mapper/support/blank.rb

@@ -30,6 +30,6 @@ end
 
 class String
   def blank?
-    empty? || self =~ /^\s*$/
+    empty? || self =~ /\A\s*\Z/
   end
-end
+end

data/lib/data_mapper/support/serialization.rb

@@ -1,13 +1,69 @@
+require 'rexml/document'
+
+begin
+  require 'json/ext'
+rescue LoadError
+  require 'json/pure'
+end
+
 module DataMapper
   module Support
     module Serialization
       
-      def to_yaml
-        document = {}
-        attributes.each_pair { |k,v| document[k.to_s] = v }
-        document.to_yaml
+      def to_yaml(opts = {})
+        
+        YAML::quick_emit( object_id, opts ) do |out|
+          out.map(nil, to_yaml_style ) do |map|
+            session.table(self).columns.each do |column|
+              lazy_load!(column.name) if column.lazy?
+              value = instance_variable_get(column.instance_variable_name)
+              map.add(column.to_s, value.is_a?(Class) ? value.to_s : value)
+            end
+            (self.instance_variable_get("@yaml_added") || []).each do |k,v|
+              map.add(k.to_s, v)
+            end
+          end
+        end
+        
       end
       
+      def to_xml
+        doc = REXML::Document.new
+        
+        table = session.table(self.class)
+        root = doc.add_element(Inflector.underscore(self.class.name))
+        
+        key_attribute = root.attributes << REXML::Attribute.new(table.key.to_s, key)
+        
+        # Single-quoted attributes are ugly. :p
+        # NOTE: I don't want to break existing REXML specs for everyone, so I'm
+        # overwriting REXML::Attribute#to_string just for this instance.
+        def key_attribute.to_string
+          %Q[#@expanded_name="#{to_s().gsub(/"/, '&quot;')}"] 
+        end
+        
+        table.columns.each do |column|
+          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?
+        end
+        
+        doc.to_s
+      end
+      
+      def to_json(*a)
+        table = session.table(self.class)
+        
+        result = '{ '
+        
+        result << table.columns.map do |column|
+          "#{column.name.to_json}: #{send(column.name).to_json(*a)}"
+        end.join(', ')
+        
+        result << ' }'
+        result
+      end
     end
   end # module Support
 end # module DataMapper

data/lib/data_mapper/support/string.rb

@@ -26,8 +26,30 @@ module DataMapper
       #     FROM users
       #   QUERY
       #   => "SELECT name FROM users"
-      def compress_lines
-        gsub(/\s+/, ' ').strip
+      def compress_lines(spaced = true)
+        split($/).map { |line| line.strip }.join(spaced ? ' ' : '')
+      end
+      
+      def margin(indicator = nil)
+        target = dup
+        lines = target.split($/)
+        
+        if indicator.nil?
+          min_margin = nil
+          lines.each do |line|
+            if line =~ /(\s+)/ && (min_margin.nil? || $1.size < min_margin)
+              min_margin = $1.size
+            end
+          end
+
+          lines.map do |line|
+            line.sub(/^\s{#{min_margin}}/, '')
+          end.join($/)
+        else
+          lines.map do |line|
+            line.sub(/^.*?#{"\\" + indicator}/, '')
+          end.join($/)
+        end
       end
       
     end # module String

data/lib/data_mapper/validations/validation_errors.rb

@@ -24,9 +24,12 @@ module DataMapper
       end
     end
     
-    # Are any errors present?
-    def empty?
-      @errors.empty?
+    def on(attribute)
+      @errors[attribute]
+    end
+    
+    def method_missing(meth, *args)
+      @errors.send(meth, *args)
     end
    
   end

data/performance.rb

@@ -4,7 +4,8 @@ require 'active_record'
 ActiveRecord::Base.establish_connection :adapter => 'mysql',
   :username => 'root',
   :password => '',
-  :database => 'data_mapper_1'
+  :database => 'data_mapper_1',
+  :socker => "/tmp/mysql.sock"  
 
 ActiveRecord::Base.find_by_sql('SELECT 1')
 
@@ -21,7 +22,8 @@ require 'lib/data_mapper'
 DataMapper::Database.setup({
   :adapter => 'mysql',
   :database => 'data_mapper_1',
-  :username => 'root'
+  :username => 'root',
+  :socket => "/tmp/mysql.sock"
 })
 
 class DMAnimal < DataMapper::Base
@@ -89,16 +91,16 @@ Benchmark::send(ENV['BM'] || :bmbm, 40) do |x|
   end
   
   x.report('ActiveRecord:all') do
-    N.times { ARAnimal.find(:all).each { |a| a.name } }
+    N.times { ARZoo.find(:all).each { |a| a.name } }
   end
   
   x.report('DataMapper:all') do
-    N.times { DMAnimal.all.each { |a| a.name } }
+    N.times { Zoo.all.each { |a| a.name } }
   end
   
   x.report('DataMapper:all:in-session') do
     database do
-      N.times { DMAnimal.all.each { |a| a.name } }
+      N.times { Zoo.all.each { |a| a.name } }
     end
   end
   
@@ -212,6 +214,19 @@ Benchmark::send(ENV['BM'] || :bmbm, 40) do |x|
     end
   end
   
+  x.report('DataMapper:raw-query') do
+    N.times do
+      database.adapter.connection do |db|
+        
+        command = db.create_command("SELECT * FROM zoos")
+      
+        command.execute_reader do |reader|          
+          reader.each { reader.current_row }
+        end
+      end
+    end
+  end
+  
   x.report('ActiveRecord:accessors') do
     person = ARPerson.find(:first)