dm-core 0.9.2 → 0.9.3

data/lib/dm-core/scope.rb

@@ -1,16 +1,28 @@
 module DataMapper
   module Scope
+    Model.append_extensions self
+
+    # @api private
+    def default_scope(repository_name = nil)
+      repository_name = self.default_repository_name if repository_name == :default || repository_name.nil?
+      @default_scope ||= Hash.new{|h,k| h[k] = {}}
+      @default_scope[repository_name]
+    end
+
+    # @api private
     def query
       scope_stack.last
     end
 
     protected
 
+    # @api semipublic
     def with_scope(query, &block)
       # merge the current scope with the passed in query
       with_exclusive_scope(self.query ? self.query.merge(query) : query, &block)
     end
 
+    # @api semipublic
     def with_exclusive_scope(query, &block)
       query = DataMapper::Query.new(repository, self, query) if query.kind_of?(Hash)
 
@@ -25,11 +37,22 @@ module DataMapper
 
     private
 
+    # @api private
+    def merge_with_default_scope(query)
+      DataMapper::Query.new(query.repository, query.model, default_scope_for_query(query)).update(query)
+    end
+
+    # @api private
     def scope_stack
-      scope_stack_for = Thread.current[:dm_scope_stack] ||= Hash.new { |h,k| h[k] = [] }
+      scope_stack_for = Thread.current[:dm_scope_stack] ||= Hash.new { |h,model| h[model] = [] }
       scope_stack_for[self]
     end
 
-    Model.send(:include, self)
+    # @api private
+    def default_scope_for_query(query)
+      repository_name = query.repository.name
+      default_repository_name = query.model.default_repository_name
+      self.default_scope(default_repository_name).merge(self.default_scope(repository_name))
+    end
   end # module Scope
 end # module DataMapper

data/lib/dm-core/type.rb

@@ -35,7 +35,7 @@ module DataMapper
   #   end
   class Type
     PROPERTY_OPTIONS = [
-      :public, :protected, :private, :accessor, :reader, :writer,
+      :accessor, :reader, :writer,
       :lazy, :default, :nullable, :key, :serial, :field, :size, :length,
       :format, :index, :unique_index, :check, :ordinal, :auto_validation,
       :validates, :unique, :track, :precision, :scale
@@ -86,7 +86,7 @@ module DataMapper
         @primitive = primitive
       end
 
-      #load DataMapper::Property options
+      # Load DataMapper::Property options
       PROPERTY_OPTIONS.each do |property_option|
         self.class_eval <<-EOS, __FILE__, __LINE__
           def #{property_option}(arg = nil)
@@ -97,7 +97,7 @@ module DataMapper
         EOS
       end
 
-      #create property aliases
+      # Create property aliases
       PROPERTY_OPTION_ALIASES.each do |property_option, aliases|
         aliases.each do |ali|
           self.class_eval <<-EOS, __FILE__, __LINE__

data/lib/dm-core/types/discriminator.rb

@@ -10,20 +10,22 @@ module DataMapper
         model = property.model
 
         model.class_eval <<-EOS, __FILE__, __LINE__
-          def self.child_classes
-            @child_classes ||= []
+          def self.descendants
+            (@descendants ||= []).uniq!
+            @descendants
           end
 
           after_class_method :inherited, :add_scope_for_discriminator
 
-          def self.add_scope_for_discriminator(target)
-            target.send(:scope_stack) << DataMapper::Query.new(target.repository, target, :#{property.name} => target.child_classes << target)
-            propagate_child_classes(target)
+          def self.add_scope_for_discriminator(retval, target)
+            target.descendants << target
+            target.default_scope.update(#{property.name.inspect} => target.descendants)
+            propagate_descendants(target)
           end
 
-          def self.propagate_child_classes(target)
-            child_classes << target
-            superclass.send(:propagate_child_classes,target) if superclass.respond_to?(:propagate_child_classes)
+          def self.propagate_descendants(target)
+            descendants << target
+            superclass.propagate_descendants(target) if superclass.respond_to?(:propagate_descendants)
           end
         EOS
       end

data/lib/dm-core/types/object.rb

@@ -8,6 +8,10 @@ module DataMapper
       lazy true
       track :hash
 
+      def self.typecast(value, property)
+        value
+      end
+
       def self.dump(value, property)
         Base64.encode64(Marshal.dump(value))
       end

data/lib/dm-core/types/paranoid_boolean.rb

@@ -3,20 +3,31 @@ module DataMapper
     class ParanoidBoolean < DataMapper::Type(Boolean)
       primitive TrueClass
       default   false
+      lazy      true
 
       def self.bind(property)
         model = property.model
         repository = property.repository
 
-        model.class_eval <<-EOS
+        model.send(:set_paranoid_property, property.name){true}
+
+        model.class_eval <<-EOS, __FILE__, __LINE__
+
+          def self.with_deleted
+            with_exclusive_scope(#{property.name.inspect} => true) do
+              yield
+            end
+          end
+
           def destroy
-            attribute_set(#{property.name.inspect}, true)
+            self.class.paranoid_properties.each do |name, blk|
+              attribute_set(name, blk.call(self))
+            end
             save
           end
         EOS
 
-        model.send(:scope_stack) << DataMapper::Query.new(repository, model, property.name => nil)
-
+        model.default_scope(repository.name).update(property.name => false)
       end
     end # class ParanoidBoolean
   end # module Types

data/lib/dm-core/types/paranoid_datetime.rb

@@ -2,20 +2,31 @@ module DataMapper
   module Types
     class ParanoidDateTime < DataMapper::Type(DateTime)
       primitive DateTime
+      lazy      true
 
       def self.bind(property)
         model = property.model
         repository = property.repository
 
-        model.class_eval <<-EOS
+        model.send(:set_paranoid_property, property.name){DateTime.now}
+
+        model.class_eval <<-EOS, __FILE__, __LINE__
+
+          def self.with_deleted
+            with_exclusive_scope(#{property.name.inspect}.not => nil) do
+              yield
+            end
+          end
+
           def destroy
-            attribute_set(#{property.name.inspect}, DateTime.now)
+            self.class.paranoid_properties.each do |name, blk|
+              attribute_set(name, blk.call(self))
+            end
             save
           end
         EOS
 
-        model.send(:scope_stack) << DataMapper::Query.new(repository, model, property.name => nil)
-
+        model.default_scope(repository.name).update(property.name => nil)
       end
     end # class ParanoidDateTime
   end # module Types

data/lib/dm-core/version.rb

@@ -0,0 +1,3 @@
+module DataMapper
+  VERSION = '0.9.3' unless defined?(DataMapper::VERSION)
+end

data/script/all

@@ -0,0 +1,5 @@
+#!/usr/bin/env sh
+rake spec:unit
+ADAPTER=sqlite3  rake spec:integration
+ADAPTER=mysql    rake spec:integration
+ADAPTER=postgres rake spec:integration

data/script/performance.rb

@@ -0,0 +1,191 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '..', 'lib', 'dm-core')
+
+require 'rubygems'
+require 'ftools'
+
+# sudo gem install rbench
+# OR git clone git://github.com/somebee/rbench.git , rake install
+gem 'rbench', '>=0.2.2'
+require 'rbench'
+
+gem 'faker', '>=0.3.1'
+require 'faker'
+
+gem 'activerecord', '>=2.1.0'
+require 'active_record'
+
+socket_file = Pathname.glob(%w[
+  /opt/local/var/run/mysql5/mysqld.sock
+  tmp/mysqld.sock
+  /tmp/mysqld.sock
+  tmp/mysql.sock
+  /tmp/mysql.sock
+  /var/mysql/mysql.sock
+]).find { |path| path.socket? }
+
+configuration_options = {
+  :adapter => 'mysql',
+  :username => 'root',
+  :password => '',
+  :database => 'data_mapper_1',
+}
+
+configuration_options[:socket] = socket_file unless socket_file.nil?
+
+log_dir = DataMapper.root / 'log'
+log_dir.mkdir unless log_dir.directory?
+
+DataMapper::Logger.new(log_dir / 'dm.log', :debug)
+adapter = DataMapper.setup(:default, "mysql://root@localhost/data_mapper_1?socket=#{socket_file}")
+
+if configuration_options[:adapter]
+  sqlfile = File.join(File.dirname(__FILE__),'..','tmp','perf.sql')
+  mysql_bin = %w[mysql mysql5].select{|bin| `which #{bin}`.length > 0 }
+  mysqldump_bin = %w[mysqldump mysqldump5].select{|bin| `which #{bin}`.length > 0 }
+end
+
+ActiveRecord::Base.logger = Logger.new(log_dir / 'ar.log')
+ActiveRecord::Base.logger.level = 0
+
+ActiveRecord::Base.establish_connection(configuration_options)
+
+class ARExhibit < ActiveRecord::Base #:nodoc:
+  set_table_name 'exhibits'
+end
+
+ARExhibit.find_by_sql('SELECT 1')
+
+class Exhibit
+  include DataMapper::Resource
+
+  property :id,         Serial
+  property :name,       String
+  property :zoo_id,     Integer
+  property :notes,      Text, :lazy => true
+  property :created_on, Date
+#  property :updated_at, DateTime
+end
+
+touch_attributes = lambda do |exhibits|
+  [*exhibits].each do |exhibit|
+    exhibit.id
+    exhibit.name
+    exhibit.created_on
+#    exhibit.updated_at
+  end
+end
+
+
+c = configuration_options
+
+if sqlfile && File.exists?(sqlfile)
+  puts "Found data-file. Importing from #{sqlfile}"
+  #adapter.execute("LOAD DATA LOCAL INFILE '#{sqlfile}' INTO TABLE exhibits")
+  `#{mysql_bin} -u #{c[:username]} #{"-p#{c[:password]}" unless c[:password].blank?} #{c[:database]} < #{sqlfile}`
+else
+
+  Exhibit.auto_migrate!
+
+  exhibits = []
+  # pre-compute the insert statements and fake data compilation,
+  # so the benchmarks below show the actual runtime for the execute
+  # method, minus the setup steps
+  10_000.times do
+    exhibits << [
+      'INSERT INTO `exhibits` (`name`, `zoo_id`, `notes`, `created_on`) VALUES (?, ?, ?, ?)',
+      Faker::Company.name,
+      rand(10).ceil,
+      Faker::Lorem.paragraphs.join($/),
+      Date.today
+    ]
+  end
+  10_000.times { |i| adapter.execute(*exhibits.at(i)) }
+
+  if sqlfile
+    answer = nil
+    until answer && answer[/^$|y|yes|n|no/]
+      print("Would you like to dump data into tmp/perf.sql (for faster setup)? [Yn]");
+      STDOUT.flush
+      answer = gets
+    end
+
+    if answer[/^$|y|yes/]
+      File.makedirs(File.dirname(sqlfile))
+      #adapter.execute("SELECT * INTO OUTFILE '#{sqlfile}' FROM exhibits;")
+      `#{mysqldump_bin} -u #{c[:username]} #{"-p#{c[:password]}" unless c[:password].blank?} #{c[:database]} exhibits > #{sqlfile}`
+      puts "File saved\n"
+    end
+  end
+
+end
+
+TIMES = ENV['x'] ? ENV['x'].to_i : 10_000
+
+puts "You can specify how many times you want to run the benchmarks with rake:perf x=(number)"
+puts "Some tasks will be run 10 and 1000 times less than (number)"
+puts "Benchmarks will now run #{TIMES} times"
+
+RBench.run(TIMES) do
+
+  column :times
+  column :dm, :title => "DM 0.9.3"
+  column :ar, :title => "AR 2.1"
+  column :diff, :compare => [:dm,:ar]
+
+  report "Model.get specific (not cached)" do
+    dm { touch_attributes[Exhibit.get(1)] }
+    ActiveRecord::Base.uncached { ar { touch_attributes[ARExhibit.find(1)] } }
+  end
+
+  report "Model.get specific (cached)" do
+    Exhibit.repository(:default) { dm { touch_attributes[Exhibit.get(1)]    } }
+    ActiveRecord::Base.cache    { ar { touch_attributes[ARExhibit.find(1)] } }
+  end
+
+  report "Model.first" do
+    dm { touch_attributes[Exhibit.first]   }
+    ar { touch_attributes[ARExhibit.first] }
+  end
+
+  report "Model.all limit(100)", TIMES / 10 do
+    dm { touch_attributes[Exhibit.all(:limit => 100)] }
+    ar { touch_attributes[ARExhibit.find(:all, :limit => 100)] }
+  end
+
+  report "Model.all limit(10,000)", TIMES / 1000 do
+    dm { touch_attributes[Exhibit.all(:limit => 10_000)] }
+    ar { touch_attributes[ARExhibit.find(:all, :limit => 10_000)] }
+  end
+
+  create_exhibit = {
+    :name       => Faker::Company.name,
+    :zoo_id     => rand(10).ceil,
+    :notes      => Faker::Lorem.paragraphs.join($/),
+    :created_on => Date.today
+  }
+
+  report "Model.create" do
+    dm { Exhibit.create(create_exhibit)   }
+    ar { ARExhibit.create(create_exhibit) }
+  end
+
+  report "Resource#update" do
+    dm { e = Exhibit.get(1); e.name = 'bob'; e.save   }
+    ar { e = ARExhibit.find(1); e.name = 'bob'; e.save  }
+  end
+
+  report "Resource#destroy" do
+    dm { Exhibit.first.destroy }
+    ar { ARExhibit.first.destroy }
+  end
+
+  summary "Total"
+
+end
+
+connection = adapter.send(:create_connection)
+command = connection.create_command("DROP TABLE exhibits")
+command.execute_non_query rescue nil
+connection.close

data/script/profile.rb

@@ -0,0 +1,86 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '..', 'lib', 'dm-core')
+
+require 'rubygems'
+
+gem 'ruby-prof', '>=0.6.0'
+require 'ruby-prof'
+
+gem 'faker', '>=0.3.1'
+require 'faker'
+
+OUTPUT = DataMapper.root / 'profile_results.txt'
+#OUTPUT = DataMapper.root / 'profile_results.html'
+
+SOCKET_FILE = Pathname.glob(%w[
+  /opt/local/var/run/mysql5/mysqld.sock
+  /tmp/mysqld.sock
+  /tmp/mysql.sock
+  /var/mysql/mysql.sock
+]).find { |path| path.socket? }
+
+DataMapper::Logger.new(DataMapper.root / 'log' / 'dm.log', :debug)
+DataMapper.setup(:default, "mysql://root@localhost/data_mapper_1?socket=#{SOCKET_FILE}")
+
+class Exhibit
+  include DataMapper::Resource
+
+  property :id,         Serial
+  property :name,       String
+  property :zoo_id,     Integer
+  property :notes,      Text, :lazy => true
+  property :created_on, Date
+#  property :updated_at, DateTime
+
+  auto_migrate!
+  create  # create one row for testing
+end
+
+touch_attributes = lambda do |exhibits|
+  [*exhibits].each do |exhibit|
+    exhibit.id
+    exhibit.name
+    exhibit.created_on
+    exhibit.updated_at
+  end
+end
+
+# RubyProf, making profiling Ruby pretty since 1899!
+def profile(&b)
+  result  = RubyProf.profile &b
+  printer = RubyProf::FlatPrinter.new(result)
+  #printer = RubyProf::GraphHtmlPrinter.new(result)
+  printer.print(OUTPUT.open('w+'))
+end
+
+profile do
+#  10_000.times { touch_attributes[Exhibit.get(1)] }
+#
+#  repository(:default) do
+#    10_000.times { touch_attributes[Exhibit.get(1)] }
+#  end
+#
+#  1000.times { touch_attributes[Exhibit.all(:limit => 100)] }
+#
+#  repository(:default) do
+#    1000.times { touch_attributes[Exhibit.all(:limit => 100)] }
+#  end
+#
+#  10.times { touch_attributes[Exhibit.all(:limit => 10_000)] }
+#
+#  repository(:default) do
+#    10.times { touch_attributes[Exhibit.all(:limit => 10_000)] }
+#  end
+
+  create_exhibit = {
+    :name       => Faker::Company.name,
+    :zoo_id     => rand(10).ceil,
+    :notes      => Faker::Lorem.paragraphs.join($/),
+    :created_on => Date.today
+  }
+
+  1000.times { Exhibit.create(create_exhibit) }
+end
+
+puts "Done!"