dm-ldap-adapter 0.3.5 → 0.4.0.alpha2

data/spec/sorting_spec.rb

@@ -2,28 +2,19 @@ $LOAD_PATH << File.dirname(__FILE__)
 require 'spec_helper'
 
 describe DataMapper.repository(:ldap).adapter do
-  
+
   describe 'belongs_to association' do
-    
+
     before do
       DataMapper.repository(:ldap) do
         User.all.destroy!
-        @user1 = User.create(:login => "black", :name => 'Black', :mail => "blackmail@exmple.com", :age => 100) 
-        @user2 = User.create(:login => "brown", :name => 'brown', :mail => "brownmail@exmple.com", :age => 25)
+        @user1 = User.create(:login => "black", :name => 'Black', :mail => ["blackmail@example.com"], :age => 100)
+        @user2 = User.create(:login => "brown", :name => 'brown', :mail => ["brownmail@example.com"], :age => 25)
         @user3 = User.create(:login => "blue", :name => 'Yellow')
         @user4 = User.create(:login => "baluh", :name => 'Hmm')
       end
     end
-    
-    after do
-      DataMapper.repository(:ldap) do
-        @user1.destroy
-        @user2.destroy
-        @user3.destroy
-        @user4.destroy
-      end
-    end
-    
+
     it 'should sort descending without order option' do
       DataMapper.repository(:ldap) do
         expected = User.all().sort do |u1, u2|
@@ -40,6 +31,12 @@ describe DataMapper.repository(:ldap).adapter do
         end
         User.all(:order => [:login]).should == expected
       end
+      DataMapper.repository(:ldap) do
+        expected = User.all().sort do |u1, u2|
+          -1 * (u1.login <=> u2.login)
+        end
+        User.all(:order => [:login]).reverse.should == expected
+      end
     end
     it 'should sort case insensitive with order option' do
       DataMapper.repository(:ldap) do
@@ -52,9 +49,13 @@ describe DataMapper.repository(:ldap).adapter do
 
     it 'should sort with nil values' do
       DataMapper.repository(:ldap) do
-        users = User.all(:order => [:mail]).select { |u| !u.mail.nil? }
+        users = User.all(:order => [:name]).select { |u| !u.mail.nil? }
         users.should == [@user1, @user2]
       end
+      DataMapper.repository(:ldap) do
+        users = User.all(:order => [:name]).reverse.select { |u| !u.mail.nil? }
+        users.should == [@user2, @user1]
+      end
     end
   end
 end

data/spec/spec_helper.rb

@@ -3,16 +3,17 @@ require 'rubygems'
 require 'slf4r/ruby_logger'
 Slf4r::LoggerFacade4RubyLogger.level = :info
 
-gem 'dm-core', "<0.10.0"
-gem 'do_sqlite3', "<0.10.0"
-
-require 'do_sqlite3'
+require 'dm-sqlite-adapter'
+require 'dm-migrations'
+require 'dm-transactions'
 require 'pathname'
 $LOAD_PATH << Pathname(__FILE__).dirname.parent.expand_path + 'lib'
 
+print "datamapper version:"
+puts DataMapper::VERSION
+
 require 'ldap_resource'
 require 'adapters/ldap_adapter'
-require 'adapters/memory_adapter'
 
 DataMapper.setup(:default, 'sqlite3::memory:')
 DataMapper.setup(:ldap, {
@@ -20,17 +21,30 @@ DataMapper.setup(:ldap, {
                    :host => 'localhost',
                    :port => '389',
                    :base => "dc=example,dc=com",
-#                   :facade => :ruby_ldap,
+                   :facade => (ENV['FACADE'] || :net_ldap).to_sym,
                    :bind_name => "cn=admin,dc=example,dc=com",
-                   :password => "behappy"   
+                   :password => "secret"
 })
-DataMapper.setup(:memory, {:adapter  => 'memory'})
 
+module DataMapper
+  module Resource
+    class State
+
+      # a persisted/deleted resource
+      class Deleted < Persisted
+        def set(subject, value)
+          warn 'Deleted resource cannot be modified ' + subject.inspect + ' ' + value.to_s + " " + @resource.inspect
+          super
+        end
+      end
+    end
+  end
+end
 class User
   include DataMapper::Resource
   property :id,        Serial, :field => "uidnumber"
   property :login,     String, :field => "uid", :unique_index => true
-  property :hashed_password,  String, :field => "userpassword", :access => :private
+  property :hashed_password,  String, :field => "userpassword", :writer => :private
   property :name,      String, :field => "cn"
   property :mail,      String
   property :age,       Integer, :field => "postalcode"
@@ -62,7 +76,7 @@ class User
     end
     groups
   end
- 
+
   dn_prefix { |user| "uid=#{user.login}"}
 
   treebase "ou=people"
@@ -84,11 +98,11 @@ class Role
   include DataMapper::Resource
   property :id,       Serial, :field => "gidnumber"
   property :name,     String, :field => "cn"
-  
+
   dn_prefix { |role| "cn=#{role.name}" }
-  
+
   treebase "ou=groups"
-  
+
   ldap_properties {{:objectclass => "posixGroup"}}
 
   belongs_to :user
@@ -98,23 +112,23 @@ class Group
   include DataMapper::Resource
   property :id,       Serial, :field => "gidnumber"
   property :name,     String, :field => "cn"
-  
+
   dn_prefix { |group| "cn=#{group.name}" }
-  
+
   treebase "ou=groups"
-  
+
   ldap_properties {{:objectclass => "posixGroup"}}
 end
 
 class GroupUser
   include DataMapper::Resource
- 
+
   dn_prefix { |group_user| "cn=#{group_user.group.name}" }
-  
+
   treebase "ou=groups"
-  
+
   multivalue_field :memberuid
-  
+
   ldap_properties do |group_user|
     {:cn=>"#{group_user.group.name}",  :objectclass => "posixGroup"}
   end

metadata

@@ -1,7 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: dm-ldap-adapter
 version: !ruby/object:Gem::Version 
-  version: 0.3.5
+  hash: 436503056
+  prerelease: true
+  segments: 
+  - 0
+  - 4
+  - 0
+  - alpha2
+  version: 0.4.0.alpha2
 platform: ruby
 authors: 
 - mkristian
@@ -9,49 +16,71 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-25 00:00:00 +05:30
+date: 2010-10-19 00:00:00 +05:30
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: ruby-net-ldap
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 0
+        - 0
+        - 4
         version: 0.0.4
-    version: 
+  type: :runtime
+  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: slf4r
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
         version: "0"
-    version: 
+  type: :runtime
+  version_requirements: *id002
 - !ruby/object:Gem::Dependency 
   name: dm-core
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
-    - - <
+    - - ~>
       - !ruby/object:Gem::Version 
-        version: 0.10.0
-    version: 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :runtime
+  version_requirements: *id003
 - !ruby/object:Gem::Dependency 
   name: hoe
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 2
+        - 3
+        - 3
         version: 2.3.3
-    version: 
+  type: :development
+  version_requirements: *id004
 description: ldap adapter for datamapper which uses either net-ldap or ruby-ldap
 email: 
 - m.kristian@web.de
@@ -65,20 +94,23 @@ extra_rdoc_files:
 - README.txt
 - ldap-commands.txt
 files: 
+- .project
+- .yardoc
 - History.txt
 - MIT-LICENSE
 - Manifest.txt
 - README-example.markdown
 - README.txt
 - Rakefile
+- env.sh
 - example/identity_map.rb
 - example/posix.rb
 - ldap-commands.txt
 - lib/adapters/ldap_adapter.rb
-- lib/adapters/memory_adapter.rb
-- lib/adapters/simple_adapter.rb
+- lib/adapters/noop_transaction.rb
 - lib/dummy_ldap_resource.rb
 - lib/ldap/array.rb
+- lib/ldap/conditions_2_filter.rb
 - lib/ldap/digest.rb
 - lib/ldap/net_ldap_facade.rb
 - lib/ldap/ruby_ldap_facade.rb
@@ -104,21 +136,29 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
+      hash: 25
+      segments: 
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
 requirements: []
 
 rubyforge_project: dm-ldap-adapter
-rubygems_version: 1.3.5
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: ""

data/lib/adapters/memory_adapter.rb

@@ -1,79 +0,0 @@
-require "dm-core"
-require 'adapters/simple_adapter'
-
-# this and the SimpleAdapter is basically the 
-# dm-core/adapter/in_memory_adapter.rb most credits go dm-core. 
-# there are few bug fixes and enhancements.
-module DataMapper
-  module Adapters
-    class MemoryAdapter < SimpleAdapter
-
-      public
-
-      # @see SimpleAdapter
-      def initialize(name, uri_or_options)
-        super
-
-        @records = Hash.new { |hash,model| hash[model] = Array.new }
-        @ids = Hash.new { |hash,model| hash[model] = 0 }
-      end
-
-      # @see SimpleAdapter
-      def create_resource(resource)
-        uniques = resource.model.properties.select do |prop|
-          prop if prop.unique_index
-        end
-        uniques.each do |prop|
-          raise PersistentError.new "#{prop.name} = #{prop.get(resource)} already exists" unless resource.model.first( prop.name => prop.get(resource) ).nil?
-        end
-        @records[resource.model] << resource
-        resource.id = (@ids[resource.model] += 1) if resource.key.size == 1 
-        # and resource.key[0].serial?
-        resource
-      end
-
-      # @see SimpleAdapter
-      def update_resource(resource, attributes)
-        attributes.each do |property, value|
-          property.set!(resource, value)
-        end
-      end
-
-      # @see SimpleAdapter
-      def delete_resource(resource)
-        records = @records[resource.model]
-        records.delete(resource)
-      end
-
-      # @see SimpleAdapter
-      def read_resource(query)        
-        read(query, false)
-      end
-
-      # @see SimpleAdapter
-      def read_resources(query)        
-        read(query, true)
-      end
-
-      private
-
-      # helper to read either one or many resources matching the given query
-      def read(query, many)
-        model      = query.model
-        conditions = query.conditions
-        
-        match_with = many ? :select : :detect
-
-        result = @records[model].send(match_with) do |resource|
-          filter_resource(resource, conditions)
-        end
-
-        # TODO Sort
-
-        # TODO Limit
-
-        return result
-      end
-    end
-  end
-end

data/lib/adapters/simple_adapter.rb

@@ -1,198 +0,0 @@
-require "dm-core"
-require 'slf4r'
-
-module DataMapper
-  module Adapters
-    class NoopTransaction
-      
-      def close ; end
-      def begin ; end
-      def prepare ; end
-      def commit ; end
-      def rollback ; end
-      def rollback_prepared ; end
-      
-    end
-    class SimpleAdapter < AbstractAdapter
-
-      include Slf4r::Logger
-
-      # @see AbstractAdapter
-      def transaction_primitive
-        NoopTransaction.new
-      end
-
-      def initialize(name, uri_or_options)
-        super(name, uri_or_options)
-      end
-
-      protected
-      
-      # checks whether a given resource fullfils the conditions
-      # @param [DataMapper::Resource] resource
-      # @param [Array<Condition>] conditions
-      # @return [Boolean] 
-      #   true if the resource are within the conditions otherwise false
-      def filter_resource(resource, conditions)
-        #puts "condi"
-        #p conditions
-        # no conditation => no filter
-        if conditions.size == 0
-          true
-        else
-          conditions.all? do |tuple|
-            operator, property, bind_value = *tuple
-            
-            value = property.get!(resource)
-            case operator
-            when :eql, :in then equality_comparison(bind_value, value)
-            when :not      then !equality_comparison(bind_value, value)
-            when :like     then Regexp.new(bind_value.gsub(/%/, ".*")) =~ value
-            when :gt       then !value.nil? && value >  bind_value
-            when :gte      then !value.nil? && value >= bind_value
-            when :lt       then !value.nil? && value <  bind_value
-            when :lte      then !value.nil? && value <= bind_value
-            else raise "Invalid query operator: #{operator.inspect}"
-            end
-          end
-        end
-      end
-
-      # helper method to dispatch the equality test for different
-      # classes
-      def equality_comparison(bind_value, value)
-        case bind_value
-          when Array, Range then bind_value.include?(value)
-          when NilClass     then value.nil?
-          else                   bind_value == value
-        end
-      end
-
-      public
-
-      # @see AbstractAdapter
-      # @param [Array<DataMapper::Resources>] resources
-      #   aaaa
-      # @return [Fixnum] 
-      #    number of the newly created resources
-      def create(resources)
-        resources.select do |resource|
-
-          create_resource(resource)
-
-        end.size # just return the number of create resources
-      end
-
-      # @see AbstractAdapter
-      # @param [Hash] attributes
-      #   collection of attribute, i.e. the name/value pairs which 
-      #   needs to be updated
-      # @param [Query] 
-      #   on all resources which are selected by that query the 
-      #   update will be applied
-      # @return [Fixnum] 
-      #   number of the updated resources
-      def update(attributes, query)
-        read_many(query).select do |resource|
-          
-          update_resource(resource, attributes)
-
-        end.size
-      end
-
-      # @see AbstractAdapter
-      # @param [DataMapper::Query] query
-      #    which selects the resource
-      # @return [DataMapper::Resource] 
-      #    the found Resource or nil
-      def read_one(query)
-        result = read_resource(query)
-        if result.is_a? Resource
-          result
-        elsif result # assume result to be Array with the values
-          #puts "------------------"
-          #p result
-          query.model.load(result, query)
-        end
-      end
-      
-      # @see AbstractAdapter
-      # @param [DataMapper::Query] query
-      #   which selects the resources
-      # @return [DataMapper::Collection] 
-      #   collection of Resources
-      def read_many(query)
-        Collection.new(query) do |set|
-          result = read_resources(query)
-#puts "read_many"
-#p result
-          if result.size > 0 and result.first.is_a? Resource
-            set.replace(result)
-          else
-            result.each do |values|
-              set.load(values)
-            end
-          end
-        end
-      end
-
-      # @see AbstractAdapter
-      # @param [Query] query
-      #   which selects the resources to be deleted
-      # @return [Fixnum]
-      #   number of the deleted resources
-      def delete(query)
-        read_many(query).each do |resource|
-
-          delete_resource(resource)
-
-        end.size
-      end
-      
-      private
-
-      # @param [DataMapper::Resource] resource
-      #   which will be created
-      # @return [DataMapper::Resource] 
-      #   either the resource itself if the creation was successful or nil 
-      def create_resource(resource)
-        raise NotImplementedError.new
-      end
-
-      # @param [DataMapper::Query] query
-      #   which selects the resource
-      # @return [DataMapper::Resource,Array<String>] 
-      #   the resource or a set of values ordered in the same manner as query.fields attributes
-      def read_resource(query)
-        raise NotImplementedError.new
-      end
-
-      # @param [DataMapper::Query] query
-      #   which selects the resources
-      # @return [Array<DataMapper::Resource>,Array<String>]
-      #   resources or ordered values 
-      # @see #read_resource
-      def read_resources(query)
-        raise NotImplementedError.new
-      end
-
-      # @param [DataMapper::Resource] resource
-      #   which will be updated with the given attributes.
-      # @param [Hash] attributes 
-      #    the keys are the property names and the values are the new values of that property. 
-      # @return [DataMapper::Resource] 
-      #   resource on success otherwise nil
-      def update_resource(resource, attributes)
-        raise NotImplementedError.new
-      end
-
-      # @param [DataMapper::Resource] resource
-      #   which will be deleted
-      # @return [DataMapper::Resource]
-      #   either the resource if the deletion was successful or nil 
-      def delete_resource(resource)
-        raise NotImplementedError.new
-      end
-    end
-  end
-end