datamapper-dm-core 0.9.11 → 0.10.0

data/script/profile.rb

@@ -1,17 +1,21 @@
-#!/usr/bin/env ruby
-
-require File.join(File.dirname(__FILE__), '..', 'lib', 'dm-core')
+#!/usr/bin/env ruby -KU
 
+require 'ftools'
 require 'rubygems'
 
-gem 'ruby-prof', '~>0.7.1'
-require 'ruby-prof'
+gem 'addressable', '~>2.0'
+gem 'faker',       '~>0.3.1'
+gem 'ruby-prof',   '~>0.7.3'
 
-gem 'faker', '~>0.3.1'
+require 'addressable/uri'
 require 'faker'
+require 'ruby-prof'
 
-OUTPUT = DataMapper.root / 'profile_results.txt'
-#OUTPUT = DataMapper.root / 'profile_results.html'
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'dm-core'))
+
+TEXT_OUTPUT = DataMapper.root / 'profile_results.txt'
+HTML_OUTPUT = DataMapper.root / 'profile_results.html'
+CALL_OUTPUT = DataMapper.root / 'profile_results.prof'
 
 SOCKET_FILE = Pathname.glob(%w[
   /opt/local/var/run/mysql5/mysqld.sock
@@ -21,8 +25,33 @@ SOCKET_FILE = Pathname.glob(%w[
   /var/run/mysqld/mysqld.sock
 ]).find { |path| path.socket? }
 
+configuration_options = {
+  :adapter  => 'mysql',
+  :database => 'dm_core_test',
+  :host     => 'localhost',
+  :username => 'root',
+  :password => '',
+  :socket   => SOCKET_FILE,
+}
+
 DataMapper::Logger.new(DataMapper.root / 'log' / 'dm.log', :debug)
-DataMapper.setup(:default, "mysql://root@localhost/data_mapper_1?socket=#{SOCKET_FILE}")
+adapter = DataMapper.setup(:default, configuration_options)
+
+if configuration_options[:adapter]
+  sqlfile       = File.join(File.dirname(__FILE__), '..', 'tmp', 'performance.sql')
+  mysql_bin     = %w[ mysql mysql5 ].select { |bin| `which #{bin}`.length > 0 }
+  mysqldump_bin = %w[ mysqldump mysqldump5 ].select { |bin| `which #{bin}`.length > 0 }
+end
+
+class User
+  include DataMapper::Resource
+
+  property :id,         Serial
+  property :name,       String
+  property :email,      String
+  property :about,      Text,   :lazy => false
+  property :created_on, Date
+end
 
 class Exhibit
   include DataMapper::Resource
@@ -30,58 +59,160 @@ class Exhibit
   property :id,         Serial
   property :name,       String
   property :zoo_id,     Integer
-  property :notes,      Text, :lazy => true
+  property :user_id,    Integer
+  property :notes,      Text,    :lazy => false
   property :created_on, Date
-#  property :updated_at, DateTime
 
-  auto_migrate!
-  create  # create one row for testing
+  belongs_to :user
+end
+
+DataMapper.auto_migrate!
+
+def touch_attributes(*exhibits)
+  exhibits.flatten.each do |exhibit|
+    exhibit.id
+    exhibit.name
+    exhibit.created_on
+  end
 end
 
-touch_attributes = lambda do |exhibits|
-  [*exhibits].each do |exhibit|
+def touch_relationships(*exhibits)
+  exhibits.flatten.each do |exhibit|
     exhibit.id
     exhibit.name
     exhibit.created_on
-    exhibit.updated_at
+    exhibit.user
   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+'))
+  results = RubyProf.profile(&b)
+
+  TEXT_OUTPUT.open('w+') do |file|
+    RubyProf::FlatPrinter.new(results).print(file)
+  end
+
+  HTML_OUTPUT.open('w+') do |file|
+    RubyProf::GraphHtmlPrinter.new(results).print(file)
+  end
+
+  CALL_OUTPUT.open('w+') do |file|
+    RubyProf::CallTreePrinter.new(results).print(file)
+  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
+  puts 'Generating data for benchmarking...'
+
+  # 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
+
+  # Using the same paragraph for all exhibits because it is very slow
+  # to generate unique paragraphs for all exhibits.
+  notes = Faker::Lorem.paragraphs.join($/)
+  today = Date.today
+
+  puts 'Inserting 10,000 users and exhibits...'
+  10_000.times do
+    user = User.create(
+      :created_on => today,
+      :name       => Faker::Name.name,
+      :email      => Faker::Internet.email
+    )
+
+    Exhibit.create(
+      :created_on => today,
+      :name       => Faker::Company.name,
+      :user       => user,
+      :notes      => notes,
+      :zoo_id     => rand(10).ceil
+    )
+  end
+
+  if sqlfile
+    answer = nil
+    until answer && answer[/^$|y|yes|n|no/]
+      print('Would you like to dump data into tmp/performance.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 users > #{sqlfile}`
+      puts "File saved\n"
+    end
+  end
 end
 
+TIMES = 10_000
+
+exhibits = Exhibit.all.to_a
+
 profile do
-#  10_000.times { touch_attributes[Exhibit.get(1)] }
-#
-#  repository(:default) do
-#    10_000.times { touch_attributes[Exhibit.get(1)] }
-#  end
+#  dm_obj = Exhibit.get(1)
+#  puts 'Model#id'
+#  (TIMES * 100).times { dm_obj.id }
 #
-#  1000.times { touch_attributes[Exhibit.all(:limit => 100)] }
+#  puts 'Model.new (instantiation)'
+#  TIMES.times { Exhibit.new }
 #
-#  repository(:default) do
-#    1000.times { touch_attributes[Exhibit.all(:limit => 100)] }
-#  end
+#  puts 'Model.new (setting attributes)'
+#  TIMES.times { Exhibit.new(:name => 'sam', :zoo_id => 1) }
 #
-#  10.times { touch_attributes[Exhibit.all(:limit => 10_000)] }
+#  puts 'Model.get specific (not cached)'
+#  TIMES.times { touch_attributes(Exhibit.get(1)) }
 #
+#  puts 'Model.get specific (cached)'
 #  repository(:default) do
-#    10.times { touch_attributes[Exhibit.all(:limit => 10_000)] }
+#    TIMES.times { touch_attributes(Exhibit.get(1)) }
 #  end
 
-  create_exhibit = {
-    :name       => Faker::Company.name,
-    :zoo_id     => rand(10).ceil,
-    :notes      => Faker::Lorem.paragraphs.join($/),
-    :created_on => Date.today
-  }
+  puts 'Model.first'
+  TIMES.times { touch_attributes(Exhibit.first) }
 
-  1000.times { Exhibit.create(create_exhibit) }
+#  puts 'Model.all limit(100)'
+#  (TIMES / 10).ceil.times { touch_attributes(Exhibit.all(:limit => 100)) }
+#
+#  puts 'Model.all limit(100) with relationship'
+#  (TIMES / 10).ceil.times { touch_relationships(Exhibit.all(:limit => 100)) }
+#
+#  puts 'Model.all limit(10,000)'
+#  (TIMES / 1000).ceil { touch_attributes(Exhibit.all(:limit => 10_000)) }
+#
+#  exhibit = {
+#    :name       => Faker::Company.name,
+#    :zoo_id     => rand(10).ceil,
+#    :notes      => Faker::Lorem.paragraphs.join($/),
+#    :created_on => Date.today
+#  }
+#
+#  puts 'Model.create'
+#  TIMES.times { Exhibit.create(exhibit) }
+#
+#  attrs_first  = { :name => 'sam', :zoo_id => 1 }
+#  attrs_second = { :name => 'tom', :zoo_id => 1 }
+#
+#  puts 'Resource#attributes='
+#  TIMES.times { exhibit = Exhibit.new(attrs_first); exhibit.attributes = attrs_second }
+#
+#  puts 'Resource#update'
+#  TIMES.times { |index| exhibit = exhibits[index]; exhibit.name = 'bob'; exhibit.save }
+#
+#  puts 'Resource#destroy'
+#  TIMES.times { |index| exhibits[index].destroy }
+#
+#  puts 'Model.transaction'
+#  TIMES.times { Exhibit.transaction { Exhibit.new } }
 end
 
 puts "Done!"

data/spec/lib/adapter_helpers.rb

@@ -0,0 +1,105 @@
+require "benchmark"
+
+module DataMapper::Spec
+  module AdapterHelpers
+    def self.current_adapters
+      @current_adapters ||= []
+    end
+
+    def supported_by(*adapters, &block)
+      adapters = get_adapters(*adapters)
+
+      PRIMARY.only(*adapters).each do |adapter, connection_uri|
+        # keep track of the current adapters
+        AdapterHelpers.current_adapters << adapters
+
+        describe("with #{adapter}") do
+
+          before :all do
+            # store these in instance vars for the shared adapter specs
+            @adapter    = DataMapper.setup(:default, connection_uri)
+            @repository = DataMapper.repository(@adapter.name)
+
+            # create all tables and constraints before each spec
+            if @repository.respond_to?(:auto_migrate!)
+              @repository.auto_migrate!
+            end
+          end
+
+          after :all do
+            # remove all tables and constraints after each spec
+            if DataMapper.respond_to?(:auto_migrate_down!, true)
+              DataMapper.send(:auto_migrate_down!, @repository.name)
+            end
+          end
+
+          # TODO: add destroy_model_storage and migrations code
+          # that removes the YAML file and remove this code
+          after :all do
+            if defined?(DataMapper::Adapters::YamlAdapter) && @adapter.kind_of?(DataMapper::Adapters::YamlAdapter)
+              descendants = DataMapper::Model.descendants.to_a
+              while model = descendants.shift
+                descendants.concat(model.descendants.to_a - [ model ])
+
+                model.default_scope.clear
+                model.all(:repository => @repository).destroy!
+              end
+            end
+          end
+
+          self.instance_eval(&block)
+        end
+
+        AdapterHelpers.current_adapters.pop
+      end
+    end
+
+    def with_alternate_adapter(&block)
+      adapters = AdapterHelpers.current_adapters.last
+
+      ALTERNATE.only(*adapters).each do |adapter, connection_uri|
+        describe("and #{adapter}") do
+
+          before :all do
+            @alternate_adapter    = DataMapper.setup(:alternate, connection_uri)
+            @alternate_repository = DataMapper.repository(@alternate_adapter.name)
+
+            # create all tables and constraints before each spec
+            if @alternate_repository.respond_to?(:auto_migrate!)
+              @alternate_repository.auto_migrate!
+            end
+          end
+
+          after :all do
+            # remove all tables and constraints after each spec
+            if DataMapper.respond_to?(:auto_migrate_down!, true)
+              DataMapper.send(:auto_migrate_down!, @alternate_repository.name)
+            end
+          end
+
+          # TODO: add destroy_model_storage and migrations code
+          # that removes the YAML file and remove this code
+          after :all do
+            if defined?(DataMapper::Adapters::YamlAdapter) && @alternate_adapter.kind_of?(DataMapper::Adapters::YamlAdapter)
+              descendants = DataMapper::Model.descendants.to_a
+              while model = descendants.shift
+                descendants.concat(model.descendants.to_a - [ model ])
+
+                model.default_scope.clear
+                model.all(:repository => @alternate_repository).destroy!
+              end
+            end
+          end
+
+          self.instance_eval(&block)
+        end
+      end
+    end
+
+    def get_adapters(*adapters)
+      adapters.map! { |adapter_name| adapter_name.to_s }
+      adapters = ADAPTERS if adapters.include?('all')
+      ADAPTERS & adapters
+    end
+  end
+end

data/spec/lib/collection_helpers.rb

@@ -0,0 +1,18 @@
+module DataMapper::Spec
+  module CollectionHelpers
+    module GroupMethods
+      def self.extended(base)
+        base.class_inheritable_accessor :loaded
+        base.loaded = false
+      end
+
+      def should_not_be_a_kicker
+        unless loaded
+          it 'should not be a kicker' do
+            @articles.should_not be_loaded
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/counter_adapter.rb

@@ -0,0 +1,34 @@
+class CounterAdapter < DataMapper::Adapters::AbstractAdapter
+  instance_methods.each { |method| undef_method method unless %w[ __id__ __send__ send class dup object_id kind_of? instance_of? respond_to? equal? assert_kind_of should should_not instance_variable_set instance_variable_get extend ].include?(method.to_s) }
+
+  attr_reader :counts
+
+  def kind_of?(klass)
+    super || @adapter.kind_of?(klass)
+  end
+
+  def instance_of?(klass)
+    super || @adapter.instance_of?(klass)
+  end
+
+  def respond_to?(method, include_private = false)
+    super || @adapter.respond_to?(method, include_private)
+  end
+
+  private
+
+  def initialize(adapter)
+    @counts  = Hash.new { |hash, key| hash[key] = 0 }
+    @adapter = adapter
+    @count   = 0
+  end
+
+  def increment_count_for(method)
+    @counts[method] += 1
+  end
+
+  def method_missing(method, *args, &block)
+    increment_count_for(method)
+    @adapter.send(method, *args, &block)
+  end
+end

data/spec/lib/pending_helpers.rb

@@ -0,0 +1,27 @@
+module DataMapper::Spec
+  module PendingHelpers
+    def pending_if(message, boolean = true)
+      if boolean
+        pending(message) { yield }
+      else
+        yield
+      end
+    end
+
+    def rescue_if(message, boolean = true)
+      if boolean
+        raised = nil
+        begin
+          yield
+          raised = false
+        rescue Exception
+          raised = true
+        end
+
+        raise 'should have raised' if raised == false
+      else
+        yield
+      end
+    end
+  end
+end

data/spec/lib/rspec_immediate_feedback_formatter.rb

@@ -0,0 +1,53 @@
+require 'spec/runner/formatter/base_text_formatter'
+
+# Code is based on standard SpecdocFormatter, but will print full error details as soon as they are found.
+# Successful or pending examples are written only as a dot in the output. Header is only printed if errors occur.
+#
+# To use it, add the following to your spec/spec.opts:
+#  --require
+#  lib/rspec_immediate_feedback_formatter.rb
+#  --format
+#  Spec::Runner::Formatter::ImmediateFeedbackFormatter
+
+module Spec
+  module Runner
+    module Formatter
+      class ImmediateFeedbackFormatter < BaseTextFormatter
+
+        def add_example_group(example_group)
+          super
+          @current_group = example_group.description
+        end
+
+        def example_failed(example, counter, failure)
+          if @current_group
+            output.puts
+            output.puts @current_group
+            @current_group = nil  # only print the group name once
+          end
+
+          message = if failure.expectation_not_met?
+            "- #{example.description} (FAILED - #{counter})"
+          else
+            "- #{example.description} (ERROR - #{counter})"
+          end
+
+          output.puts(red(message))
+          dump_failure(counter, failure)  # dump stacktrace immediately
+          output.flush
+        end
+
+        def example_passed(*)
+          output.print green('.')
+          output.flush
+        end
+
+        def example_pending(*)
+          super
+          output.print yellow('*')
+          output.flush
+        end
+      end
+    end
+  end
+end

data/spec/public/associations/many_to_many_spec.rb

@@ -0,0 +1,193 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+share_examples_for 'A Limited Many to Many Collection' do
+  describe '#destroy!' do
+    describe 'on a limited collection' do
+      before :all do
+        @other   = @articles.create
+        @limited = @articles.all(:limit => 1)
+
+        @return = @limited.destroy!
+      end
+
+      it 'should only remove the join resource for the destroyed resource' do
+        @join_model.all.should_not be_empty
+      end
+    end
+  end
+end
+
+# run the specs once with a loaded association and once not
+[ false, true ].each do |loaded|
+  describe 'Many to Many Associations with :through => Resource' do
+    extend DataMapper::Spec::CollectionHelpers::GroupMethods
+
+    self.loaded = loaded
+
+    # define the model prior to supported_by
+    before :all do
+      module ::Blog
+        class Author
+          include DataMapper::Resource
+
+          property :id,   Serial
+          property :name, String
+
+          has n, :articles, :through => Resource
+        end
+
+        class Article
+          include DataMapper::Resource
+
+          property :id,       Serial
+          property :title,    String, :nullable => false
+          property :content,  Text
+          property :subtitle, String
+
+          has n, :authors, :through => Resource
+          belongs_to :original, self, :nullable => true
+          has n, :revisions, self, :child_key => [ :original_id ]
+          has 1, :previous,  self, :child_key => [ :original_id ], :order => [ :id.desc ]
+          has n, :publications, :through => Resource
+        end
+
+        class Publication
+          include DataMapper::Resource
+
+          property :id,   Serial
+          property :name, String
+
+          has n, :articles, :through => Resource
+        end
+      end
+
+      @author_model      = Blog::Author
+      @article_model     = Blog::Article
+      @publication_model = Blog::Publication
+
+      # initialize the join model
+      Blog::Author.relationships(:default)[:articles].through
+
+      @join_model = Blog::ArticleAuthor
+    end
+
+    supported_by :all do
+      before :all do
+        @author = @author_model.create(:name => 'Dan Kubb')
+
+        @original = @author.articles.create(:title => 'Original Article')
+        @article  = @author.articles.create(:title => 'Sample Article', :content => 'Sample', :original => @original)
+        @other    = @author.articles.create(:title => 'Other Article',  :content => 'Other')
+
+        # load the targets without references to a single source
+        load_collection = lambda do |query|
+          @author_model.get(*@author.key).articles(query)
+        end
+
+        @articles       = load_collection.call(:title => 'Sample Article')
+        @other_articles = load_collection.call(:title => 'Other Article')
+
+        @articles.entries if loaded
+      end
+
+      it_should_behave_like 'A public Collection'
+      it_should_behave_like 'A public Association Collection'
+      it_should_behave_like 'A Collection supporting Strategic Eager Loading' unless loaded
+      it_should_behave_like 'Finder Interface'
+      it_should_behave_like 'A Limited Many to Many Collection'
+    end
+  end
+
+  describe 'Many to Many Associations :through => one_to_many' do
+    extend DataMapper::Spec::CollectionHelpers::GroupMethods
+
+    self.loaded = loaded
+
+    # define the model prior to supported_by
+    before :all do
+      module ::Blog
+        class Author
+          include DataMapper::Resource
+
+          property :id,   Serial
+          property :name, String
+
+          has n, :sites
+          has n, :articles, :through => :sites
+        end
+
+        class Site
+          include DataMapper::Resource
+
+          property :name, String, :key => true, :default => 'default'
+
+          belongs_to :author
+          has n, :articles
+        end
+
+        class Article
+          include DataMapper::Resource
+
+          property :id,      Serial
+          property :title,   String, :nullable => false
+          property :content, Text
+          property :subtitle, String
+
+          property :site_name, String, :default => 'default'
+
+          belongs_to :site
+          has n, :authors, :through => :site
+          belongs_to :original, self, :nullable => true
+          has n, :revisions, self, :child_key => [ :original_id ]
+          has 1, :previous,  self, :child_key => [ :original_id ], :order => [ :id.desc ]
+          has n, :publications, :through => Resource
+        end
+
+        class Publication
+          include DataMapper::Resource
+
+          property :id,   Serial
+          property :name, String
+
+          has n, :articles, :through => Resource
+        end
+      end
+
+      @author_model      = Blog::Author
+      @article_model     = Blog::Article
+      @publication_model = Blog::Publication
+
+      @join_model = Blog::Site
+    end
+
+    supported_by :all do
+      before :all do
+        @author = @author_model.create(:name => 'Dan Kubb')
+
+        @original_site = @author.sites.create(:name => 'original')
+        @article_site  = @author.sites.create(:name => 'article')
+        @other_site    = @author.sites.create(:name => 'other')
+
+        @original = @original_site.articles.create(:title => 'Original Article')
+        @article  = @article_site.articles.create(:title => 'Sample Article', :content => 'Sample', :original => @original)
+        @other    = @other_site.articles.create(:title => 'Other Article',  :content => 'Other')
+
+        # load the targets without references to a single source
+        load_collection = lambda do |query|
+          @author_model.get(*@author.key).articles(query)
+        end
+
+        @articles       = load_collection.call(:title => 'Sample Article')
+        @other_articles = load_collection.call(:title => 'Other Article')
+
+        @articles.entries if loaded
+      end
+
+      it_should_behave_like 'A public Collection'
+      it_should_behave_like 'A public Association Collection'
+      it_should_behave_like 'A Collection supporting Strategic Eager Loading' unless loaded
+      it_should_behave_like 'Finder Interface'
+      it_should_behave_like 'A Limited Many to Many Collection'
+    end
+  end
+end