ldif_parser 0.5.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 86f7b2757e53b3856dee02c28b75d3007ee67efcb016ad6186392d1b286a9015
-  data.tar.gz: 9e34979e64fbd4c6ba5ea5e08762941c4b136825312a9746d4ee4521cd46b381
+  metadata.gz: 39d7e193974194956a141adaad500d69571ba7932d6ae08d73d58f8d7d770f52
+  data.tar.gz: 6c364a27f19e583a6032e3d97f16df493b9e4f89c60fed724702ac29f3f63ab6
 SHA512:
-  metadata.gz: 48ab36890e5d8aaa380d809f3f1e8a812f46fc5f01a455c926a21ee4de6746ed17f5c6d37b4649f35170abf46eee798973c0424d27fc6d585ddf6d6b6f39d4fe
-  data.tar.gz: 04fc17e10e1d27487d228d96307acece582f74cb86cdd9ba1159a3c68f026146af5d9ff0beb2f3ff0ef6911be5e09e287881d2475686cbc5c8c064402d805667
+  metadata.gz: dde3733aaa120fadffb2fd28f47459a5997d4e5e7295b5664dd6a986a2d18ad3d34d7609f4436c276d6b217abe6b480b4fdb5fed50a79cdac7f3d797adcc7db2
+  data.tar.gz: 3197b571025c9121f6e8c1d4fd989711156de14c408577cde9a585f400f0926dd7b84f45a9cb5c486829f975941de0de13bd3318ff63845b54b912578611bd22

data/Gemfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+ruby '>= 3.1'
+
+group :development do
+  gem 'benchmark-ips'
+  gem 'rubocop'
+end

data/README.md

@@ -5,10 +5,8 @@
 require 'ldif_parser'
 
 ldif_path = '/tmp/ldap.bak'
-result = LdifParser.parse_file(ldif_path, only: %w[displayName givenName sn mail])
-
-result.each do |res|
-  p res
+LdifParser.open(ldif_path, only: %w[displayName givenName sn mail]).each do |entry|
+  p entry
 end
 ```
 
@@ -20,9 +18,7 @@ $ gem install ldif_parser
 
 ## Usage
 
-In the example `result` is an `Array[Hash[Symbol, Array[String]]]`.
-
-Each entry has default a default `Array` value.
+Use `each` method to iterate on each ldif entries and do what you want.
 
 If the ldif file is too large, you can optimize the processing of the file with the `only` and `except` options.
 
@@ -32,4 +28,16 @@ These options allow you to limit the number of lines in the ldif file that will
 
 - minimized: minimize has string all array with only one value
 - only: captures only the specified ldap attributes
-- except: ignore the specified ldap attributes
+- except: ignore the specified ldap attributes
+
+## Speed test
+
+````bash
+$ time ruby test/speed.rb 
+ruby -v => 3.1.6p260
+wc -l $path => 1000000
+
+real    0m4,562s
+user    0m4,457s
+sys     0m0,091s
+````

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/lib/entries_maker.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative 'entry_maker'
+require 'base64'
+
+class LdifParser
+  class EntriesMaker
+    R_INPUT_ENTRIES_SEPARATOR = /^\s*$/
+
+    class << self
+      def parse(input, options = {})
+        content = []
+
+        next until input.eof? || (line = input.readline).match(R_INPUT_ENTRIES_SEPARATOR)
+
+        return if !line || line.empty?
+
+        until input.eof? || (line = input.readline).match(R_INPUT_ENTRIES_SEPARATOR)
+          line.chomp!
+          content << line
+        end
+
+        input.seek(-line.length, IO::SEEK_CUR) if !input.eof? && line
+
+        EntryMaker.new(content.join("\n"), **options).make
+      end
+    end
+  end
+end

data/lib/entry.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class LdifParser
+  class Entry < Hash
+    def dn
+      return @dn if defined?(@dn)
+
+      @dn = self[:dn]
+    end
+
+    def get(key)
+      self[key.to_s.downcase.to_sym]
+    end
+  end
+end

data/lib/entry_maker.rb

@@ -1,55 +1,44 @@
 # frozen_string_literal: true
 
-require_relative 'hash_insensitive'
+require_relative 'entry'
 require 'base64'
 
 class LdifParser
   class EntryMaker
-    R_LINE_SPLIT = /(\w+)(:+)\s*(.*)/.freeze
+    R_LINE_SPLIT = /(\w+)(:+)\s*(.*)/
     BASE64_SEPARATOR = '::'
 
-    class << self
-      def call(str)
-        new(str).make
-      end
-
-      def call_minimized(str)
-        new(str).make_minimized
-      end
-    end
-
-    def initialize(str)
+    def initialize(str, minimized: false, only_regexp: nil, except_regexp: nil)
       @str = str
       @str.gsub!(/\n\s+/, '')
       @str.gsub!(/\n+$/, '')
+
+      @minimized = minimized
+      @only_regexp = only_regexp
+      @except_regexp = except_regexp
     end
 
     def make
       hash = lines_decoded_to_h
-      hash.extend(HashInsensitive)
-      hash.default = []
-      hash
-    end
+      hash[:dn] = hash[:dn].first
 
-    def make_minimized
-      make.transform_values do |v|
-        v.length == 1 ? v.first : v
+      if @minimized
+        hash.transform_values! do |v|
+          v.length == 1 ? v.first : v
+        end
       end
+
+      hash
     end
 
     private
 
     def lines_decoded_to_h
-      lines_decoded.each_with_object({}) do |(k, v), h|
-        init_hash(h, k)
-        h[k].push(v)
+      lines_decoded.each_with_object(Entry.new) do |(k, v), h|
+        (h[k] ||= []) << v
       end
     end
 
-    def init_hash(h, k)
-      h[k] ||= []
-    end
-
     def lines_decoded
       lines.map do |line|
         line_decoder(line)
@@ -57,15 +46,20 @@ class LdifParser
     end
 
     def line_decoder(line)
-      parts = line.scan(R_LINE_SPLIT).first
-      parts[0] = parts[0].to_sym
-      parts[2] = Base64.decode64(parts[2]).force_encoding('UTF-8') if parts[1] == BASE64_SEPARATOR
-      parts.delete_at(1)
-      parts
+      key, separator, value = line.scan(R_LINE_SPLIT).first
+
+      if separator == BASE64_SEPARATOR
+        [key.to_sym, Base64.decode64(value).force_encoding('UTF-8')]
+      else
+        [key.to_sym, value]
+      end
     end
 
     def lines
-      @str.split(/\n/)
+      arr = @str.split(/\n/)
+      arr.select! { |line| line.match?(@only_regexp) } unless @only_regexp.nil?
+      arr.reject! { |line| line.match?(@except_regexp) } unless @except_regexp.nil?
+      arr
     end
   end
 end

data/lib/ldif_parser.rb

@@ -1,95 +1,94 @@
 # frozen_string_literal: true
 
-require_relative 'entry_maker'
+require_relative 'entries_maker'
 require_relative 'version'
+require 'stringio'
 
 class LdifParser
-  NEW_LDIF_OBJECT_PATTERN = 'dn'
-  SPACE = ' '
-  DOUBLE_POINT = ':'
-
   class << self
-    def parse_file(ldif_path, minimized: false, only: [], except: [])
-      parse(IO.read(ldif_path), minimized: minimized, only: only, except: except)
+    def open(path, minimized: false, only: [], except: [])
+      options = {
+        minimized: minimized,
+        only_regexp: build_regexp(only),
+        except_regexp: build_regexp(except)
+      }.freeze
+
+      input = File.open(File.expand_path(path))
+
+      new(input, options).tap do |parser|
+        if block_given?
+          yield parser
+
+          parser.close
+        else
+          ObjectSpace.define_finalizer parser, finalizer(input)
+        end
+      end
     end
 
-    def parse(str, minimized: false, only: [], except: [])
-      included_pattern(only)
-      excluded_pattern(except)
-      parser = new(str)
-      minimized ? parser.parse_minimized! : parser.parse!
-    end
+    private
 
-    def included_pattern(patterns)
-      @included_patterns = patterns.map(&:downcase)
-    end
+    def build_regexp(keys)
+      return nil if keys.empty?
 
-    def excluded_pattern(patterns)
-      @excluded_patterns = patterns.map(&:downcase)
+      or_map = keys.map { |key| "#{key}:" }
+      Regexp.new("^(#{or_map.join('|')})", Regexp::IGNORECASE)
     end
 
-    attr_reader :included_patterns, :excluded_patterns
+    def finalizer(io)
+      proc { io.close }
+    end
   end
 
-  def initialize(str)
-    @str = str
-  end
+  attr_reader :input
 
-  def parse!
-    str_parts.map do |str|
-      EntryMaker.call(str)
-    end
-  end
+  def initialize(what, options = {})
+    @input = if what.respond_to? :to_io
+               what.to_io
+             elsif what.is_a? String
+               StringIO.new(what)
+             else
+               raise ArgumentError, 'I do not know what to do.'
+             end
 
-  def parse_minimized!
-    str_parts.map do |str|
-      EntryMaker.call_minimized(str)
-    end
+    @options = options
   end
 
-  def str_parts
-    parts = []
-    str = ''.dup
-    previous_key = nil
-
-    @str.each_line do |line|
-      line_key = get_line_key(line, previous_key)
-      next if line_key.nil?
+  def close
+    @input.close
+  end
 
-      if line_has_to_be_excluded?(line_key)
-        previous_key = line_key
-        next
-      end
+  def lock
+    @input.flock File::LOCK_SH if @input.respond_to? :flock
 
-      if new_ldif_object?(line_key, str, line)
-        parts << str
-        str = ''.dup
-      end
+    return unless block_given?
 
-      str << line
-      previous_key = line_key
+    begin
+      yield self
+    ensure
+      unlock
     end
-
-    parts << str
-
-    @str = nil
-
-    parts
   end
 
-  def new_ldif_object?(line_key, str, line)
-    line_key == NEW_LDIF_OBJECT_PATTERN && !str.empty? && !line.start_with?(SPACE)
+  def unlock
+    return unless @input.respond_to? :flock
+
+    @input.flock File::LOCK_UN
   end
 
-  def get_line_key(line, previous_key)
-    return previous_key if line.start_with?(SPACE)
+  def each(&block)
+    @input.seek 0
 
-    line.split(DOUBLE_POINT).first&.downcase || previous_key
+    lock do
+      each_no_lock(&block)
+    end
   end
 
-  def line_has_to_be_excluded?(line_key)
-    return false if line_key == NEW_LDIF_OBJECT_PATTERN
+  private
 
-    self.class.excluded_patterns.include?(line_key) || (!self.class.included_patterns.empty? && !self.class.included_patterns.include?(line_key))
+  def each_no_lock
+    while (entry = EntriesMaker.parse(@input, @options))
+      yield entry
+    end
   end
 end

data/lib/version.rb

@@ -1,15 +1,10 @@
 # frozen_string_literal: true
 
 class LdifParser
-  def self.gem_version
-    Gem::Version.new VERSION::STRING
-  end
-
-  module VERSION
-    MAJOR = 0
-    MINOR = 5
-    TINY  = 0
-
-    STRING = [MAJOR, MINOR, TINY].compact.join('.')
+  class << self
+    def version
+      File.read(File.expand_path('../VERSION', __dir__)).strip
+    end
+    alias gem_version version
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ldif_parser
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Maxime Désécot
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-10-17 00:00:00.000000000 Z
+date: 2025-03-02 00:00:00.000000000 Z
 dependencies: []
 description: Simple class to parse ldif file
 email:
@@ -17,17 +17,18 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- Gemfile
 - LICENSE
 - README.md
+- VERSION
+- lib/entries_maker.rb
+- lib/entry.rb
 - lib/entry_maker.rb
-- lib/hash_insensitive.rb
 - lib/ldif_parser.rb
 - lib/version.rb
-- sig/entry_maker.rbs
-- sig/ldif_parser.rbs
 homepage: https://github.com/RaoH37/ldif_parser
 licenses:
-- GPL-3.0
+- GPL-3.0-only
 metadata:
   homepage_uri: https://github.com/RaoH37/ldif_parser
   source_code_uri: https://github.com/RaoH37/ldif_parser
@@ -40,14 +41,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.7'
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.8.11
 requirements: []
-rubygems_version: 3.4.19
+rubygems_version: 3.3.27
 signing_key:
 specification_version: 4
 summary: LDIF parser

data/lib/hash_insensitive.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module HashInsensitive
-  def dn
-    @dn ||= self['dn'].first
-  end
-
-  def insensitive_origin_keys
-    keys.select { |key| key.respond_to?(:to_s) }
-  end
-
-  def insensitive_keys
-    insensitive_origin_keys.map(&:to_s).map(&:downcase)
-  end
-
-  def default=(obj)
-    @default = obj
-  end
-
-  def default(key)
-    return @default unless key.respond_to?(:to_s)
-
-    tmp_key = key.to_s.downcase
-    tmp_index = insensitive_keys.index(tmp_key)
-    return @default if tmp_index.nil?
-
-    insensitive_origin_key = insensitive_origin_keys.at(tmp_index)
-
-    self[insensitive_origin_key]
-  end
-end

data/sig/entry_maker.rbs

@@ -1,14 +0,0 @@
-class LdifParser
-  class EntryMaker
-    def self.call: (String str) -> Hash[Symbol, Array[String]]
-    def self.call_minimized: (String str) -> Hash[Symbol, (String | Array[String])]
-
-    def initialize: (String str) -> void
-    def make: -> Hash[Symbol, Array[String]]
-    def make_minimized: -> Hash[Symbol, String | Array[String]]
-    def lines_decoded_to_h: -> Hash[Symbol, Array[String]]
-    def lines_decoded: -> Array[Array[String]]
-    def line_decoder: (String line) -> Array[String]
-    def lines: -> Array[String]
-  end
-end

data/sig/ldif_parser.rbs

@@ -1,13 +0,0 @@
-class LdifParser
-  def self.parse_file: (String ldif_path, minimized: bool, only: Array[String], except: Array[String]) -> Array[Hash[Symbol, (String | Array[String])]]
-  def self.parse: (String str, minimized: bool, only: Array[String], except: Array[String]) -> Array[Hash[Symbol, (String | Array[String])]]
-  def self.included_pattern: (Array[String] patterns) -> Array[String]
-  def self.excluded_pattern: (Array[String] patterns) -> Array[String]
-  attr_reader included_patterns: Array[String]
-  attr_reader excluded_patterns: Array[String]
-
-  def initialize: (String str) -> void
-  def parse!: -> Array[Hash[Symbol, (String | Array[String])]]
-  def str_parts: -> Array[String]
-  def line_has_to_be_excluded?: (String line) -> (bool)
-end