datamapper 0.1.1 → 0.2.0

data/lib/data_mapper/associations/advanced_has_many_association.rb

@@ -1,55 +0,0 @@
-module DataMapper
-  module Associations
-    
-    class AdvancedHasManyAssociation
-      include Enumerable
-      
-      def initialize(klass, association_name, options)
-        @association_name = association_name.to_sym
-        @options = options
-
-        # Define the association instance method (i.e. Project#tasks)
-        klass.class_eval <<-EOS
-          def #{association_name}
-            @#{association_name} || (@#{association_name} = HasManyAssociation.new(self, "#{association_name}", #{options.inspect}))
-          end
-        EOS
-      end
-      
-      def name
-        @association_name
-      end
-
-      def constant
-        @associated_class || @associated_class = if @options.has_key?(:class) || @options.has_key?(:class_name)
-          associated_class_name = (@options[:class] || @options[:class_name])
-          if associated_class_name.kind_of?(String)
-            Kernel.const_get(Inflector.classify(associated_class_name))
-          else
-            associated_class_name
-          end
-        else            
-          Kernel.const_get(Inflector.classify(association_name))
-        end
-      end
-      
-      def foreign_key
-        @foreign_key || (@foreign_key = (@options[:foreign_key] || @instance.session.schema[@instance.class].default_foreign_key))
-      end
-
-    end
-    
-    module AdvancedHasMany
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-      
-      module ClassMethods
-        def advanced_has_many(association_name, options = {})
-          database.schema[self].associations << AdvancedHasManyAssociation.new(self, association_name, options)
-        end
-      end
-    end
-    
-  end
-end

data/lib/data_mapper/support/blank_slate.rb

@@ -1,3 +0,0 @@
-class BlankSlate #:nodoc:
-  instance_methods.each { |m| undef_method m unless m =~ /^(__|instance_eval)/ }
-end

data/lib/data_mapper/support/proc.rb

@@ -1,69 +0,0 @@
-require File.dirname(__FILE__) + '/blank_slate'
-
-class Proc
-  
-  # Yeah, all this is kinda the suck.
-  def to_hash
-    Conditions.new(&self).__to_hash__
-  end
-  
-  class Conditions < BlankSlate
-    
-    def initialize(&block)
-      @block = block
-      @conditions = []
-    end
-    
-    def method_missing(sym, *args)
-      attribute = Attribute.new(sym)
-      @conditions << attribute
-      attribute
-    end
-    
-    def __to_hash__
-      instance_eval(&@block)      
-      @conditions.inject({}) do |h,attribute|
-        h[attribute.__operator__] = *attribute.__args__; h
-      end
-    end
-    
-    class Attribute < BlankSlate
-      
-      def initialize(message)
-        @message = message
-        @args = nil
-        @operator = nil
-      end
-    
-      def method_missing(sym, *args)
-        op = case sym
-          when :==, :===, :in then :eql
-          when :=~ then :like
-          when :"<=>" then :not
-          when :< then :lt
-          when :<= then :lte
-          when :> then :gt
-          when :>= then :gte
-          else sym
-        end
-        
-        @operator = Symbol::Operator.new(@message, op)
-        @args = args
-      end
-      
-      def __operator__
-        @operator
-      end
-      
-      def __args__
-        @args
-      end
-    
-      def __message__
-        @message
-      end
-      
-    end
-        
-  end
-end

data/lib/data_mapper/support/struct.rb

@@ -1,26 +0,0 @@
-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/unit_of_work.rb

@@ -1,38 +0,0 @@
-module DataMapper
-  
-  # Should this track relations?
-  module UnitOfWork
-
-    def new_record?
-      @new_record.nil? || @new_record
-    end
-    
-    def dirty?(name = nil)
-      if name.nil?
-        session.schema[self.class].columns.any? { |column| self.instance_variable_get(column.instance_variable_name).hash != original_hashes[column.name] }
-      else
-        key = name.kind_of?(Symbol) ? name : name.to_sym
-        self.instance_variable_get("@#{name}").hash != original_hashes[key]
-      end
-    end
-
-    def dirty_attributes
-      if new_record?
-        session.schema[self.class].columns.reject do |column|
-          instance_variable_get(column.instance_variable_name).nil?
-        end
-      else        
-        session.schema[self.class].columns.select do |column|
-          column.name != :id && instance_variable_get(column.instance_variable_name).hash != original_hashes[column.name]
-        end
-      end.inject({}) do |fields, column|
-        fields[column.name] = instance_variable_get(column.instance_variable_name); fields
-      end
-    end
-    
-    def original_hashes
-      @original_hashes || (@original_hashes = {})
-    end
-  end
-
-end

data/spec/basic_finder.rb

@@ -1,67 +0,0 @@
-context 'Finder' do
-  
-  specify 'database-specific load should not fail' do
-    
-    DataMapper::database do |db|
-      froggy = db.first(Animal, :conditions => ['name = ?', 'Frog'])
-      froggy.name.should == 'Frog'
-    end
-
-  end
-  
-  specify 'current-database load should not fail' do
-    froggy = DataMapper::database.first(Animal).name.should == 'Frog'
-  end
-  
-  specify 'load through ActiveRecord impersonation should not fail' do
-    Animal.find(:all).size.should == 16
-  end
-  
-  specify 'load through Og impersonation should not fail' do
-    Animal.all.size.should == 16
-  end
-  
-  specify ':conditions option should accept a hash' do
-    Animal.all(:conditions => { :name => 'Frog' }).size.should == 1
-  end
-  
-  specify 'non-standard options should be considered part of the conditions' do
-    database.log.debug('non-standard options should be considered part of the conditions')
-    zebra = Animal.first(:name => 'Zebra')
-    zebra.name.should == 'Zebra'
-    
-    elephant = Animal[:name => 'Elephant']
-    elephant.name.should == 'Elephant'
-    
-    aged = Person.all(:age => 29)
-    aged.size.should == 2
-    aged.first.name.should == 'Sam'
-    aged.last.name.should == 'Bob'
-    
-    fixtures(:animals)
-  end
-  
-  specify 'should not find deleted objects' do
-    database do
-      wally = Animal[:name => 'Whale']
-      wally.destroy!.should == true
-    
-      wallys_evil_twin = Animal[:name => 'Whale']
-      wallys_evil_twin.should == nil
-    
-      wally.new_record?.should == true
-      wally.save
-    
-      Animal[:name => 'Whale'].should == wally
-    end
-  end
-  
-  specify 'lazy-loads should issue for whole sets' do
-    people = Person.all
-    
-    people.each do |person|
-      person.notes
-    end
-  end
-  
-end

data/spec/belongs_to.rb

@@ -1,47 +0,0 @@
-context 'An Exhibit' do
-  
-  setup do
-    @aviary = Exhibit[:name => 'Monkey Mayhem']
-  end
-  
-  specify 'has a zoo association' do
-    @aviary.zoo.class.should == Zoo
-    Exhibit.new.zoo.should == nil
-  end
-  
-  specify 'belongs to a zoo' do
-    database do |db|
-      @aviary.zoo.should == @aviary.session.first(Zoo, :name => 'San Diego')
-    end
-  end
-  
-  specify 'can build its zoo' do
-    database do |db|
-      e = Exhibit.new({:name => 'Super Extra Crazy Monkey Cage'})
-      e.zoo.should == nil
-      e.build_zoo({:name => 'Monkey Zoo'})
-      e.zoo.class == Zoo
-      e.zoo.new_record?.should == true
-      
-      # Need to get associations working properly before this works ....
-      e.save
-    end
-  end
-  
-  specify 'can build its zoo' do
-    database do |db|
-      e = Exhibit.new({:name => 'Super Extra Crazy Monkey Cage'})
-      e.zoo.should == nil
-      e.create_zoo({:name => 'Monkey Zoo'})
-      e.zoo.class == Zoo
-      e.zoo.new_record?.should == false
-      e.save
-    end
-  end
-  
-  teardown do
-    fixtures('zoos')
-    fixtures('exhibits')
-  end
-
-end

data/spec/has_and_belongs_to_many.rb

@@ -1,25 +0,0 @@
-# context 'An Exhibit' do
-#   
-#   setup do
-#     @amazonia = Exhibit[:name => 'Amazonia']
-#   end
-#   
-#   specify 'has an animals association' do
-#     [@amazonia, Exhibit.new].each do |exhibit|
-#       exhibit.animals.class.should == DataMapper::Associations::HasAndBelongsToManyAssociation
-#     end
-#   end
-#   
-#   specify 'has many animals' do
-#     @amazonia.animals.size.should == 2
-#   end
-#   
-#   specify 'should load associations magically' do
-#     Exhibit.all.each do |exhibit|
-#       exhibit.animals.each do |animal|
-#         animal.exhibits.should.include?(exhibit)
-#       end
-#     end
-#   end
-#   
-# end

data/spec/has_many.rb

@@ -1,34 +0,0 @@
-describe DataMapper::Associations::HasManyAssociation do
-  
-  before(:all) do
-    fixtures(:zoos)
-    fixtures(:exhibits)
-    
-    @san_diego = Zoo[:name => 'San Diego']
-    @dallas = Zoo[:name => 'Dallas']
-    @miami = Zoo[:name => 'Miami']
-  end
-    
-  it 'should expose a proxy for the accessor' do
-    [@miami, Zoo.new].each do |z|
-      z.exhibits.class.should == DataMapper::Associations::HasManyAssociation
-    end
-  end
-  
-  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.first(Exhibit, :name => 'Monkey Mayhem'))
-    end
-  end
-  
-  it 'should eager-load associations for an entire set' do
-    zoos = Zoo.all
-    zoos.each do |zoo|
-      zoo.exhibits.each do |exhibit|
-        exhibit.zoo.should == zoo
-      end
-    end
-  end
-  
-end

data/spec/new_record.rb

@@ -1,24 +0,0 @@
-context 'A new record' do
-  
-  setup do
-    @bob = Person.new(:name => 'Bob', :age => 30, :occupation => 'Sales')
-  end
-  
-  specify 'should be dirty' do
-    @bob.dirty?.should == true
-  end
-  
-  specify 'set attributes should be dirty' do
-    attributes = @bob.attributes.dup.reject { |k,v| k == :id }
-    @bob.dirty_attributes.should == { :name => 'Bob', :age => 30, :occupation => 'Sales' }
-  end
-  
-  specify 'should be marked as new' do
-    @bob.new_record?.should == true
-  end
-  
-  specify 'should have a nil id' do
-    @bob.id.should == nil
-  end
-  
-end

data/spec/sub_select.rb

@@ -1,16 +0,0 @@
-=begin
-context 'Sub-selection' do
-  
-  specify 'should return a Cup' do
-    Animal[:id.select => { :name => 'cup' }].name.should == 'Cup'
-  end
-  
-  specify 'should return all exhibits for Galveston zoo' do
-    Exhibit.all(:zoo_id.select(Zoo) => { :name => 'Galveston' }).size.should == 3
-  end
-  
-  specify 'should allow a sub-select in the select-list' do
-    Animal[:select => [ :id.count ]]
-  end
-end
-=end

data/spec/support/string_spec.rb

@@ -1,7 +0,0 @@
-describe DataMapper::Support::String do
-  
-  it 'should underscore camel-cased words' do
-    String::memoized_underscore('DataMapper').should == 'data_mapper'
-  end
-  
-end