dm-ldap-adapter 0.3.5 → 0.4.0.alpha2

data/lib/ldap_resource.rb

@@ -3,11 +3,105 @@ require 'dm-core'
 require 'ldap/array'
 
 module DataMapper
-  module Resource
-    module ClassMethods
-      
+  module Model
+   
+      def load(records, query)
+        repository      = query.repository
+        repository_name = repository.name
+        fields          = query.fields
+        discriminator   = properties(repository_name).discriminator
+        no_reload       = !query.reload?
+        
+        field_map = fields.map { |property| [ property, property.field ] }.to_hash
+        
+        records.map do |record|
+          identity_map = nil
+          key_values   = nil
+          resource     = nil
+          
+          case record
+          when Hash
+            # remap fields to use the Property object
+            record = record.dup
+            field_map.each { |property, field| record[property] = record.delete(field) if record.key?(field) }
+
+            model     = discriminator && discriminator.load(record[discriminator]) || self
+            model_key = model.key(repository_name)
+
+            resource = if model_key.valid?(key_values = record.values_at(*model_key))
+              identity_map = repository.identity_map(model)
+              identity_map[key_values]
+            end
+
+            resource ||= model.allocate
+
+            fields.each do |property|
+              next if no_reload && property.loaded?(resource)
+
+              value = record[property]
+
+              # TODO: typecasting should happen inside the Adapter
+              # and all values should come back as expected objects
+              if property.respond_to?(:load_with_resource)
+                # hack to allow mutable types which are able to reset 
+                # the attribute to make them dirty
+                value = property.load_with_resource(value, resource)
+              else
+                value = property.load(value)
+              end
+
+              property.set!(resource, value)
+            end
+
+          when Resource
+            model     = record.model
+            model_key = model.key(repository_name)
+            
+            resource = if model_key.valid?(key_values = record.key)
+                         identity_map = repository.identity_map(model)
+                         identity_map[key_values]
+                       end
+            
+            resource ||= model.allocate
+            
+            fields.each do |property|
+              next if no_reload && property.loaded?(resource)
+              
+              property.set!(resource, property.get!(record))
+            end
+          end
+          
+          resource.instance_variable_set(:@_repository, repository)
+          
+          if identity_map
+            resource.persisted_state = Resource::State::Clean.new(resource) unless resource.persisted_state?
+            
+            # defer setting the IdentityMap so second level caches can
+            # record the state of the resource after loaded
+            identity_map[key_values] = resource
+          else
+            resource.persisted_state = Resource::State::Immutable.new(resource)
+          end
+          
+          resource
+        end
+      end
+
+      module LdapResource
+
+      Model.append_inclusions self
+
+      # authenticate the current resource against the stored password
+      # @param [String] password to authenticate
+      # @return [TrueClass, FalseClass] whether password was right or wrong
+      def authenticate(password)
+        ldap.authenticate(ldap.dn(self.class.dn_prefix(self),
+                                  self.class.treebase),
+                          password)
+      end
+
       # if called without parameter or block the given properties get returned.
-      # if called with a block then the block gets stored. if called with new 
+      # if called with a block then the block gets stored. if called with new
       # properties they get stored. if called with a Resource then either the
       # stored block gets called with that Resource or the stored properties get
       # returned.
@@ -27,9 +121,9 @@ module DataMapper
           @ldap_properties = block
         end
       end
-      
+
       # if called without parameter or block the given treebase gets returned.
-      # if called with a block then the block gets stored. if called with a 
+      # if called with a block then the block gets stored. if called with a
       # String then it gets stored. if called with a Resource then either the
       # stored block gets called with that Resource or the stored String gets
       # returned.
@@ -53,9 +147,9 @@ module DataMapper
           end
         end
       end
-      
+
       # if called without parameter or block the given dn_prefix gets returned.
-      # if called with a block then the block gets stored. if called with a 
+      # if called with a block then the block gets stored. if called with a
       # String then it gets stored. if called with a Resource then either the
       # stored block gets called with that Resource or the stored String gets
       # returned.
@@ -75,8 +169,8 @@ module DataMapper
           @ldap_dn = block
         end
       end
-      
-      # if called without parameter then the stored field gets returned 
+
+      # if called without parameter then the stored field gets returned
       # otherwise the given parameters gets stored
       # @param [Symbol, String] field a new multivalue_field
       # @return [Symbol] the multivalue_field
@@ -87,23 +181,16 @@ module DataMapper
           @ldap_multivalue_field = field.to_sym
         end
       end
-    end
-    
-    # authenticate the current resource against the stored password
-    # @param [String] password to authenticate
-    # @return [TrueClass, FalseClass] whether password was right or wrong
-    def authenticate(password)
-      ldap.authenticate(ldap.dn(self.class.dn_prefix(self),
-                                self.class.treebase), 
-                        password)
-    end
 
-    private
-    # short cut to the ldap facade
-    # @return [Ldap::LdapFacade]
-    def ldap
-      raise "not an ldap adapter #{repository.adapter.name}" unless repository.adapter.respond_to? :ldap
-      repository.adapter.ldap
+      private
+      # short cut to the ldap facade
+      # @return [Ldap::LdapFacade]
+      def ldap
+        raise "not an ldap adapter #{repository.adapter.name}" unless repository.adapter.respond_to? :ldap
+        repository.adapter.ldap
+      end
     end
+
+    include LdapResource
   end
 end

data/spec/assiociations_ldap_adapter_spec.rb

@@ -1,164 +1,163 @@
 $LOAD_PATH << File.dirname(__FILE__)
 require 'spec_helper'
 
-[
- :default,
- :ldap,
- :memory
-].each do |adapter|
-  
-  describe "A #{DataMapper.repository(adapter).adapter.class.name}" do
-  
-    puts "#{DataMapper.repository(adapter).adapter.class.name}"
-   
-    before do
+describe DataMapper::Adapters::LdapAdapter do
 
-      DataMapper.repository(adapter) do
-        User.all(:login.like => "b%").destroy!
-        Group.all(:name.like => "test_%").destroy!
-        @user1 = User.create(:login => "black", :name => 'Black', :age => 0)
-        @user2 = User.create(:login => "brown", :name => 'Brown', :age => 25)
-        @user3 = User.create(:login => "blue", :name => 'Blue',  :age => nil)
- 
-        @group1 = Group.create(:name => "test_root_group")
-        @group2 = Group.create(:name => "test_admin_group")
-      end
-    end
+  before do
 
-    after do
-      DataMapper.repository(adapter) do
-        @user1.destroy
-        @user2.destroy
-        @user3.destroy
+    DataMapper.repository(:ldap) do
+      User.all(:login.like => "b%").destroy!
+      Group.all(:name.like => "test_%").destroy!
+      @user1 = User.create(:login => "black", :name => 'Black', :age => 0)
+      @user2 = User.create(:login => "brown", :name => 'Brown', :age => 25)
+      @user3 = User.create(:login => "blue", :name => 'Blue',  :age => nil)
 
-        @group1.destroy
-        @group2.destroy
-      end
+      @group1 = Group.create(:name => "test_root_group")
+      @group2 = Group.create(:name => "test_admin_group")
     end
+  end
 
-    it 'should successfully save an object' do
-      DataMapper.repository(adapter) do
-        @group1.new_record?.should be_false
-      end
+  it 'should successfully save an object' do
+    DataMapper.repository(:ldap) do
+      @group1.new?.should be_false
     end
+  end
 
-    it 'should be able to get the object' do
-      DataMapper.repository(adapter) do
-        Group.get(@group1.id).should == @group1
-      end
+  it 'should be able to get the object' do
+    DataMapper.repository(:ldap) do
+      Group.get(@group1.id).should == @group1
     end
+  end
 
-    it 'should be able to get all the objects' do
-      DataMapper.repository(adapter) do
-        Group.all(:name.like => "test_%").should == [@group1, @group2]
-      end
+  it 'should be able to get all the objects' do
+    DataMapper.repository(:ldap) do
+      Group.all(:name.like => "test_%").should == [@group1, @group2]
     end
+  end
 
-    it 'should be able to have a user' do
-      DataMapper.repository(adapter) do
+  it 'should be able to have a user' do
+    DataMapper.repository(:ldap) do
+      begin
+        gu = GroupUser.new(:user_id => @user1.id, :group_id => @group1.id)
         # the next load prevent strange errors
         @user1 = User.get!(@user1.id)
         @user1.groups << @group1
         @user1.save
         User.get(@user1.id).groups.should == [@group1]
+      rescue => e
+        puts e
+        puts e.backtrace.join "\n\t"
+        raise e
       end
     end
+  end
 
-    it 'should be able to delete a user' do
-      DataMapper.repository(adapter) do
-        # the next load prevent strange errors
-        @user1 = User.get!(@user1.id)
-        @user1.groups << @group1
-        @user1.save
-        @user1.groups.delete(@group1)
-        @user1.save
-        User.get(@user1.id).groups.should == []
-        @user1.groups << @group1
-        @user1.groups << @group2
-        @user1.save
-        @user1.groups.delete(@group1)
-        @user1.save
-        User.get(@user1.id).groups.should == [@group2]
-      end
+  it 'should be able to delete a user' do
+    DataMapper.repository(:ldap) do
+      # the next load prevent strange errors
+      @user1 = User.get!(@user1.id)
+      @user1.groups << @group1
+      @user1.save
+      @user1.groups.delete(@group1)
+      @user1.save
+      User.get(@user1.id).groups.should == []
+      @user1.groups << @group1
+      @user1.groups << @group2
+      @user1.save
+      @user1.groups.delete(@group1)
+      @user1.save
+      User.get(@user1.id).groups.should == [@group2]
     end
+  end
 
-    it 'should be able to have users and remove them again' do
-      DataMapper.repository(adapter) do
-        # the next load prevent strange errors
-        @user1 = User.get!(@user1.id)
-        @user1.groups << @group1
-        @user1.save
-        User.get(@user1.id).groups.should == [@group1]
-        @user1.groups << @group2
-        @user1.save
-        User.get(@user1.id)
-        @user1.groups.sort{|g1, g2| g1.id <=> g2.id}.should == [@group1, @group2]
-        @user1.groups.delete(@group1)
-        @user1.save
-        User.get(@user1.id).groups.should == [@group2]
-        @user1.groups.delete(@group2)
-        @user1.save
-        User.get(@user1.id).groups.should == []
-      end
+  it 'should be able to have users and remove them again' do
+    DataMapper.repository(:ldap) do
+      # the next load prevent strange errors
+      @user1 = User.get!(@user1.id)
+      @user1.groups << @group1
+      @user1.save
+      User.get(@user1.id).groups.should == [@group1]
+      @user1.groups << @group2
+      @user1.save
+      User.get(@user1.id)
+      @user1.groups.sort{|g1, g2| g1.id <=> g2.id}.should == [@group1, @group2]
+      @user1.groups.delete(@group1)
+      @user1.save
+      User.get(@user1.id).groups.should == [@group2]
+      @user1.groups.delete(@group2)
+      @user1.save
+      User.get(@user1.id).groups.should == []
     end
+  end
 
-    it 'should be able to have two users' do
-      DataMapper.repository(adapter) do
-        # the next load prevent strange errors
-        @user1 = User.get!(@user1.id)
-        @user1.groups << @group1
-        @user1.groups << @group2
-        @user1.save
-        User.get(@user1.id).groups.sort{|g1, g2| g1.id <=> g2.id}.should == [@group1, @group2]
-        @user2.groups << @group1
-        @user2.save
-      end
-      DataMapper.repository(adapter) do
-        User.get(@user2.id).groups.should == [@group1]
-        User.get(@user1.id).groups.sort{|g1, g2| g1.id <=> g2.id}.should == [@group1, @group2]
-      end
+  it 'should be able to have two users' do
+    DataMapper.repository(:ldap) do
+      # the next load prevent strange errors
+      @user1 = User.get!(@user1.id)
+      @user1.groups << @group1
+      @user1.groups << @group2
+      @user1.save
+      User.get(@user1.id).groups.sort{|g1, g2| g1.id <=> g2.id}.should == [@group1, @group2]
+      @user2.groups << @group1
+      @user2.save
     end
-    
-    it 'should raise an not found error' do
-      lambda do
-        User.get!(4711)
-      end.should raise_error(DataMapper::ObjectNotFoundError)
+    DataMapper.repository(:ldap) do
+      User.get(@user2.id).groups.should == [@group1]
+      User.get(@user1.id).groups.sort{|g1, g2| g1.id <=> g2.id}.should == [@group1, @group2]
     end
+  end
 
-    it 'should be able to have two users in one group' do
-      DataMapper.repository(adapter) do
-        @user1 = User.get!(@user1.id)
-        @user1.groups << @group1
-        @user1.groups << @group2
-        @user1.groups.sort{|g1, g2| g1.id <=> g2.id}.should == [@group1, @group2]
-        @user2.groups << @group1
-      end
-      DataMapper.repository(adapter) do
-        User.get(@user1.id).groups.sort{|g1, g2| g1.id <=> g2.id}.should == [@group1, @group2]
-        User.get(@user2.id).groups.should == [@group1]
-      end
+  it 'should raise an not found error' do
+    lambda do
+      User.get!(4711)
+    end.should raise_error(DataMapper::ObjectNotFoundError)
+  end
+
+  it 'should be able to have two users in one group' do
+    DataMapper.repository(:ldap) do
+      @user1 = User.get!(@user1.id)
+      @user1.groups << @group1
+      @user1.groups << @group2
+      @user1.groups.sort{|g1, g2| g1.id <=> g2.id}.should == [@group1, @group2]
+      @user2.groups << @group1
     end
-    
-    it 'should be able to delete a user from a group' do
-      DataMapper.repository(adapter) do
-        size = GroupUser.all.size
-        @user1 = User.get!(@user1.id)
-        @user1.groups << @group1
-        @user1.groups << @group2
-        @user2.groups << @group1
-        GroupUser.all.size.should == size + 3
-      end
-      DataMapper.repository(adapter) do
-        @user1 = User.get!(@user1.id)
-        @user1.groups.delete(@group1)
-        User.get(@user1.id).groups.should == [@group2]
-        User.get(@user2.id).groups.should == [@group1]
-        @user2 = User.get!(@user2.id)
-        @user2.groups.delete(@group1)
-        User.get(@user1.id).groups.should == [@group2]
-        User.get(@user2.id).groups.should == []
-      end
+    DataMapper.repository(:ldap) do
+      User.get(@user1.id).groups.sort{|g1, g2| g1.id <=> g2.id}.should == [@group1, @group2]
+      User.get(@user2.id).groups.should == [@group1]
     end
+  end
 
+  it 'should be able to delete a user from a group' do
+    DataMapper.repository(:ldap) do
+      size = GroupUser.all.size
+      @user1 = User.get!(@user1.id)
+      @user1.groups << @group1
+      @user1.groups << @group2
+      @user2.groups << @group1
+      GroupUser.all.size.should == size + 3
+    end
+    DataMapper.repository(:ldap) do
+      puts
+      puts "--------------"
+      p User.get(@user1.id).groups
+      puts "--------------"
+      p User.get(@user2.id).groups
+      puts
+      @user1 = User.get!(@user1.id)
+      @user1.groups.delete(@group1)
+      puts
+      puts "--------------"
+      p User.get(@user1.id).groups
+      puts "--------------"
+      p User.get(@user2.id).groups
+      puts
+      User.get(@user1.id).groups.should == [@group2]
+      User.get(@user2.id).groups.should == [@group1]
+      @user2 = User.get!(@user2.id)
+      @user2.groups.delete(@group1)
+      User.get(@user1.id).groups.should == [@group2]
+      User.get(@user2.id).groups.should == []
+    end
   end
+
 end

data/spec/authentication_ldap_adapter_spec.rb

@@ -7,18 +7,13 @@ describe DataMapper.repository(:ldap).adapter do
 
     before do
       DataMapper.repository(:ldap) do
+        User.all.destroy!
         @user = User.new(:login => "beige", :name => 'Beige')
         @user.password = "asd123"
         @user.save
       end
     end
 
-    after do
-      DataMapper.repository(:ldap) do
-        @user.destroy
-      end
-    end
-
     it 'should successfully authenticate' do
       DataMapper.repository(:ldap) do
         @user.authenticate("asd123").should be_true