dm-ldap-adapter 0.3.5 → 0.4.0.alpha2

data/lib/adapters/ldap_adapter.rb

@@ -1,19 +1,21 @@
-require 'adapters/simple_adapter'
+require "dm-core"
+require 'slf4r'
+# require 'adapters/noop_transaction'
 
 module Ldap
 
   # the class provides two ways of getting a LdapFacade. either
   # one which is put on the current Thread or a new one
   class LdapConnection
-    
+
     include ::Slf4r::Logger
 
-    def initialize(uri)
-      if uri[:facade].nil?
+    def initialize(options)
+      if options[:facade].nil?
         require 'ldap/net_ldap_facade'
         @facade = ::Ldap::NetLdapFacade
       else
-        case uri[:facade].to_sym
+        case options[:facade].to_sym
         when :ruby_ldap
           require 'ldap/ruby_ldap_facade'
           @facade = ::Ldap::RubyLdapFacade
@@ -26,19 +28,19 @@ module Ldap
       end
       logger.info("using #{@facade}")
       @ldaps = { }
-      auth =  { 
+      auth =  {
         :method => :simple,
-        :username => uri[:bind_name],
-        :password => uri[:password]
-      } 
-      @config = { 
-        :host => uri[:host], 
-        :port => uri[:port].to_i, 
-        :auth => auth, 
-        :base => uri[:base]
+        :username => options[:bind_name],
+        :password => options[:password]
+      }
+      @config = {
+        :host => options[:host],
+        :port => options[:port].to_i,
+        :auth => auth,
+        :base => options[:base]
       }
     end
-    
+
     # puts a LdapFacade into the current thread and executes the
     # given block.
     def open
@@ -48,10 +50,10 @@ module Ldap
           yield
         end
       ensure
-        @ldaps[Thread.current] = nil 
+        @ldaps[Thread.current] = nil
       end
     end
-    
+
     # @return [Ldap::LdapFacade]
     #  either the one from the current Thread or a new one
     def current
@@ -67,10 +69,32 @@ end
 
 require "dm-core"
 module DataMapper
+  class Query
+
+    class SortCaseInsensitive < Sort
+      def initialize(value, ascending = true)
+        if(value && value.is_a?(String))
+          super(value.upcase, ascending)
+        else
+          super
+        end
+      end
+    end
+
+    def sort_records_case_insensitive(records)
+      sort_order = order.map { |direction| [ direction.target, direction.operator == :asc ] }
+
+      records.sort_by do |record|
+        sort_order.map do |(property, ascending)|
+          SortCaseInsensitive.new(record_value(record, property), ascending)
+        end
+      end
+    end
+  end
   module Adapters
-    class LdapAdapter < SimpleAdapter
+    class LdapAdapter < AbstractAdapter
 
-      # @return [Ldap::LdapFacade] 
+      # @return [Ldap::LdapFacade]
       #   ready to use LdapFacade
       def ldap
         @ldap_connection.current
@@ -81,25 +105,25 @@ module DataMapper
       end
 
       def key_properties(resource)
-        resource.send(:key_properties).first
+        resource.model.key.first
       end
 
       COMPARATORS = { "=" => :eql, ">=" => :gte, "<=" => :lte, "like" => :like }
 
       # helper to remove datamapper specific classes from the conditions
-      # @param [Array] conditions 
+      # @param [Array] conditions
       #   array of tuples: (action, property, new value)
-      # @return [Array] 
+      # @return [Array]
       #   tuples: (action, attribute name, new value)
       def to_ldap_conditions(query)
         conditions = query.conditions
         ldap_conditions = []
-        conditions.each do |c|
-          if c[0] == :raw
+        conditions.operands.each do |c|
+          if c.is_a? Array
             props = {}
             query.fields.each{ |f| props[f.name] = f.field}
             or_conditions = []
-            c[1].split('or').each do |e|
+            c[0].split('or').each do |e|
               e.strip!
               match = e.match("=|<=|>=|like")
               or_conditions << [COMPARATORS[match.values_at(0)[0]],
@@ -108,23 +132,57 @@ module DataMapper
             end
             ldap_conditions << [:or_operator, or_conditions, nil]
           else
-            ldap_conditions << [c[0], c[1].field, c[2]]
+          comparator = c.slug
+          case comparator
+          when :raw
+          when :not
+              # TODO proper recursion !!!
+            ldap_conditions << [comparator, c.operands.first.subject.field, c.operands.first.send(:dumped_value)]
+          when :in
+            ldap_conditions << [:eql, c.subject.field, c.send(:dumped_value)]
+          else
+            ldap_conditions << [comparator, c.subject.field, c.send(:dumped_value)]
           end
         end
+        end
         ldap_conditions
       end
 
+      include ::Slf4r::Logger
+
+      # @see AbstractAdapter
+#      def transaction_primitive
+ #       NoopTransaction.new
+  #    end
+
       public
 
-      def initialize(name, uri_or_options)
-        super(name, uri_or_options)
-        @ldap_connection = ::Ldap::LdapConnection.new(@uri)
+      def initialize(name, options)
+        super(name, options)
+        @ldap_connection = ::Ldap::LdapConnection.new(@options)
+      end
+
+
+      def create(resources)
+        resources.select do |resource|
+
+          create_resource(resource)
+
+        end.size # just return the number of create resources
       end
 
+      def update(attributes, collection)
+        collection.each do |resource|
+#puts "update"
+#p resource
+          update_resource(resource, attributes)
+
+        end.size
+      end
       # @param [DataMapper::Resource] resource
       #   to be created
       # @see SimpleAdapter#create_resource
-      # @return [Fixnum] 
+      # @return [Fixnum]
       #    value for the primary key or nil
       def create_resource(resource)
         logger.debug { resource.inspect }
@@ -133,8 +191,8 @@ module DataMapper
         key = nil
         resource.send(:properties).each do |prop|
           value = prop.get!(resource)
-          if prop.type == ::DataMapper::Types::LdapArray
-            props[prop.field.to_sym] = value.to_s unless value.nil? or value.size == 0
+          if prop.class == ::Ldap::LdapArray
+            props[prop.field.to_sym] = value unless value.nil? or value.size == 0
           else
             props[prop.field.to_sym] = value.to_s unless value.nil?
           end
@@ -156,14 +214,14 @@ module DataMapper
                     end
         logger.debug { "resource #{resource.inspect} key value: #{key_value.inspect}" + ", multivalue_field: " + resource.model.multivalue_field.to_s }
         if key_value and !key.nil?
-          key.set!(resource, key_value.to_i) 
+          key.set!(resource, key_value.to_i)
           resource
         elsif resource.model.multivalue_field
           multivalue_prop = resource.send(:properties).detect do |prop|
             prop.field.to_sym == resource.model.multivalue_field
           end
-          update_resource(resource, 
-                          { multivalue_prop => 
+          update_resource(resource,
+                          { multivalue_prop =>
                             resource.send(multivalue_prop.name.to_sym)})
         else
           nil
@@ -179,18 +237,21 @@ module DataMapper
         actions = []
         attributes.each do |property, value|
           field = property.field.to_sym #TODO sym needed or string ???
-          if property.type == ::DataMapper::Types::LdapArray
-            if resource.original_values[property.name].nil?
-              actions << [:add, field, value.to_s]
+          if property.class == ::Ldap::LdapArray
+value = property.load(value)
+            if resource.original_attributes[property].nil?
+              value.each do |v|
+                actions << [:add, field, v]
+              end
             else
               array_actions = []
-              resource.original_values[property.name].each do |ov|
+              resource.original_attributes[property].each do |ov|
                 unless value.member? ov
                   actions << [:delete, field, ov.to_s]
                 end
               end
               value.each do |v|
-                unless resource.original_values[property.name].member? v
+                unless resource.original_attributes[property].member? v
                   actions << [:add, field, v.to_s]
                 end
               end
@@ -199,119 +260,93 @@ module DataMapper
           else
             if resource.model.multivalue_field == property.field.to_sym
               if value.nil?
-                actions << [:delete, field, resource.original_values[property.name].to_s]
+                actions << [:delete, field, resource.original_attributes[property].to_s]
               else
                 actions << [:add, field, value.to_s]
               end
             elsif value.nil?
               actions << [:delete, field, []]
-            elsif resource.original_values[property.name].nil?
+            elsif resource.original_attributes[property].nil?
               actions << [:add, field, value.to_s]
             else
               actions << [:replace, field, value.to_s]
             end
           end
         end
-# puts "actions"
-# p actions
+#puts "actions"
+#p actions
 #puts
-        ldap.update_object(resource.model.dn_prefix(resource), 
-                           resource.model.treebase, 
+        ldap.update_object(resource.model.dn_prefix(resource),
+                           resource.model.treebase,
                            actions)
       end
 
-      # @param [DataMapper::Resource] resource
-      #   to be deleted
-      # @see SimpleAdapter#delete_resource
-      def delete_resource(resource)
-        if resource.model.multivalue_field
-          multivalue_prop = resource.send(:properties).detect do |prop|
-            prop.field.to_sym == resource.model.multivalue_field
+      # @see AbstractAdapter#delete
+      def delete(collection)
+        collection.each do |resource|
+          if resource.model.multivalue_field
+            multivalue_prop = resource.send(:properties).detect do |prop|
+              prop.field.to_sym == resource.model.multivalue_field
+            end
+            # set the original value so update does the right thing
+            resource.send("#{multivalue_prop.name}=".to_sym, nil)
+            update_resource(resource,
+                            { multivalue_prop => nil })
+          else
+            ldap.delete_object(resource.model.dn_prefix(resource),
+                               resource.model.treebase)
           end
-          # set the original value so update does the right thing
-          resource.send("#{multivalue_prop.name}=".to_sym, nil)
-          update_resource(resource, 
-                          { multivalue_prop => nil })
-        else
-          ldap.delete_object(resource.model.dn_prefix(resource),
-                             resource.model.treebase)
         end
       end
-      
-      # @param [DataMapper::Query] query
-      #   the search criteria
-      # @return [DataMapper::Resource]
-      #   the found resource or nil
-      # @see SimpleAdapter#read_resource
-      def read_resource(query)  
-        field_names = query.fields.collect {|f| f.field }
-        result = ldap.read_objects(query.model.treebase, 
-                                   query.model.key.collect { |k| k.field}, 
-                                   to_ldap_conditions(query),
-                                   field_names)
-        if query.model.multivalue_field
-          resource = result.detect do |item|
-            # run over all values of the multivalue field
-            item[query.model.multivalue_field].any? do |value|
-              values =  query.fields.collect do |f|
-                if query.model.multivalue_field == f.field.to_sym 
-                  value
-                else 
-                  val = item[f.field.to_sym].first
-                  f.primitive == Integer ? val.to_i : val
-                end
-              end
-              resource = query.model.load(values, query)
-              return resource if filter_resource(resource, query.conditions)
-            end
-          end
-        else
-          values = result.first
-          if values
-            query.fields.collect do |f|
-              val = values[f.field.to_sym]
-              if f.type == DataMapper::Types::LdapArray
-                val if val
-              elsif val
-                f.primitive == Integer ? val.first.to_i : val.first
-              end
-            end
+
+      # @see AbstractAdapter#read
+      def read(query)
+        result = []
+        resources = read_resources(query)
+        resources.each do |resource|
+          map = {}
+          query.fields.each_with_index do |property, idx|
+            map[property.field] = property.typecast(resource[idx])
           end
+          result << map
         end
+
+#puts "read_many"
+#p result.size
+        result = result.uniq if query.unique?
+        result = query.match_records(result) if query.model.multivalue_field
+        result = query.sort_records_case_insensitive(result)
+        result = query.limit_records(result)
+        result
       end
-        
-      # @param [DataMapper::Query] query
-      #   the search criteria
-      # @return [Array<DataMapper::Resource]
-      #   the array of found resources
-      # @see SimpleAdapter#read_resources
+
       def read_resources(query)
-        order_by = query.order.first.property.field
+        order_by = query.order.first.target.field
         order_by_sym = order_by.to_sym
         field_names = query.fields.collect {|f| f.field }
-        result = ldap.read_objects(query.model.treebase, 
-                                   query.model.key.collect { |k| k.field }, 
+        result = ldap.read_objects(query.model.treebase,
+                                   query.model.key.collect { |k| k.field },
                                    to_ldap_conditions(query),
-                                   field_names, order_by).sort! do |u1, u2|
-          value1 = u1[order_by_sym].first.upcase rescue ""
-          value2 = u2[order_by_sym].first.upcase rescue ""
-          value1 <=> value2
-        end
+                                   field_names, order_by)
+#.sort! do |u1, u2|
+#          value1 = u1[order_by_sym].first.upcase rescue ""
+#          value2 = u2[order_by_sym].first.upcase rescue ""
+#          value1 <=> value2
+#        end
         if query.model.multivalue_field
           props_result = []
           result.each do |props|
             # run over all values of the multivalue field
             (props[query.model.multivalue_field] || []).each do |value|
               values =  query.fields.collect do |f|
-                if query.model.multivalue_field == f.field.to_sym 
+                if query.model.multivalue_field == f.field.to_sym
                   value
-                else 
+                else
                   prop = props[f.field.to_sym].first
                   f.primitive == Integer ? prop.to_i : prop
                 end
               end
-              resource = query.model.load(values, query)
-              props_result << resource if filter_resource(resource, query.conditions)
+              props_result << values
             end
           end
           props_result
@@ -319,7 +354,7 @@ module DataMapper
           result.collect do |props|
             query.fields.collect do |f|
               prop = props[f.field.to_sym]
-              if f.type == DataMapper::Types::LdapArray
+              if f.class == Ldap::LdapArray
                 prop if prop
               elsif prop
                 f.primitive == Integer ? prop.first.to_i : prop.first
@@ -328,6 +363,8 @@ module DataMapper
           end
         end
       end
+
+#      include ::DataMapper::Transaction::Adapter
     end
   end
 end

data/lib/adapters/noop_transaction.rb

@@ -0,0 +1,16 @@
+require "dm-core"
+
+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
+  end
+end

data/lib/dummy_ldap_resource.rb

@@ -4,9 +4,9 @@ require 'ldap/digest'
 # dummy implementation which turns the extra ldap configuration noops
 module DataMapper
   module Resource
- 
+
     module ClassMethods
- 
+
       include ::Slf4r::Logger
 
       def ldap_properties(resource = nil, &block)
@@ -21,7 +21,7 @@ module DataMapper
           logger.debug { "ldap_properties=#{@ldap_properties.inspect}" }
         end
       end
-      
+
       def treebase(resource = nil, &block)
         if block
           @treebase = block
@@ -34,7 +34,7 @@ module DataMapper
           logger.debug { "treebase=#{@treebase}" }
         end
       end
-      
+
       def dn_prefix(resource = nil, &block)
         if block
           @dn_prefix = block
@@ -47,12 +47,12 @@ module DataMapper
           logger.debug { "dn_prefix=#{dn_prefix}" }
         end
       end
-      
+
       def multivalue_field(field = nil)
         logger.debug { "multivalue_field = #{field}" } if field
       end
     end
-    
+
     def authenticate(password)
       raise "NotImplemented"
     end

data/lib/ldap/array.rb

@@ -1,18 +1,102 @@
-module DataMapper
-  module Types
-    class LdapArray < DataMapper::Type
-      primitive Array
-      default Proc.new { Array.new }
+require 'dm-core'
+module Ldap
+  class Array < ::Array
 
-      def self.dump(value, property)
-        value || []
-      end
+    def initialize(resource, property,  *args)
+      setup(resource, property)
+      super(args)
+    end
+
+    def setup(resource, property)
+      @resource = resource
+      @property = property
+      self
+    end
+
+    alias :push! :push
+
+    def []=(k, v)
+      result = super
+      @resource.send("#{@property.name}=".to_sym, self)
+      result
+    end
+
+    
+    def <<(element)
+      push(element)
+    end
+
+    def push(element)
+      result = super
+      @resource.send("#{@property.name}=".to_sym, self)
+      result
+    end
+
+   alias :delete! :delete
+
+    def delete(element)
+      result = super
+      @resource.send(:"#{@property.name}=", self)
+      result
+    end
+  end
+
+  class LdapArray < ::DataMapper::Property::Text 
+    
+    default Proc.new { |r,p| Ldap::Array.new(r,p) }
+
+    def custom?
+      true
+    end
+
+    def primitive?(value)
+      super || value.kind_of?(::Array)
+    end
+
+    def load(value)
+      result = case value
+               when ::String then value.gsub(/^.|.$/,'').split('","').to_a.freeze
+               when ::Array then value.freeze
+               else
+                 []
+               end
+    end
+
+    def dump(value)
+      result = case value
+               when LdapArray then '"' + value.join('","') + '"'
+               when ::Array then '"' + value.join('","') + '"'
+               when ::String then '"' + value.to_s + '"'
+               else
+                 nil
+               end
+    end
 
-      def self.load(value, property)
-        value || []
-      end
+    def initialize(*args)
+      super
+      model.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{name.to_s}=(v)
+          case v
+          when Ldap::Array
+            v.setup(self, properties[:#{name}])
+          else
+            vv = Ldap::Array.new(self, properties[:#{name}])
+            vv.replace(v)
+          end
+          attribute_set(:#{name}, v)
+        end
 
+        def #{name.to_s}
+          v = attribute_get(:#{name})
+          case v
+          when Ldap::Array
+            v.setup(self, properties[:#{name}])
+          else
+            vv = Ldap::Array.new(self, properties[:#{name}])
+            vv.replace(v)
+          end
+        end
+      RUBY
     end
   end
-  Property::TYPES << Types::LdapArray unless Property::TYPES.member? Types::LdapArray 
 end