Module: LOM::Mapper

Defined in:
lib/lom/mapper.rb,
lib/lom/mapper.rb

Overview

Class methods to be injected in the class being mapped, and performs initialization thanks to #extend_object

Defined Under Namespace

Modules: InstanceMethods

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.extend_object(o) ⇒ Object 



67
68
69
70
71
72
73
 
# File 'lib/lom/mapper.rb', line 67

def self.extend_object(o)
    super
    o.include Mapper::InstanceMethods
    o.extend  Enumerable
    o.const_set(:Filtered, LOM::Filtered)
    o.__ldap_init
end

Instance Method Details

#__ldap_init ⇒ Object 



75
76
77
78
79
80
81
82
83
84
85
 
# File 'lib/lom/mapper.rb', line 75

def __ldap_init
    @__ldap_branch    = nil
    @__ldap_prefix    = nil
    @__ldap_scope     = :one
    @__ldap_filter    = nil
    @__ldap_attrs     = nil
    @__ldap_from      = nil
    @__ldap_to        = nil
    @__ldap_list      = []
    @__ldap_lh        = nil
end

#_ldap_to_obj(entry) ⇒ Object

Raises:



185
186
187
188
189
190
191
 
# File 'lib/lom/mapper.rb', line 185

def _ldap_to_obj(entry)
    raise EntryNotFound if entry.nil?
    entry.extend(EntryEnhanced)       
    args  = entry.instance_exec(entry, &_ldap_from)
    args  = [ args ] unless args.kind_of?(Array)
    self.new(*args)
end

#all ⇒ Object 



242
243
244
 
# File 'lib/lom/mapper.rb', line 242

def all
    each(:object).to_a
end

#delete!(name) ⇒ Object 



258
259
260
261
 
# File 'lib/lom/mapper.rb', line 258

def delete!(name)
    dn    = ldap_dn_from_id(name)
    lh.delete(:dn => dn)
end

#each(type = :object, filter: nil, paged: nil) ⇒ Object 



194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
 
# File 'lib/lom/mapper.rb', line 194

def each(type = :object, filter: nil, paged: nil)
    # Create Enumerator if no block given
    unless block_given?
        return enum_for(:each, type, filter: filter, paged: paged)
    end

    # Merging filters
    filters = [ filter, _ldap_filter ].compact
    filter  = filters.size == 2 ? "(&#{filters.join})" : filters.first

    # 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)     } ]
        else raise ArgumentError, 'type must be either :object or :id'
        end
    
    # Paginate
    # XXX: pagination is emulated, should be avoided
    skip, count = if paged
                      page, page_size = paged
                      [ (page - 1) * page_size, page_size ]
                  end
    
    # Perform search
    lh.search(:base       => _ldap_branch,
              :filter     => filter,
              :attributes => attributes,
              :scope      => _ldap_scope) {|entry|

        if paged.nil?
            yield(converter.(entry))
        elsif skip > 0
            skip -= 1
        elsif count <= 0
            break
        else
            count -= 1
            yield(converter.(entry))
        end                
    }
end

#get(name) ⇒ Object Also known as: [] 



250
251
252
253
254
255
256
 
# File 'lib/lom/mapper.rb', line 250

def get(name)
    dn    = ldap_dn_from_id(name)
    attrs = _ldap_attrs
    entry = lh.get(:dn => dn, :attributes => attrs)

    _ldap_to_obj(entry)
end

#ldap_attrs(*v) ⇒ Object 



142
143
144
 
# File 'lib/lom/mapper.rb', line 142

def ldap_attrs(*v)
    @__ldap_attrs = v
end

#ldap_branch(v) ⇒ Object 



126
127
128
 
# File 'lib/lom/mapper.rb', line 126

def ldap_branch(v)
    @__ldap_branch = v
end

#ldap_dn_from_id(id) ⇒ Object 



181
182
183
 
# File 'lib/lom/mapper.rb', line 181

def ldap_dn_from_id(id)
    Net::LDAP::DN.new(_ldap_prefix.to_s, id, _ldap_branch).to_s
end

#ldap_dn_to_id(dn) ⇒ Object 



166
167
168
169
170
171
172
173
174
175
176
177
178
179
 
# File 'lib/lom/mapper.rb', line 166

def ldap_dn_to_id(dn)
    prefix = _ldap_prefix.to_s
    branch = _ldap_branch
    
    if sub = Net::LDAP::DN.sub?(dn, branch)
        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
            v
        end
    end
end

#ldap_filter(v) ⇒ Object 



138
139
140
 
# File 'lib/lom/mapper.rb', line 138

def ldap_filter(v)
    @__ldap_filter = v[0] == '(' ? v : "(#{v})"
end

#ldap_from(p = nil, &b) ⇒ Object

Note:

block will be executed in the Net::LDAP::Entry instance



147
148
149
150
151
152
153
 
# File 'lib/lom/mapper.rb', line 147

def ldap_from(p=nil, &b)
    if (! p.nil? ^ b.nil?) || (p && !p.kind_of?(Proc))
        raise ArgumentError,
              'one and only one of proc/lamba/block need to be defined'
    end
    @__ldap_from = p || b
end

#ldap_list(name, body = nil, &block) ⇒ Object 



109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
 
# File 'lib/lom/mapper.rb', line 109

def ldap_list(name, body=nil, &block)
    if body && block
        raise ArgumentError
    elsif body.nil? && block.nil?
        raise ArgumentError
    elsif block
        body = block
    end
        
    @__ldap_list << name
    define_singleton_method(name) do |*args|
        filter = body.call(*args)
        LOM::Filtered.new(self, filter)
    end
end

#ldap_listing ⇒ Object 



105
106
107
 
# File 'lib/lom/mapper.rb', line 105

def ldap_listing
    @__ldap_list
end

#ldap_prefix(v) ⇒ Object 



130
131
132
 
# File 'lib/lom/mapper.rb', line 130

def ldap_prefix(v)
    @__ldap_prefix = v
end

#ldap_scope(v) ⇒ Object 



134
135
136
 
# File 'lib/lom/mapper.rb', line 134

def ldap_scope(v)
    @__ldap_scope = v
end

#ldap_to(p = nil, &b) ⇒ Object

Note:

block will be executed in the mapped object instance



156
157
158
159
160
161
162
 
# File 'lib/lom/mapper.rb', line 156

def ldap_to(p=nil, &b)
    if (! p.nil? ^ b.nil?) || (p && !p.kind_of?(Proc))
        raise ArgumentError,
              'one and only one of proc/lamba/block need to be defined'
    end
    @__ldap_to = p || b
end

#lh ⇒ Object

Get the LDAP handler to use

In order of preference:

  • the handler set using lh=

  • the LH constant in this scope or parent scope

  • the one provided by LOM.lh



95
96
97
 
# File 'lib/lom/mapper.rb', line 95

def lh
    @__ldap_lh || const_get(:LH) || LOM.lh
end

#lh=(lh) ⇒ Object

Set the LDAP handler to use



100
101
102
 
# File 'lib/lom/mapper.rb', line 100

def lh=(lh)
    @__ldap_lh = lh
end

#list ⇒ Object 



246
247
248
 
# File 'lib/lom/mapper.rb', line 246

def list
    each(:id).to_a
end

#paginate(page, page_size) ⇒ Object 



238
239
240
 
# File 'lib/lom/mapper.rb', line 238

def paginate(page, page_size)
    LOM::Filtered.new(self, paged: [ page, page_size ])
end