lom 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 383b6cdf0a55888e40558ca5b24f46a7f5e5d033f27fc873e4625c42b385c571
-  data.tar.gz: cef1eef2f7ee9b2b39118e9f54b2d15f1ba5d35518ed04e98cb09a047cbbb34e
+  metadata.gz: 6d37a56b9ef6c9dad3ae785439cb49560c641304fdb12f3d3d070541e8bf27b9
+  data.tar.gz: cd71e20fd089ab2b489bcdb2f857f508b8c283c0d4f2de875b81cfc722fab05b
 SHA512:
-  metadata.gz: dd9eab41714ae145477e2756300b0041dd2d0a12f90485a3997e95266bbb121a33e8a3ed3660d8fd14e7372fd0cfa0fca6da6f800f61599a1c995da221b67b4f
-  data.tar.gz: f435226cb86088cfa48db588b105396b79fc0172eec4a967168b507dffb1039f201f6d7261d371edf63883c7fe519ca0d6167c649259f282a7d38e592ee929e1
+  metadata.gz: 956540737ca9944e790aeead959ef079f61f8d9469b22867969858c993bd97897f742fd9ca43ef3b99110e76e81902474f88fd6a95e0bd216fee0b620ca5377e
+  data.tar.gz: 7340668aaeef6a7821e88d95bf5da772aedfcb4a3dce9ab89d858c08c2b4be9165e127f0c5871decce112edc06337ba0c7e611601d12b56a6cbfe5b52e490202

data/README.md

@@ -104,7 +104,13 @@ class User < Dry::Struct
         }
     end
     
+    ldap_list    :query,    ->(str) do
+        Filtered.match(:uid, str) |
+        Filtered.match(:cn,  str) |
+        Filtered.match(:givenName, str) | Filtered.match(:sn, str)
+    end
     
+
     #
     # Object structure
     #

data/lib/lom/filtered.rb

@@ -13,10 +13,19 @@ class Filtered
     NONE = Object.new.freeze
     ANY  = Object.new.freeze
 
-    def initialize(src, filter = nil, paged: nil)
-        @src      = src
-        @filter   = filter
-        @paged    = paged
+    class NoSource < Error
+    end
+
+    def initialize(filter = nil, src: nil, paged: nil)
+        if filter.is_a?(Filtered)
+            @filter   = filter.filter
+            @src      = src || filter.src
+            @paged    = paged || filter.paged
+        else
+            @filter   = filter
+            @src      = src
+            @paged    = paged
+        end
     end
     attr_reader :src, :filter, :paged
 
@@ -30,7 +39,7 @@ class Filtered
         _operator_2('&', o)
     end
 
-    # Take the negation of this fileter
+    # Take the negation of this filter
     def ~@
         _operator_1('!')
     end
@@ -51,24 +60,26 @@ class Filtered
     end
 
     # Iterate over matching data
-    def each(*args, &block)
-        @src.each(*args, filter: @filter, paged: self.paged, &block)
+    def each(*args, rawfilter: nil, &block)
+        raise NoSource if @src.nil?
+        @src.each(*args, filter: @filter, rawfilter: rawfilter,
+                  paged: self.paged, &block)
     end
 
     # Retrieve matching data as a list of object
     #
     # @return [Array<Object>]
     #
-    def all
-        each(:object).to_a
+    def all(&rawfilter)
+        each(:object, rawfilter: rawfilter).to_a
     end
 
     # Retrieve matching data as a list of id
     #
     # @return [Array<String>]
     #
-    def list
-        each(:id).to_a
+    def list(&rawfilter)
+        each(:id, rawfilter: rawfilter).to_a
     end
 
     # Escape (and convert) a value for correct processing.
@@ -89,20 +100,20 @@ class Filtered
 
     # Test if an attribute exists
     def self.exists(attr, predicate: true)
-        case predicate
-        when true,  nil   then   "(#{attr}=*)"
-        when false, :none then "(!(#{attr}=*))"
-        else raise ArgumentError
-        end
+        self.new(case predicate
+                 when true,  nil   then   "(#{attr}=*)"
+                 when false, :none then "(!(#{attr}=*))"
+                 else raise ArgumentError
+                 end)
     end
 
     # Test if an attribute is of the specified value
     def self.is(attr, val, predicate: true)
-        case predicate
-        when true,  nil then   "(#{attr}=#{escape(val)})"
-        when false      then "(!(#{attr}=#{escape(val)}))"
-        else raise ArgumentError
-        end
+        self.new(case predicate
+                 when true,  nil then   "(#{attr}=#{escape(val)})"
+                 when false      then "(!(#{attr}=#{escape(val)}))"
+                 else raise ArgumentError
+                 end)
     end
 
     # Test if an attribute has the specified value.
@@ -110,11 +121,20 @@ class Filtered
     def self.has(attr, val)
         val = yield(val) if block_given?
 
-        case val
-        when ANY  then   "(#{attr}=*)"
-        when NONE then "(!(#{attr}=*))"
-        else             "(#{attr}=#{escape(val)})"
-        end
+        self.new(case val
+                 when ANY  then   "(#{attr}=*)"
+                 when NONE then "(!(#{attr}=*))"
+                 else             "(#{attr}=#{escape(val)})"
+                 end)
+    end
+
+    # Test if an attribute match the specified value
+    def self.match(attr, val, predicate: true)
+        self.new(case predicate
+                 when true,  nil then   "(#{attr}=*#{escape(val)}*)"
+                 when false      then "(!(#{attr}=*#{escape(val)}*))"
+                 else raise ArgumentError
+                 end)
     end
 
     # Test if an attribute as a time before the specified timestamp
@@ -122,7 +142,7 @@ class Filtered
     def self.before(attr, ts, predicate: true)
         ts = Date.today + ts if ts.kind_of?(Integer)
         ts = LOM.to_ldap_time(ts)       
-        "(#{attr}<=#{ts})".then {|f| predicate ? f : "(!#{f})" }
+        self.new("(#{attr}<=#{ts})".then {|f| predicate ? f : "(!#{f})" })
     end
 
     # Test if an attribute as a time after the specified timestamp
@@ -130,40 +150,40 @@ class Filtered
     def self.after(attr, ts, predicate: true)
         ts = Date.today - ts if ts.kind_of?(Integer)
         ts = LOM.to_ldap_time(ts)
-        "(#{attr}>=#{ts})".then {|f| predicate ? f : "(!#{f})" }
+        self.new("(#{attr}>=#{ts})".then {|f| predicate ? f : "(!#{f})" })
     end
 
     private
 
     # Operation with 2 elements
     def _operator_2(op, o)
-        if @src != o.src
+        if !@src.nil? && !o.src.nil? && @src != o.src
             raise ArgumentError, 'filter defined with different sources'
         end
         _filter = if !@filter.nil? && !o.filter.nil?
                   then Net::LDAP.filter(op, @filter, o.filter)
                   else @filter || o.filter
                   end
-        Filtered.new(@src, _filter, paged: o.paged || self.paged)
+        Filtered.new(_filter, src: @src || o.src, paged: o.paged || self.paged)
     end
 
     # Operation with 1 element
     def _operator_1(op)
-        Filtered.new(@src, Net::LDAP.filter(op, @filter),
+        Filtered.new(Net::LDAP.filter(op, @filter), src: @src,
                      paged: self.paged)
     end
 
     # Check if an ldap_list has been defined with that name
     def respond_to_missing?(method_name, include_private = false)
+        return super if @src.nil?
         @src.ldap_listing.include?(method_name) || super
     end
     
     # Call the ldap_list defined with that name
     def method_missing(method_name, *args, &block)
-        if @src.ldap_listing.include?(method_name)
-            self & @src.send(method_name, *args, &block)
-        else
-            super
+        if @src&.ldap_listing.include?(method_name)
+        then self & @src.send(method_name, *args, &block)
+        else super
         end        
     end
     

data/lib/lom/ldap/extensions.rb

@@ -188,7 +188,7 @@ module Extensions
             if LOM.debug.include?(:dry)
                 return true
             end
-            return true if op.empty?                # That's a no-op
+            return true if ops.empty?               # That's a no-op
             modify(:dn => dn, :operations => ops)   # Apply modifications
         end       
     end

data/lib/lom/mapper.rb

@@ -37,7 +37,8 @@ module InstanceMethods
     # @return [true, false]
     #
     def save!
-        attrs  = instance_exec(self, &self.class._ldap_to)
+        model  = self.class
+        attrs  = instance_exec(self, &model.ldap_to)
                      .transform_values {|v|
                           # Don't use Array(), not what you think on
                           # some classes such as Time
@@ -45,9 +46,9 @@ module InstanceMethods
                           v = [ v ] unless v.is_a?(Array)
                           v.to_ldap
                      }
-        id, _  = Array(attrs[self.class._ldap_prefix])
+        id, _  = Array(attrs[model.ldap_prefix])
         raise MappingError, 'prefix for dn has multiple values' if _
-        dn     = self.class.ldap_dn_from_id(id)
+        dn     = model.ldap_dn_from_id(id)
         
         lh.update(dn: dn, attributes: attrs).then {|res|
             break res unless res.nil?
@@ -101,7 +102,10 @@ module Mapper
         @__ldap_lh = lh
     end
         
-
+    # Return the list of defined list (using ldap_list).
+    #
+    # @return [Array<Symbol>] list of defined ldap list
+    #
     def ldap_listing
         @__ldap_list
     end
@@ -118,16 +122,18 @@ module Mapper
         @__ldap_list << name
         define_singleton_method(name) do |*args|
             filter = body.call(*args)
-            LOM::Filtered.new(self, filter)
+            LOM::Filtered.new(filter, src: self)
         end
     end
 
     
-    def ldap_branch(v)
+    def ldap_branch(v = nil)
+        return _ldap_branch if v.nil?
         @__ldap_branch = v
     end
     
-    def ldap_prefix(v)
+    def ldap_prefix(v = nil)
+        return _ldap_prefix if v.nil?
         @__ldap_prefix = v
     end
     
@@ -154,6 +160,8 @@ module Mapper
 
     # @note block will be executed in the mapped object instance
     def ldap_to(p=nil, &b)
+        return _ldap_to if p.nil? && b.nil?
+
         if (! p.nil? ^ b.nil?) || (p && !p.kind_of?(Proc))
             raise ArgumentError,
                   'one and only one of proc/lamba/block need to be defined'
@@ -162,7 +170,15 @@ module Mapper
     end
 
 
-    
+    # Convert a dn to it's corresponding id the current mapping.
+    #
+    # @raise [Error]   dn belongs to this mapping (it is in the mapping
+    #                  branch), but is malformed (not a direct child, or
+    #                  wrong prefix)
+    #
+    # @return [String] id
+    # @return [nil]    dn is not from this mapping
+    #
     def ldap_dn_to_id(dn)
         prefix = _ldap_prefix.to_s
         branch = _ldap_branch
@@ -171,8 +187,8 @@ module Mapper
             case prefix
             when String, Symbol
                 k, v, _ = sub.to_a
-                raise ArgumentError, "not a direct child" if _
-                raise ArgumentError, "wrong prefix"       if k.casecmp(prefix) != 0
+                raise Error, "not a direct child" if _
+                raise Error, "wrong prefix"       if k.casecmp(prefix) != 0
                 v
             end
         end
@@ -190,24 +206,45 @@ module Mapper
         self.new(*args)
     end
     
-    
-    def each(type = :object, filter: nil, paged: nil)
+
+    # Iterate over matching data.
+    #
+    # @note If using `rawfilter`, no optimization will be performed
+    #       aned the ldap attributes will be retrieved,
+    #       even if desired type is :id
+    #
+    # @param type      [:object, :id]           return object or id
+    # @param filter    [String]                 extra ldap search filter
+    # @param rawfilter [Proc]                   filter on ldap entry
+    # @param paged     [Array<Integer,Integer>] pagination information
+    #
+    # @yieldparam obj_or_id [Object, String] ldap converted element according to type
+    #
+    # @return [Enumerator] if no block given
+    # @return [self]       if block given
+    #
+    def each(type = :object, filter: nil, rawfilter: nil, paged: nil)
         # Create Enumerator if no block given
         unless block_given?
-            return enum_for(:each, type, filter: filter, paged: paged)
+            return enum_for(:each, type,
+                            filter: filter, rawfilter: rawfilter, paged: paged)
         end
 
         # Merging filters
-        filters = [ filter, _ldap_filter ].compact
-        filter  = filters.size == 2 ? "(&#{filters.join})" : filters.first
+        filter  = Net::LDAP.filter('&', *[ filter, _ldap_filter ].compact)
 
         # Define attributes/converter according to selected type
         attributes, converter =
             case type
-            when :id     then [ :dn,         ->(e) { ldap_dn_to_id(e.dn) } ]
-            when :object then [ _ldap_attrs, ->(e) { _ldap_to_obj(e)     } ]
+            when :id     then [ rawfilter ? _ldap_attrs : :dn,
+                                ->(e) { ldap_dn_to_id(e.dn) }
+                              ]
+            when :object then [ _ldap_attrs,
+                                ->(e) { _ldap_to_obj(e)     }
+                              ]
             else raise ArgumentError, 'type must be either :object or :id'
             end
+
         
         # Paginate
         # XXX: pagination is emulated, should be avoided
@@ -222,7 +259,9 @@ module Mapper
                   :attributes => attributes,
                   :scope      => _ldap_scope) {|entry|
 
-            if paged.nil?
+            if rawfilter && !rawfilter.call(entry)
+                next
+            elsif paged.nil?
                 yield(converter.(entry))
             elsif skip > 0
                 skip -= 1
@@ -233,18 +272,29 @@ module Mapper
                 yield(converter.(entry))
             end                
         }
+
+        # Return self
+        self
     end
 
     def paginate(page, page_size)
-        LOM::Filtered.new(self, paged: [ page, page_size ])
+        LOM::Filtered.new(src: self, paged: [ page, page_size ])
     end
   
-    def all
-        each(:object).to_a
+    # Retrieve matching data as a list of object
+    #
+    # @return [Array<Object>]
+    #
+    def all(&rawfilter)
+        each(:object, rawfilter: rawfilter).to_a
     end
 
-    def list
-        each(:id).to_a
+    # Retrieve matching data as a list of id
+    #
+    # @return [Array<String>]
+    #
+    def list(&rawfilter)
+        each(:id, rawfilter: rawfilter).to_a
     end
     
     def get(name)

data/lib/lom/version.rb

@@ -1,3 +1,3 @@
 class LOM
-    VERSION = '0.9.0'
+    VERSION = '0.10.0'
 end

data/lom.gemspec

@@ -8,15 +8,13 @@ Gem::Specification.new do |s|
     s.summary     = "LDAP Object Mapper"
     s.description =  <<~EOF
       
-      Ease processing of parameters in Sinatra framework.
-      Integrates well with dry-types, sequel, ...
+      Creation of mapping between ldap entry and ruby object.
+      Allowing easy retrieval of information, building of search filter,
+      and updating ldap.
 
-      Example:
-        want! :user,    Dry::Types::String, User
-        want? :expired, Dry::Types::Params::Bool.default(true)
       EOF
 
-    s.homepage    = 'https://gitlab.com/sdalu/lom'
+    s.homepage    = 'https://github.com/sdalu/lom'
     s.license     = 'MIT'
 
     s.authors     = [ "Stéphane D'Alu" ]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lom
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Stéphane D'Alu
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-26 00:00:00.000000000 Z
+date: 2021-06-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: net-ldap
@@ -52,14 +52,12 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '13'
-description: |2
+description: |2+
 
-  Ease processing of parameters in Sinatra framework.
-  Integrates well with dry-types, sequel, ...
+  Creation of mapping between ldap entry and ruby object.
+  Allowing easy retrieval of information, building of search filter,
+  and updating ldap.
 
-  Example:
-    want! :user,    Dry::Types::String, User
-    want? :expired, Dry::Types::Params::Bool.default(true)
 email:
 - stephane.dalu@insa-lyon.fr
 executables: []
@@ -77,7 +75,7 @@ files:
 - lib/lom/mapper.rb
 - lib/lom/version.rb
 - lom.gemspec
-homepage: https://gitlab.com/sdalu/lom
+homepage: https://github.com/sdalu/lom
 licenses:
 - MIT
 metadata: {}
@@ -101,3 +99,4 @@ signing_key:
 specification_version: 4
 summary: LDAP Object Mapper
 test_files: []
+...