lom 0.9.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 383b6cdf0a55888e40558ca5b24f46a7f5e5d033f27fc873e4625c42b385c571
-  data.tar.gz: cef1eef2f7ee9b2b39118e9f54b2d15f1ba5d35518ed04e98cb09a047cbbb34e
+  metadata.gz: b3a1b6204446324ec92c63443efc8c9578db7628aa4544f42c435a1605ec05aa
+  data.tar.gz: 7fa61741e1c85db00a5ab168d2814afcc0a21ba0ba2a914649f7e8ef6f6df815
 SHA512:
-  metadata.gz: dd9eab41714ae145477e2756300b0041dd2d0a12f90485a3997e95266bbb121a33e8a3ed3660d8fd14e7372fd0cfa0fca6da6f800f61599a1c995da221b67b4f
-  data.tar.gz: f435226cb86088cfa48db588b105396b79fc0172eec4a967168b507dffb1039f201f6d7261d371edf63883c7fe519ca0d6167c649259f282a7d38e592ee929e1
+  metadata.gz: 468294c000324a795a2a3cb67de0436c492e4d08caffea7d14bbc47486b81640fb2c352df233771aefa1cc136e71a1dbcc98efe24c49c7b79d6952f824e1787d
+  data.tar.gz: 4add52468b4bb244a215dfa2ac32244417f3b282d615c19f2dcc30cc97601bd9c678180047da6de881bd9952f6423f3d5ac743d0d575dd80079f9d6ddb3e5432

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/converters.rb

@@ -10,25 +10,25 @@ module Converters
     #
     # Integer
     #
-    
+
     refine Integer do
         def to_ldap
             self.to_s
         end
     end
-    
+
     refine Integer.singleton_class do
         def from_ldap(v)
             Integer(v)
         end
     end
 
-    
+
 
     #
     # String
     #
-    
+
     refine String do
         def to_ldap
             self
@@ -41,15 +41,15 @@ module Converters
         end
     end
 
-    
+
 
     #
     # Date / Time
     #
-    
+
     refine Date do
         def to_ldap
-            self.to_time.to_ldap
+            self.strftime("%Y%m%d%H%M%SZ")
         end
     end
 
@@ -74,12 +74,12 @@ module Converters
         end
     end
 
-   
+
 
     #
     # Boolean
     #
-    
+
     refine TrueClass do
         def to_ldap
             'TRUE'
@@ -96,20 +96,20 @@ module Converters
         def to_ldap
             'FALSE'
         end
-    end        
+    end
+
 
 
-    
     #
     # Array / Set
     #
-    
+
     refine Set do
         def to_ldap
             self.to_a.to_ldap
         end
     end
-    
+
     refine Array do
         def to_ldap
             self.map { |val|

data/lib/lom/ldap/extensions.rb

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 
+require 'uri'
 require 'net/ldap'
 require 'net/ldap/dn'
 
@@ -188,7 +189,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?
@@ -55,6 +56,27 @@ module InstanceMethods
             lh.add(dn: dn, attributes: attrs)
         }
     end
+
+
+    # Delete object from ldap
+    #
+    # @return [true, false]
+    #
+    def delete!
+        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
+                          v = [   ] if     v.nil? 
+                          v = [ v ] unless v.is_a?(Array)
+                          v.to_ldap
+                     }
+        id, _  = Array(attrs[model.ldap_prefix])
+        raise MappingError, 'prefix for dn has multiple values' if _
+
+        model.delete!(id)
+    end
 end
 end
 
@@ -101,7 +123,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 +143,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 +181,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 +191,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 +208,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 +227,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 +280,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,21 +293,40 @@ 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)
+
+    # Fetch the requested entry.
+    #
+    # @param param [String]  entry name
+    #
+    # @raise [LOM::EntryNotFound] if entry not found
+    #
+    # @return [Object]
+    #
+    def fetch(name)
         dn    = ldap_dn_from_id(name)
         attrs = _ldap_attrs
         entry = lh.get(:dn => dn, :attributes => attrs)
@@ -260,8 +339,33 @@ module Mapper
         lh.delete(:dn => dn)
     end
 
+    # Get the requested entry.
+    # Same as #fetch but return nil if not found
+    #
+    # @param param [String]  entry name
+    #
+    # @return [nil] entry not found
+    # @return [Object]
+    #
+    def get(name)
+        fetch(name)
+    rescue LOM::EntryNotFound
+        nil
+    end
+
     alias [] get
 
+    # Test existence of entry
+    #
+    # @param param [String]  entry name
+    #
+    # @return [Boolean]
+    #
+    def exists?(name)
+        dn    = ldap_dn_from_id(name)
+        lh.get(:dn => dn, :return_result => false)
+    end
+
     private
     
     def _ldap_branch

data/lib/lom/version.rb

@@ -1,3 +1,3 @@
 class LOM
-    VERSION = '0.9.0'
+    VERSION = '0.11.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,13 @@
 --- !ruby/object:Gem::Specification
 name: lom
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.11.0
 platform: ruby
 authors:
 - Stéphane D'Alu
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-26 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: net-ldap
@@ -52,14 +51,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,11 +74,10 @@ 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: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -96,8 +92,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.8
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: LDAP Object Mapper
 test_files: []
+...