datamapper 0.1.0 → 0.1.1

data/lib/data_mapper/{extensions → support}/active_record_impersonation.rb

@@ -1,5 +1,5 @@
 module DataMapper
-  module Extensions
+  module Support
     
     module ActiveRecordImpersonation
       
@@ -12,7 +12,7 @@ module DataMapper
       end
       
       def reload!
-        session.find(self.class, id, :select => session.mappings[self.class].columns.map(&:name), :reload => true)
+        session.first(self.class, key, :select => session.mappings[self.class].columns.map(&:name), :reload => true)
       end
       
       def reload
@@ -25,12 +25,16 @@ module DataMapper
       
       module ClassMethods
         
+        def find_or_create(search_attributes, create_attributes = nil)
+          first(search_attributes) || create(search_attributes.merge(create_attributes))
+        end
+        
         def all(options = {}, &b)
-          find(:all, options, &b)
+          database.all(self, options, &b)
         end
         
-        def first(options = {}, &b)
-          find(:first, options, &b)
+        def first(*args, &b)
+          database.first(self, *args, &b)
         end
         
         def delete_all
@@ -41,8 +45,12 @@ module DataMapper
           database.truncate(self)
         end
         
-        def find(*args, &b)
-          DataMapper::database.find(self, *args, &b)
+        def find(type_or_id, options = {}, &b)
+          case type_or_id
+            when :first then first(options, &b)
+            when :all then all(options, &b)
+            else first(type_or_id, options, &b)
+          end
         end
         
         def find_by_sql(*args)
@@ -50,11 +58,7 @@ module DataMapper
         end
         
         def [](id_or_hash)
-          if id_or_hash.kind_of?(Hash)
-            find(:first, id_or_hash)
-          else
-            find(id_or_hash)
-          end
+          first(id_or_hash)
         end
         
         def create(attributes)

data/lib/data_mapper/support/blank.rb

@@ -0,0 +1,35 @@
+class Object
+  def blank?
+    nil? || (respond_to?(:empty?) && empty?)
+  end
+end
+
+class Fixnum
+  def blank?
+    false
+  end
+end
+
+class NilClass
+  def blank?
+    true
+  end
+end
+
+class TrueClass
+  def blank?
+    false
+  end
+end
+
+class FalseClass
+  def blank?
+    false
+  end
+end
+
+class String
+  def blank?
+    empty? || self =~ /^\s*$/
+  end
+end

data/lib/data_mapper/support/connection_pool.rb

@@ -1,4 +1,5 @@
-require 'thread'
+# See 'fastthread' dependency in data_mapper.rb
+# require 'thread' 
 
 module DataMapper
   module Support

data/lib/data_mapper/support/string.rb

@@ -2,6 +2,11 @@ module DataMapper
   module Support
     module String
       
+      # I set the constant on the String itself to avoid inheritance chain lookups.
+      def self.included(base)
+        base.const_set('EMPTY', ''.freeze)
+      end
+      
       def ensure_starts_with(part)
         [0,1] == part ? self : (part + self)
       end
@@ -14,10 +19,32 @@ module DataMapper
         ensure_starts_with(a).ensure_ends_with(b || a)
       end
       
+      # Matches any whitespace (including newline) and replaces with a single space
+      # EXAMPLE:
+      #   <<QUERY.compress_lines
+      #     SELECT name
+      #     FROM users
+      #   QUERY
+      #   => "SELECT name FROM users"
+      def compress_lines
+        gsub(/\s+/, ' ').strip
+      end
+      
     end # module String
   end # module Support
 end # module DataMapper
 
 class String #:nodoc:
   include DataMapper::Support::String
+  
+  def self.fragile_underscore(camel_cased_word)
+    camel_cased_word.gsub(/([a-z\d])([A-Z])/,'\1_\2').downcase
+  end
+  
+  @underscore_cache = Hash.new { |h,k| h[k.freeze] = fragile_underscore(k) }
+  
+  def self.memoized_underscore(camel_cased_word)
+    @underscore_cache[camel_cased_word]
+  end
+  
 end

data/lib/data_mapper/support/struct.rb

@@ -0,0 +1,26 @@
+module DataMapper
+  module Support
+    class Struct
+      
+      def self.define(raw_fields)
+        
+        normalized_fields = raw_fields.map { |field| Inflector.underscore(field).to_sym }
+        
+        Class.new(self) do
+          define_method(:fields) do
+            normalized_fields
+          end
+        end
+      end
+      
+      def initialize(values)
+        @values = values
+      end
+
+      def method_missing(sym, *args)
+        @values[fields.index(sym)]
+      end
+      
+    end # class Struct
+  end # module Support
+end # module DataMapper

data/lib/data_mapper/validations/unique_validator.rb

@@ -37,9 +37,7 @@ module DataMapper
         
         finder_options.merge!({ target.session.mappings[target.class].key.name.not => target.key }) unless target.new_record?
         
-        # HACK: gotta make sure we're using the same database that this instance was
-        # found with unless new_record?
-        target.session.find(target.class, :first, finder_options).nil?
+        target.session.first(target.class, finder_options).nil?
       end
       
     end

data/lib/data_mapper/validations/validation_helper.rb

@@ -11,7 +11,7 @@ end.each do |validator|
 end
 
 module DataMapper
-  module Extensions
+  module Validations
     
     module ValidationHelper
       

data/performance.rb

@@ -14,8 +14,7 @@ class ARPerson < ActiveRecord::Base
   set_table_name 'people'
 end
 
-$LOAD_PATH.unshift('lib')
-require 'data_mapper'
+require 'lib/data_mapper'
 
 log_path = File.dirname(__FILE__) + '/development.log'
 
@@ -24,10 +23,8 @@ FileUtils::rm log_path if File.exists?(log_path)
 
 DataMapper::Database.setup do
   adapter   'mysql'
-  username 'root'
   database 'data_mapper_1'
-  log_stream 'development.log'
-  log_level Logger::DEBUG
+  username 'root'
 end
 
 class DMAnimal < DataMapper::Base
@@ -76,6 +73,14 @@ Benchmark::send(ENV['BM'] || :bmbm, 40) do |x|
     N.times { DMAnimal[1] }
   end
   
+  x.report('ActiveRecord:all') do
+    N.times { ARAnimal.find(:all) }
+  end
+  
+  x.report('DataMapper:all') do
+    N.times { DMAnimal.all }
+  end
+  
   x.report('ActiveRecord:conditions') do
     N.times { ARZoo.find(:first, :conditions => ['name = ?', 'Galveston']) }
   end
@@ -118,7 +123,7 @@ Benchmark::send(ENV['BM'] || :bmbm, 40) do |x|
   
   x.report('ActiveRecord:update') do
     N.times do
-      bob = ARAnimal.find(:first, :conditions => ["name = ?", 'elephant'])
+      bob = ARAnimal.find(:first, :conditions => ["name = ?", 'Elephant'])
       bob.notes = 'Updated by ActiveRecord'
       bob.save
     end
@@ -126,7 +131,7 @@ Benchmark::send(ENV['BM'] || :bmbm, 40) do |x|
   
   x.report('DataMapper:update') do
     N.times do
-      bob = DMAnimal.first(:name => 'elephant')
+      bob = DMAnimal.first(:name => 'Elephant')
       bob.notes = 'Updated by DataMapper'
       bob.save
     end
@@ -153,4 +158,16 @@ Benchmark::send(ENV['BM'] || :bmbm, 40) do |x|
       end
     end
   end
+  
+  x.report('ActiveRecord:find_by_sql') do
+    N.times do
+      ARZoo.find_by_sql("SELECT * FROM zoos")
+    end
+  end
+  
+  x.report('DataMapper:find_by_sql') do
+    N.times do
+      database.query("SELECT * FROM zoos")
+    end
+  end
 end

data/profile_data_mapper.rb

@@ -1,3 +1,7 @@
+#!/opt/local/bin/ruby
+
+ENV['LOGGER'] = 'false'
+
 require 'example'
 require 'ruby-prof'
 
@@ -13,6 +17,24 @@ end
 
 profile do
   1000.times do
-    Zoo[:name => 'Galveston']
+    Zoo.all
   end
-end
+end
+
+# require 'benchmark'
+# 
+# N = 100_000
+# 
+# Benchmark::bmbm do |x|
+#   x.report do
+#     N.times do
+#       Inflector.underscore('DataMapper')
+#     end    
+#   end
+# 
+#   x.report do
+#     N.times do
+#       String::memoized_underscore('DataMapper')
+#     end
+#   end
+# end

data/rakefile.rb

@@ -11,7 +11,7 @@ task :default => 'test'
 desc "Run specifications"
 Spec::Rake::SpecTask.new('test') do |t|
   t.spec_opts = [ '-rspec/spec_helper' ]
-  t.spec_files = FileList[ENV['FILES'] || 'spec/*.rb']
+  t.spec_files = FileList['spec/*.rb', (ENV['FILES'] || 'spec/**/*_spec.rb')]
 end
 
 desc "Run comparison with ActiveRecord"
@@ -24,7 +24,7 @@ task :profile do
   load 'profile_data_mapper.rb'
 end
 
-PACKAGE_VERSION = '0.1.0'
+PACKAGE_VERSION = '0.1.1'
 
 PACKAGE_FILES = FileList[
   'README',

data/spec/basic_finder.rb

@@ -3,14 +3,14 @@ context 'Finder' do
   specify 'database-specific load should not fail' do
     
     DataMapper::database do |db|
-      froggy = db.find(Animal, :first, :conditions => ['name = ?', 'Frog'])
+      froggy = db.first(Animal, :conditions => ['name = ?', 'Frog'])
       froggy.name.should == 'Frog'
     end
 
   end
   
   specify 'current-database load should not fail' do
-    froggy = DataMapper::database.find(Animal, :first).name.should == 'Frog'
+    froggy = DataMapper::database.first(Animal).name.should == 'Frog'
   end
   
   specify 'load through ActiveRecord impersonation should not fail' do

data/spec/belongs_to.rb

@@ -11,7 +11,7 @@ context 'An Exhibit' do
   
   specify 'belongs to a zoo' do
     database do |db|
-      @aviary.zoo.should == @aviary.session.find(Zoo, :first, :name => 'San Diego')
+      @aviary.zoo.should == @aviary.session.first(Zoo, :name => 'San Diego')
     end
   end
   

data/spec/delete_command_spec.rb

@@ -0,0 +1,9 @@
+describe DataMapper::Adapters::Sql::Commands::DeleteCommand do
+  
+  it "should drop and create the table" do
+    database.schema[Zoo].drop!.should == true
+    database.schema[Zoo].exists?.should == false
+    database.schema[Zoo].create!.should == true
+  end
+  
+end

data/spec/fixtures/zoos.yaml

@@ -1,12 +1,16 @@
 - name: Dallas
+  notes: Keep Dallas Pretentious?
 - name: San Diego
 - name: Miami
 - name: Ft. Lauderdale
 - name: Ft. Worth
 - name: New Orleans
 - name: San Antonio
+  notes: The most sprawling city I've ever seen. It's insane.
 - name: Galveston
+  notes: A friendly place. It's like Hotel California for Houston's homeless though. (No way out without a car.)
 - name: Austin
+  notes: People in Austin like to drive around with "Save Mother Earth" stickers on their SUVs and proclaim "Keep Austin Weird" while sipping on Starbucks.
 - name: Brownsville
 - name: Los Angeles
 - name: Phillidelphia

data/spec/has_many.rb

@@ -18,7 +18,7 @@ describe DataMapper::Associations::HasManyAssociation do
   it 'should lazily-load the association when Enumerable methods are called' do
     database do |db|
       @san_diego.exhibits.size.should == 2
-      @san_diego.exhibits.should include(@san_diego.session.find(Exhibit, :first, :name => 'Monkey Mayhem'))
+      @san_diego.exhibits.should include(@san_diego.session.first(Exhibit, :name => 'Monkey Mayhem'))
     end
   end
   

data/spec/load_command_spec.rb

@@ -0,0 +1,44 @@
+describe DataMapper::Adapters::Sql::Commands::LoadCommand do
+  
+  before(:all) do
+    fixtures(:zoos)
+  end
+  
+  it "should return a Struct for custom queries" do
+    results = database.query("SELECT * FROM zoos WHERE name = ?", 'Galveston')
+    zoo = results.first
+    zoo.class.superclass.should == DataMapper::Support::Struct
+    zoo.name.should == "Galveston"
+  end
+  
+end
+
+describe DataMapper::Adapters::Sql::Commands::AdvancedLoadCommand do
+  
+  def loader_for(klass, options = {})
+    session = database
+    DataMapper::Adapters::Sql::Commands::AdvancedLoadCommand.new(session.adapter, session, klass, options)
+  end
+  
+  it "should return a simple select statement for a given class" do
+    loader_for(Zoo).to_sql.should == 'SELECT `id`, `name` FROM `zoos`'
+  end
+  
+  it "should include only the columns specified in the statement" do
+    loader_for(Zoo, :select => [:name]).to_sql.should == 'SELECT `name` FROM `zoos`'
+  end
+  
+  it "should optionally include lazy-loaded columns in the statement" do
+    loader_for(Zoo, :include => :notes).to_sql.should == 'SELECT `id`, `name`, `notes` FROM `zoos`'
+  end
+  
+  it "should join associations in the statement" do
+    loader_for(Zoo, :include => :exhibits2).to_sql.should == <<-EOS.compress_lines
+      SELECT `zoos`.`id`, `zoos`.`name`,
+        `exhibits`.`id`, `exhibits`.`name`, `exhibits`.`zoo_id`
+      FROM `zoos`
+      JOIN `exhibits` ON `exhibits`.`cow_id` = `zoos`.`id`
+    EOS
+  end
+  
+end if ENV['ADAPTER'].nil? || ENV['ADAPTER'] == 'mysql'

data/spec/models/zoo.rb

@@ -1,5 +1,7 @@
 class Zoo < DataMapper::Base
   property :name, :string
+  property :notes, :text
   
   has_many :exhibits
+  advanced_has_many :exhibits2, :class_name => 'Exhibit', :foreign_key => 'cow_id'
 end