datamapper-dm-core 0.9.11 → 0.10.0

data/spec/integration/strategic_eager_loading_spec.rb

@@ -1,156 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
-
-describe "Strategic Eager Loading" do
-  include LoggingHelper
-
-  before :all do
-    class ::Zoo
-      include DataMapper::Resource
-      def self.default_repository_name; ADAPTER end
-
-      property :id, Serial
-      property :name, String
-
-      has n, :exhibits
-    end
-
-    class ::Exhibit
-      include DataMapper::Resource
-      def self.default_repository_name; ADAPTER end
-
-      property :id, Serial
-      property :name, String
-      property :zoo_id, Integer
-
-      belongs_to :zoo
-      has n, :animals
-    end
-
-    class ::Animal
-      include DataMapper::Resource
-      def self.default_repository_name; ADAPTER end
-
-      property :id, Serial
-      property :name, String
-      property :exhibit_id, Integer
-
-      belongs_to :exhibit
-    end
-
-    [Zoo, Exhibit, Animal].each { |k| k.auto_migrate!(ADAPTER) }
-
-    repository(ADAPTER) do
-      Zoo.create(:name => "Dallas Zoo")
-      Exhibit.create(:name => "Primates", :zoo_id => 1)
-      Animal.create(:name => "Chimpanzee", :exhibit_id => 1)
-      Animal.create(:name => "Orangutan", :exhibit_id => 1)
-
-      Zoo.create(:name => "San Diego")
-      Exhibit.create(:name => "Aviary", :zoo_id => 2)
-      Exhibit.create(:name => "Insectorium", :zoo_id => 2)
-      Exhibit.create(:name => "Bears", :zoo_id => 2)
-      Animal.create(:name => "Bald Eagle", :exhibit_id => 2)
-      Animal.create(:name => "Parakeet", :exhibit_id => 2)
-      Animal.create(:name => "Roach", :exhibit_id => 3)
-      Animal.create(:name => "Brown Bear", :exhibit_id => 4)
-    end
-  end
-
-  it "should eager load children" do
-    zoo_ids     = Zoo.all.map { |z| z.key }
-    exhibit_ids = Exhibit.all.map { |e| e.key }
-
-    repository(ADAPTER) do
-      zoos = Zoo.all.entries # load all zoos
-      dallas = zoos.find { |z| z.name == 'Dallas Zoo' }
-
-      logger do |log|
-        dallas.exhibits.entries # load all exhibits for zoos in identity_map
-        dallas.exhibits.size.should == 1
-
-        log.readlines.size.should == 1
-
-        repository.identity_map(Zoo).keys.sort.should == zoo_ids
-        repository.identity_map(Exhibit).keys.sort.should == exhibit_ids
-      end
-
-      logger do |log|
-        zoos.each { |zoo| zoo.exhibits.entries } # issues no queries
-        log.readlines.should be_empty
-      end
-
-      dallas.exhibits << Exhibit.new(:name => "Reptiles")
-      dallas.exhibits.size.should == 2
-      dallas.save
-    end
-    repository(ADAPTER) do
-      Zoo.first.exhibits.size.should == 2
-    end
-  end
-
-  it "should not eager load children when a query is provided" do
-    repository(ADAPTER) do
-      dallas = Zoo.all.entries.find { |z| z.name == 'Dallas Zoo' }
-      exhibits = dallas.exhibits.entries # load all exhibits
-
-      reptiles, primates = nil, nil
-
-      logger do |log|
-        reptiles = dallas.exhibits(:name => 'Reptiles')
-        reptiles.size.should == 1
-
-        log.readlines.size.should == 1
-      end
-
-      logger do |log|
-        primates = dallas.exhibits(:name => 'Primates')
-        primates.size.should == 1
-        primates.should_not == reptiles
-
-        log.readlines.size.should == 1
-      end
-    end
-  end
-
-  it "should eager load parents" do
-    animal_ids  = Animal.all.map { |a| a.key }
-    exhibit_ids = Exhibit.all.map { |e| e.key }.sort
-    exhibit_ids.pop # remove Reptile exhibit, which has no Animals
-
-    repository(ADAPTER) do
-      animals = Animal.all.entries
-      bear = animals.find { |a| a.name == 'Brown Bear' }
-
-      logger do |log|
-        bear.exhibit
-
-        repository.identity_map(Animal).keys.sort.should == animal_ids
-        repository.identity_map(Exhibit).keys.sort.should == exhibit_ids
-
-        log.readlines.size.should == 1
-      end
-    end
-  end
-
-  it "should not eager load parents when parent is in IM" do
-    repository(ADAPTER) do
-      animal = Animal.first
-      exhibit = Exhibit.get(1) # load exhibit into IM
-
-      logger do |log|
-        animal.exhibit # load exhibit from IM
-        log.readlines.should be_empty
-      end
-
-      repository.identity_map(Exhibit).keys.should == [exhibit.key]
-    end
-  end
-
-  it "should return a Collection when no children" do
-    Zoo.create(:name => 'Portland')
-
-    Zoo.all.each do |zoo|
-      zoo.exhibits.should be_kind_of(DataMapper::Collection)
-    end
-  end
-end

data/spec/integration/transaction_spec.rb

@@ -1,75 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
-
-# transaction capable adapters
-ADAPTERS = []
-ADAPTERS << :postgres if HAS_POSTGRES
-ADAPTERS << :mysql    if HAS_MYSQL
-ADAPTERS << :sqlite3  if HAS_SQLITE3
-
-if ADAPTERS.any?
-  class Sputnik
-    include DataMapper::Resource
-
-    property :id, Serial
-    property :name, DM::Text
-  end
-
-  describe DataMapper::Transaction do
-    before :all do
-      @repositories = []
-
-      ADAPTERS.each do |name|
-        @repositories << repository(name)
-      end
-    end
-
-    before :each do
-      ADAPTERS.each do |name|
-        Sputnik.auto_migrate!(name)
-      end
-    end
-
-    it "should commit changes to all involved adapters on a two phase commit" do
-      DataMapper::Transaction.new(*@repositories) do
-        ADAPTERS.each do |name|
-          repository(name) { Sputnik.create(:name => 'hepp') }
-        end
-      end
-
-      ADAPTERS.each do |name|
-        repository(name) { Sputnik.all.size.should == 1 }
-      end
-    end
-
-    it "should not commit any changes if the block raises an exception" do
-      lambda do
-        DataMapper::Transaction.new(*@repositories) do
-          ADAPTERS.each do |name|
-            repository(name) { Sputnik.create(:name => 'hepp') }
-          end
-          raise "plur"
-        end
-      end.should raise_error(Exception, /plur/)
-
-      ADAPTERS.each do |name|
-        repository(name) { Sputnik.all.size.should == 0 }
-      end
-    end
-
-    it "should not commit any changes if any of the adapters doesnt prepare properly" do
-      lambda do
-        DataMapper::Transaction.new(*@repositories) do |transaction|
-          ADAPTERS.each do |name|
-            repository(name) { Sputnik.create(:name => 'hepp') }
-          end
-
-          transaction.primitive_for(@repositories.last.adapter).should_receive(:prepare).and_throw(Exception.new("I am the famous test exception"))
-        end
-      end.should raise_error(Exception, /I am the famous test exception/)
-
-      ADAPTERS.each do |name|
-        repository(name) { Sputnik.all.size.should == 0 }
-      end
-    end
-  end
-end

data/spec/integration/type_spec.rb

@@ -1,275 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
-
-# if RUBY_VERSION >= '1.9.0'
-#   require 'csv'
-# else
-#   gem 'fastercsv', '~>1.4.0'
-#   require 'fastercsv'
-# end
-
-if ADAPTER
-  module ::TypeTests
-    class Impostor < DataMapper::Type
-      primitive String
-    end
-
-    class Coconut
-      include DataMapper::Resource
-
-      storage_names[ADAPTER] = 'coconuts'
-
-      def self.default_repository_name
-        ADAPTER
-      end
-
-      property :id, Serial
-      property :faked, Impostor
-      property :active, Boolean
-      property :note, Text
-    end
-  end
-
-  class ::Lemon
-    include DataMapper::Resource
-
-    def self.default_repository_name
-      ADAPTER
-    end
-
-    property :id, Serial
-    property :color, String
-    property :deleted_at, DataMapper::Types::ParanoidDateTime
-  end
-
-  class ::Lime
-    include DataMapper::Resource
-
-    def self.default_repository_name
-      ADAPTER
-    end
-
-    property :id, Serial
-    property :color, String
-    property :deleted_at, DataMapper::Types::ParanoidBoolean
-  end
-
-  describe DataMapper::Type, "with #{ADAPTER}" do
-    before do
-      TypeTests::Coconut.auto_migrate!(ADAPTER)
-
-      @document = <<-EOS.margin
-        NAME, RATING, CONVENIENCE
-        Freebird's, 3, 3
-        Whataburger, 1, 5
-        Jimmy John's, 3, 4
-        Mignon, 5, 2
-        Fuzi Yao's, 5, 1
-        Blue Goose, 5, 1
-      EOS
-
-      @stuff = YAML::dump({ 'Happy Cow!' => true, 'Sad Cow!' => false })
-
-      @active = true
-      @note = "This is a note on our ol' guy bob"
-    end
-
-    it "should instantiate an object with custom types" do
-      coconut = TypeTests::Coconut.new(:faked => 'bob', :active => @active, :note => @note)
-      coconut.faked.should == 'bob'
-      coconut.active.should be_a_kind_of(TrueClass)
-      coconut.note.should be_a_kind_of(String)
-    end
-
-    it "should CRUD an object with custom types" do
-      repository(ADAPTER) do
-        coconut = TypeTests::Coconut.new(:faked => 'bob', :active => @active, :note => @note)
-        coconut.save.should be_true
-        coconut.id.should_not be_nil
-
-        fred = TypeTests::Coconut.get!(coconut.id)
-        fred.faked.should == 'bob'
-        fred.active.should be_a_kind_of(TrueClass)
-        fred.note.should be_a_kind_of(String)
-
-        note = "Seems like bob is just mockin' around"
-        fred.note = note
-
-        fred.save.should be_true
-
-        active = false
-        fred.active = active
-
-        fred.save.should be_true
-
-        # Can't call coconut.reload since coconut.collection isn't setup.
-        mac = TypeTests::Coconut.get!(fred.id)
-        mac.active.should == active
-        mac.note.should == note
-      end
-    end
-
-    it "should respect paranoia with a datetime" do
-      Lemon.auto_migrate!(ADAPTER)
-
-      lemon = nil
-
-      repository(ADAPTER) do |repository|
-        lemon = Lemon.new
-        lemon.color = 'green'
-
-        lemon.save
-        lemon.destroy
-
-        lemon.deleted_at.should be_kind_of(DateTime)
-      end
-
-      repository(ADAPTER) do |repository|
-        Lemon.all.should be_empty
-        Lemon.get(lemon.id).should be_nil
-      end
-    end
-
-    it "should provide access to paranoid items with DateTime" do
-      Lemon.auto_migrate!(ADAPTER)
-
-      lemon = nil
-
-      repository(ADAPTER) do |repository|
-        %w(red green yellow blue).each do |color|
-          Lemon.create(:color => color)
-        end
-
-        Lemon.all.size.should == 4
-        Lemon.first.destroy
-        Lemon.all.size.should == 3
-        Lemon.with_deleted{Lemon.all.size.should == 1}
-      end
-    end
-
-    it "should set paranoid datetime to a date time" do
-      tmp = (DateTime.now - 0.5)
-      dt = DateTime.now
-      DateTime.stub!(:now).and_return(tmp)
-
-      repository(ADAPTER) do |repository|
-        lemon = Lemon.new
-        lemon.color = 'green'
-        lemon.save
-        lemon.destroy
-        lemon.deleted_at.should == tmp
-      end
-    end
-
-    it "should respect paranoia with a boolean" do
-      Lime.auto_migrate!(ADAPTER)
-
-      lime = nil
-
-      repository(ADAPTER) do |repository|
-        lime = Lime.new
-        lime.color = 'green'
-
-        lime.save
-        lime.destroy
-
-        lime.deleted_at.should be_kind_of(TrueClass)
-      end
-
-      repository(ADAPTER) do |repository|
-        Lime.all.should be_empty
-        Lime.get(lime.id).should be_nil
-      end
-    end
-
-    it "should provide access to paranoid items with Boolean" do
-      Lime.auto_migrate!(ADAPTER)
-
-      lemon = nil
-
-      repository(ADAPTER) do |repository|
-        %w(red green yellow blue).each do |color|
-          Lime.create(:color => color)
-        end
-
-        Lime.all.size.should == 4
-        Lime.first.destroy
-        Lime.all.size.should == 3
-        Lime.with_deleted{Lime.all.size.should == 1}
-      end
-    end
-
-    describe "paranoid types across repositories" do
-      before(:all) do
-        DataMapper::Repository.adapters[:alternate_paranoid] = repository(ADAPTER).adapter.dup
-
-        Object.send(:remove_const, :Orange) if defined?(Orange)
-        class ::Orange
-          include DataMapper::Resource
-
-          def self.default_repository_name
-            ADAPTER
-          end
-
-          property :id, Serial
-          property :color, String
-
-          repository(:alternate_paranoid) do
-            property :deleted,    DataMapper::Types::ParanoidBoolean
-            property :deleted_at, DataMapper::Types::ParanoidDateTime
-          end
-        end
-
-        repository(:alternate_paranoid){Orange.auto_migrate!}
-      end
-
-      before(:each) do
-        %w(red orange blue green).each{|color| o = Orange.create(:color => color)}
-      end
-
-      after(:each) do
-        Orange.repository.adapter.execute("DELETE FROM oranges")
-      end
-
-      it "should setup the correct objects for the spec" do
-        repository(:alternate_paranoid){Orange.all.should have(4).items}
-      end
-
-      it "should allow access the the default repository" do
-        Orange.all.should have(4).items
-      end
-
-      it "should mark the objects as deleted in the alternate_paranoid repository" do
-        repository(:alternate_paranoid) do
-          Orange.first.destroy
-          Orange.all.should have(3).items
-          Orange.find_by_sql("SELECT * FROM oranges").should have(4).items
-        end
-      end
-
-      it "should mark the objects as deleted in the alternate_paranoid repository but ignore it in the #{ADAPTER} repository" do
-        repository(:alternate_paranoid) do
-          Orange.first.destroy
-        end
-        Orange.all.should have(4).items
-      end
-
-      it "should raise an error when trying to destroy from a repository that is not paranoid" do
-        lambda do
-          Orange.first.destroy
-        end.should raise_error(ArgumentError)
-      end
-
-      it "should set all paranoid attributes on delete" do
-        repository(:alternate_paranoid) do
-          orange = Orange.first
-          orange.deleted.should be_false
-          orange.deleted_at.should be_nil
-          orange.destroy
-
-          orange.deleted.should be_true
-          orange.deleted_at.should be_a_kind_of(DateTime)
-        end
-      end
-    end
-  end
-end

data/spec/lib/logging_helper.rb

@@ -1,18 +0,0 @@
-module LoggingHelper
-  def logger
-    class << DataMapper.logger
-      attr_writer :log
-    end
-
-    old_log = DataMapper.logger.log
-
-    begin
-      StringIO.new('') do |io|
-        DataMapper.logger.log = io
-        yield io
-      end
-    ensure
-      DataMapper.logger.log = old_log
-    end
-  end
-end

data/spec/lib/mock_adapter.rb

@@ -1,27 +0,0 @@
-module DataMapper
-  module Adapters
-    class MockAdapter < DataMapper::Adapters::DataObjectsAdapter
-
-      def create(resources)
-        1
-      end
-
-      def exists?(storage_name)
-        true
-      end
-
-    end
-  end
-end
-
-module DataObjects
-  module Mock
-
-    def self.logger
-    end
-
-    def self.logger=(value)
-    end
-
-  end
-end

data/spec/lib/model_loader.rb

@@ -1,100 +0,0 @@
-# ---
-# Overview
-# ========
-# ModelLoader is a method for loading methods models for specs in a way
-# that will ensure that each spec will be an a pristine state when run.
-#
-# The problem is that if a spec needs to modify a model, the modifications
-# should not carry over to the next spec. As such, all models are
-# destroyed at the end of the spec and reloaded at the start.
-#
-# The second problem is that DataMapper::Resource keeps track
-# of every class that it is included in. This is used for automigration.
-# A number of specs run automigrate, and we don't want all the classes
-# that were defined in other specs to be migrated as well.
-#
-# Usage
-# =====
-#
-# Sets the specified model metaphors to be loaded before each spec and
-# destroyed after each spec in the current example group. This method
-# can be used in a describe block or in a before block.
-#
-# ==== Parameters
-# *metaphor<Symbol>:: The name of the metaphor to load (this is just the filename of
-#               file in specs/models)
-#
-# ==== Example
-#
-# describe "DataMapper::Associations" do
-#
-#   load_models_for_metaphor :zoo, :blog
-#
-#   it "should be awesome" do
-#     Zoo.new.should be_awesome
-#   end
-# end
-module ModelLoader
-
-  def self.included(base)
-    base.extend(ClassMethods)
-    base.class_eval { include InstanceMethods }
-    # base.before(:each) { load_models(:global) }
-    base.after(:each)  { unload_models }
-  end
-
-  module ClassMethods
-
-    def load_models_for_metaphor(*metaphors)
-      before(:each) { load_models_for_metaphor(*metaphors) }
-    end
-
-  end
-
-  module InstanceMethods
-
-    def load_models_for_metaphor(*metaphors)
-      files = metaphors.map { |m| DataMapper.root / "spec" / "models" / "#{m}.rb" }
-
-      klasses = object_space_classes.dup
-      files.each { |file| load file }
-      loaded_models.concat(object_space_classes - klasses)
-    end
-
-    def unload_models
-      while model = loaded_models.pop
-        remove_model(model)
-      end
-    end
-
-    def loaded_models
-      @loaded_models ||= []
-    end
-
-  private
-
-    def object_space_classes
-      klasses = []
-      ObjectSpace.each_object(Class) {|o| klasses << o}
-      klasses
-    end
-
-    def remove_model(klass)
-      DataMapper::Resource.descendants.delete(klass)
-      # Check to see if the model is living inside a module
-      klass_name = klass.to_s
-      if klass_name.index("::")
-        mod = klass_name.match(/(\S+)::/)[1]
-        child_class = klass_name.match(/\S+::(\S+)/)[1]
-
-        Object.const_get(mod).module_eval { remove_const child_class }
-      else
-        Object.module_eval { remove_const klass.to_s }
-      end
-    end
-  end
-end
-
-Spec::Runner.configure do |config|
-  config.include(ModelLoader)
-end

data/spec/lib/publicize_methods.rb

@@ -1,28 +0,0 @@
-class Class
-  def publicize_methods
-    klass = class << self; self; end
-
-    saved_private_class_methods      = klass.private_instance_methods
-    saved_protected_class_methods    = klass.protected_instance_methods
-    saved_private_instance_methods   = self.private_instance_methods
-    saved_protected_instance_methods = self.protected_instance_methods
-
-    self.class_eval do
-      klass.send(:public, *saved_private_class_methods)
-      klass.send(:public, *saved_protected_class_methods)
-      public(*saved_private_instance_methods)
-      public(*saved_protected_instance_methods)
-    end
-
-    begin
-      yield
-    ensure
-      self.class_eval do
-        klass.send(:private, *saved_private_class_methods)
-        klass.send(:protected, *saved_protected_class_methods)
-        private(*saved_private_instance_methods)
-        protected(*saved_protected_instance_methods)
-      end
-    end
-  end
-end

data/spec/models/content.rb

@@ -1,16 +0,0 @@
-module Content
-  class Dialect
-    include DataMapper::Resource
-
-    property :id,   Serial
-    property :name, String
-    property :code, String
-  end
-
-  class Locale
-    include DataMapper::Resource
-
-    property :id,   Serial
-    property :name, String
-  end
-end