lingo 1.8.1 → 1.8.2

data/lib/lingo/database/source/single_word.rb

@@ -38,17 +38,15 @@ class Lingo
 
         def initialize(id, lingo)
           super
-
-          @wc     = @config.fetch('def-wc',     's').downcase
-          @mul_wc = @config.fetch('def-mul-wc', @wc).downcase
-
-          @line_pattern = %r{^(#{@legal_word})$}
+          @pat = /^(#{@wrd})$/
+          @def = @config.fetch('def-wc',     's').downcase
+          @mul = @config.fetch('def-mul-wc', @def).downcase
         end
 
         private
 
         def convert_line(line, key, val)
-          [key = key.strip, %W[##{key =~ /\s/ ? @mul_wc : @wc}]]
+          [key = key.strip, %W[##{key =~ /\s/ ? @mul : @def}]]
         end
 
       end

data/lib/lingo/database/source/word_class.rb

@@ -38,21 +38,15 @@ class Lingo
 
         def initialize(id, lingo)
           super
-
-          @separator = @config.fetch('separator', ',')
-          @line_pattern = Regexp.new('^(' + @legal_word + ')' + Regexp.escape(@separator) + '((?:' + @legal_word + '#\w)+)$')
+          @pat = /^(#{@wrd})#{Regexp.escape(@sep ||= ',')}((?:#{@wrd}#\w)+)$/
         end
 
         private
 
         def convert_line(line, key, val)
-          key, valstr = key.strip, val.strip
-          val = valstr.gsub(/\s+#/, '#').scan(/\S.+?\s*#\w/)
-          val = val.map do |str|
-            str =~ /^(.+)#(.)/
-            ($1 == key ? '' : $1) + '#' + $2
-          end
-          [key, val]
+          [key = key.strip, val.strip.scan(/(\S.+?)\s*#(\w)/).map! { |v, c|
+            "#{v unless key == v}##{c}"
+          }]
         end
 
       end

data/lib/lingo/database/source.rb

@@ -63,52 +63,54 @@ class Lingo
       UTF8_CHAR   = "#{UTF8_DIGIT}|#{UTF8_BASLAT}|#{UTF8_LAT1SP}|#{UTF8_LATEXA}|#{UTF8_LATEXB}|#{UTF8_IPAEXT}"
 
       PRINTABLE_CHAR = "#{UTF8_CHAR}|[<>-]"
+      LEGAL_CHAR     = '[ /&()\[\].,-]'
 
       def self.get(name, *args)
-        const_get(name.camelcase).new(*args)
+        Lingo.get_const(name, self).new(*args)
       end
 
-      attr_reader :position
+      attr_reader :pos
 
       def initialize(id, lingo)
         @config = lingo.database_config(id)
 
-        source_file = Lingo.find(:dict, name = @config['name'])
+        source_file = Lingo.find(:dict, name = @config['name'], relax: true)
+
         reject_file = begin
           Lingo.find(:store, source_file) << '.rev'
-        rescue NoWritableStoreError
+        rescue NoWritableStoreError, SourceFileNotFoundError
         end
 
-        @pn_source = Pathname.new(source_file)
-        @pn_reject = Pathname.new(reject_file) if reject_file
+        @src = Pathname.new(source_file)
+        @rej = Pathname.new(reject_file) if reject_file
 
-        raise SourceFileNotFoundError.new(name, id) unless @pn_source.exist?
+        raise SourceFileNotFoundError.new(name, id) unless @src.exist?
 
-        @wordclass = @config.fetch('def-wc', '?').downcase
-        @separator = @config['separator']
+        @def = @config.fetch('def-wc', Language::LA_UNKNOWN).downcase
+        @sep = @config['separator']
 
-        @legal_word = '(?:' + PRINTABLE_CHAR + '|[' + Regexp.escape('- /&()[].,') + '])+'  # TODO: v1.60 - ',' bei Source zulassen; in const.rb einbauen
-        @line_pattern = Regexp.new('^'+@legal_word+'$')
+        @wrd = "(?:#{PRINTABLE_CHAR}|#{LEGAL_CHAR})+"
+        @pat = /^#{@wrd}$/
 
-        @position = 0
+        @pos = 0
       end
 
       def size
-        @pn_source.size
+        @src.size
       end
 
       def each
-        reject_file = @pn_reject.open('w', encoding: ENC) if @pn_reject
+        reject_file = @rej.open('w', encoding: ENC) if @rej
 
-        @pn_source.each_line($/, encoding: ENC) { |line|
-          @position += length = line.bytesize
+        @src.each_line($/, encoding: ENC) { |line|
+          @pos += length = line.bytesize
 
           next if line =~ /\A\s*#/ || line.strip.empty?
 
           line.chomp!
           line.downcase!
 
-          if length < 4096 && line =~ @line_pattern
+          if length < 4096 && line =~ @pat
             yield convert_line(line, $1, $2)
           else
             reject_file.puts(line) if reject_file
@@ -119,7 +121,7 @@ class Lingo
       ensure
         if reject_file
           reject_file.close
-          @pn_reject.delete if @pn_reject.size == 0
+          @rej.delete if @rej.size == 0
         end
       end
 

data/lib/lingo/database.rb

@@ -24,17 +24,9 @@
 ###############################################################################
 #++
 
-require 'pathname'
-require 'fileutils'
-require 'digest/sha1'
-
 require_relative 'database/show_progress'
 require_relative 'database/crypter'
 require_relative 'database/source'
-require_relative 'database/hash_store'
-require_relative 'database/sdbm_store'
-require_relative 'database/gdbm_store'
-require_relative 'database/libcdb_store'
 
 class Lingo
 
@@ -49,45 +41,57 @@ class Lingo
 
     include Cachable
 
-    BACKENDS = %w[LibCDB SDBM GDBM].unshift(ENV['LINGO_BACKEND']).compact.uniq
-
     FLD_SEP = '|'
     IDX_REF = '^'
     KEY_REF = '*'
     SYS_KEY = '~'
 
-    INDEX_PATTERN = %r{\A#{Regexp.escape(IDX_REF)}\d+\z}
+    IDX_REF_ESC = Regexp.escape(IDX_REF)
+    KEY_REF_ESC = Regexp.escape(KEY_REF)
+
+    INDEX_PATTERN = %r{\A#{IDX_REF_ESC}\d+\z}
+
+    BACKENDS       = []
+    BACKEND_BY_EXT = {}
+
+    class << self
+
+      def register(klass, ext, prio = -1, meth = true)
+        BACKENDS.insert(prio, name = klass.name[/::(\w+)Store\z/, 1])
+        Array(ext).each { |i| BACKEND_BY_EXT[i.prepend('.')] = name }
+
+        klass.const_set(:EXT, ext)
+        klass.class_eval('def store_ext; EXT; end', __FILE__, __LINE__) if meth
+      end
+
+      def open(*args, &block)
+        new(*args).open(&block)
+      end
 
-    def self.open(*args, &block)
-      new(*args).open(&block)
     end
 
+    attr_reader :backend
+
     def initialize(id, lingo)
-      @config = lingo.database_config(id)
+      @id, @lingo, @config, @db = id, lingo, lingo.database_config(id), nil
 
-      @id, @lingo = id, lingo
-      @src_file   = Lingo.find(:dict, @config['name'])
-      @crypter    = Crypter.new if @config.has_key?('crypt')
+      @srcfile = Lingo.find(:dict, @config['name'], relax: true)
+      @crypter = @config.has_key?('crypt') && Crypter.new
 
       begin
-        @dbm_name = Lingo.find(:store, @src_file)
-        FileUtils.mkdir_p(File.dirname(@dbm_name))
+        @stofile = Lingo.find(:store, @srcfile)
+        FileUtils.mkdir_p(File.dirname(@stofile))
+      rescue SourceFileNotFoundError => err
+        @stofile = skip_ext = err.id
+        backend = backend_from_file(@stofile) unless err.name
       rescue NoWritableStoreError
-        @backend  = HashStore
+        backend = HashStore
       end
 
-      extend(backend)
-
-      @dbm_name << store_ext if respond_to?(:store_ext, true)
-
+      use_backend(backend, skip_ext)
       init_cachable
-      convert unless uptodate?
-    end
 
-    def backend
-      @backend ||= BACKENDS.find { |mod|
-        break self.class.const_get("#{mod}Store") if Object.const_defined?(mod)
-      } || HashStore
+      convert unless uptodate?
     end
 
     def closed?
@@ -97,6 +101,8 @@ class Lingo
     def open
       @db = _open if closed?
       block_given? ? yield(self) : self
+    rescue => err
+      raise DatabaseError.new(:open, @stofile, err)
     ensure
       close if @db && block_given?
     end
@@ -134,16 +140,36 @@ class Lingo
       val.uniq!
       store(key, val)
 
-      val = val.join(FLD_SEP)
-      key, val = @crypter.encode(key, val) if @crypter
-
-      _set(key, val)
+      arg = [key, val.join(FLD_SEP)]
+      _set(*@crypter ? @crypter.encode(*arg) : arg)
     end
 
     private
 
-    def uptodate?(file = @dbm_name)
-      src = Pathname.new(@src_file)
+    def use_backend(backend = nil, skip_ext = false)
+      [ENV['LINGO_BACKEND'], *BACKENDS].each { |mod|
+        backend = get_backend(mod) and break if mod
+      } unless backend
+
+      extend(@backend = backend || HashStore)
+
+      @stofile << store_ext if !skip_ext && respond_to?(:store_ext)
+    end
+
+    def get_backend(mod)
+      self.class.const_get("#{mod}Store") if Object.const_defined?(mod)
+    rescue TypeError, NameError
+    end
+
+    def backend_from_file(file)
+      ext = File.extname(file)
+
+      mod = BACKEND_BY_EXT[ext] or raise BackendNotFoundError.new(file)
+      get_backend(mod) or raise BackendNotAvailableError.new(mod, file)
+    end
+
+    def uptodate?(file = @stofile)
+      src = Pathname.new(@srcfile)
       @source_key = lambda { [src.size, src.mtime].join(FLD_SEP) }
 
       sys_key = open { @db[SYS_KEY] } if File.exist?(file)
@@ -160,7 +186,7 @@ class Lingo
     end
 
     def _clear
-      File.delete(@dbm_name) if File.exist?(@dbm_name)
+      File.delete(@stofile) if File.exist?(@stofile)
     end
 
     def _open
@@ -186,42 +212,35 @@ class Lingo
       end
     end
 
+    def warn(*msg)
+      @lingo.warn(*msg)
+    end
+
     def convert(verbose = @lingo.config.stderr.tty?)
-      src = Source.get(@config.fetch('txt-format', 'KeyValue'), @id, @lingo)
+      src = Source.get(@config.fetch('txt-format', 'key_value'), @id, @lingo)
 
       if lex = @config['use-lex']
-        a, s = [{
-          'source' => lex.split(STRING_SEPARATOR_RE),
-          'mode'   => @config['lex-mode']
-        }, @lingo], ' '
-
-        dic = Language::Dictionary.new(*a)
-        gra = Language::Grammar.new(*a)
-
-        block = lambda { |form|
-          res = dic.find_word(form)
-
-          if res.unknown?
-            res = gra.find_compositum(form)
-            com = res.compo_form
-          end
+        a = [{ 'source' => lex.split(SEP_RE), 'mode' => @config['lex-mode'] }, @lingo]
+        d, g = Language::Dictionary.new(*a), Language::Grammar.new(*a); a = nil
 
-          com ? com.form : res.norm
+        sep, block = ' ', lambda { |f|
+          (r = d.find_word(f)).unknown? &&
+            (c = (r = g.find_compound(f)).compo_form) ? c.form : r.norm
         }
       end
 
       ShowProgress.new(self, src.size, verbose) { |progress| create {
         src.each { |key, val|
-          progress[src.position]
+          progress[src.pos]
 
           if key
             key.chomp!('.')
 
-            if lex && key.include?(s)
-              k = key.split(s).map!(&block).join(s)
+            if lex && key.include?(sep)
+              k = key.split(sep).map!(&block).join(sep)
 
-              c = k.count(s) + 1
-              self[k.split(s)[0, 3].join(s)] = ["#{KEY_REF}#{c}"] if c > 3
+              c = k.count(sep) + 1
+              self[k.split(sep)[0, 3].join(sep)] = ["#{KEY_REF}#{c}"] if c > 3
 
               key, val = k, val.map { |v| v.start_with?('#') ? key + v : v }
             end
@@ -237,3 +256,9 @@ class Lingo
   end
 
 end
+
+# in order of priority
+require_relative 'database/libcdb_store'
+require_relative 'database/sdbm_store'
+require_relative 'database/gdbm_store'
+require_relative 'database/hash_store'

data/lib/lingo/error.rb

@@ -37,7 +37,49 @@ class Lingo
     end
 
     def to_s
-      'No writable store found in search path'
+      'No writable store found in search path.'
+    end
+
+  end
+
+  class BackendNotFoundError < LingoError
+
+    attr_reader :file
+
+    def initialize(file)
+      @file = file
+    end
+
+    def to_s
+      "No backend found for `#{file}'."
+    end
+
+  end
+
+  class BackendNotAvailableError < LingoError
+
+    attr_reader :mod, :file
+
+    def initialize(mod, file)
+      @mod, @file = mod, file
+    end
+
+    def to_s
+      "Backend not available `#{mod}' for `#{file}'."
+    end
+
+  end
+
+  class DatabaseError < LingoError
+
+    attr_reader :action, :file, :err
+
+    def initialize(action, file, err)
+      @action, @file, @err = action, file, err
+    end
+
+    def to_s
+      "An error occured when trying to #{action} `#{file}': #{err} (#{err.class})"
     end
 
   end
@@ -119,4 +161,18 @@ class Lingo
 
   end
 
+  class NameNotFoundError < LingoError
+
+    attr_reader :klass, :name
+
+    def initialize(klass, name)
+      @klass, @name = klass, name
+    end
+
+    def to_s
+      "No such #{klass.name.split('::').last} type `#{name}'."
+    end
+
+  end
+
 end

data/lib/lingo/language/dictionary.rb

@@ -33,6 +33,12 @@ class Lingo
       include Cachable
       include Reportable
 
+      def self.open(*args)
+        yield dictionary = new(*args)
+      ensure
+        dictionary.close if dictionary
+      end
+
       def initialize(config, lingo)
         unless config.has_key?('source')
           raise ArgumentError, 'Required parameter `source\' missing.'
@@ -43,32 +49,29 @@ class Lingo
 
         @suffixes, @infixes = [], []
 
-        if suffix = lingo.dictionary_config['suffix']
-          suffix.each { |t, s|
-            t.downcase!
+        Array(lingo.dictionary_config['suffix']).each { |t, s|
+          t.downcase!
 
-            s.split.each { |suf|
-              su, ex = suf.split('/')
+          a = t == 'f' ? @infixes : @suffixes
 
-              (t == 'f' ? @infixes : @suffixes) << [
-                Regexp.new(su << '$', 'i'), ex || '*', t
-              ]
-            }
+          s.split.each { |r|
+            f, e = r.split('/')
+            a << [/#{f}$/i, e || '*', t]
           }
-        end
+        }
 
-        @sources     = config['source'].map { |src| lingo.lexical_hash(src) }
-        @all_sources = config['mode'].nil? || config['mode'].downcase == 'all'
+        @src = config['source'].map { |src| lingo.lexical_hash(src) }
+        @all = config['mode'].nil? || config['mode'].downcase == 'all'
 
         lingo.dictionaries << self
       end
 
       def close
-        @sources.each(&:close)
+        @src.each(&:close)
       end
 
       def report
-        super.tap { |rep| @sources.each { |src| rep.update(src.report) } }
+        super.tap { |rep| @src.each { |src| rep.update(src.report) } }
       end
 
       # _dic_.find_word( _aString_ ) -> _aNewWord_
@@ -95,11 +98,11 @@ class Lingo
         lex = [obj] if lex.empty? && obj.unknown?
 
         # multiworder optimization
-        ref = %r{\A#{Regexp.escape(Database::KEY_REF)}\d+}o
+        ref = %r{\A#{Database::KEY_REF_ESC}\d+}
 
         lex.each_with_object([]) { |l, s|
           next if l.attr == LA_SYNONYM
-          next if l.attr != LA_KOMPOSITUM && obj.attr == WA_KOMPOSITUM
+          next if l.attr != LA_COMPOUND && obj.attr == WA_COMPOUND
 
           select(l.form).each { |y| s << y unless y =~ ref }
         }
@@ -109,10 +112,10 @@ class Lingo
       #
       # Sucht alle Wörterbücher durch und gibt den ersten Treffer zurück (+mode = first+), oder alle Treffer (+mode = all+)
       def select(str)
-        @sources.each_with_object([]) { |src, lex|
+        @src.each_with_object([]) { |src, lex|
           l = src[str] or next
           lex.concat(l)
-          break lex unless @all_sources
+          break lex unless @all
         }.tap { |lex| lex.sort!; lex.uniq! }
       end