lingo 1.8.2 → 1.8.3

data/lib/lingo/config.rb

@@ -27,11 +27,15 @@
 require 'yaml'
 require_relative 'cli'
 
+YAML::ENGINE.yamler = 'psych'
+
 class Lingo
 
   class Config
 
     def initialize(*args)
+      @deprecated = Hash.new { |h, k| h[k] = true; false }
+
       @cli, @opts = CLI.new, {}
 
       @cli.execute(*args)
@@ -40,9 +44,10 @@ class Lingo
       load_config('language', :lang)
       load_config('config')
 
-      Array(self['meeting/attendees']).each { |a|
-        r = a['text_reader'] || a['textreader'] or next  # DEPRECATE textreader
+      deprecate(:textreader, :text_reader) if Array(self['meeting/attendees']).map(&:keys).flatten.include?('textreader')
 
+      if r = get('meeting/attendees', 'text_reader') ||
+             get('meeting/attendees', 'textreader')  # DEPRECATE textreader
         f = @cli.files
 
         if i = r['files']
@@ -50,9 +55,7 @@ class Lingo
         elsif !f.empty?
           r['files'] = f
         end
-
-        break
-      }
+      end
     end
 
     def [](key)
@@ -64,6 +67,23 @@ class Lingo
       (self[nodes_to_key(nodes)] ||= {})[node] = val
     end
 
+    def get(key, *names)
+      val = self[key]
+
+      while name = names.shift
+        case val
+          when Hash  then val = val[name]
+          when Array then val = val.find { |h|
+            k, v = h.dup.shift
+            break v if k == name
+          }
+          else break
+        end
+      end
+
+      val
+    end
+
     def stdin
       @cli.stdin
     end
@@ -76,10 +96,23 @@ class Lingo
       @cli.stderr
     end
 
+    def warn(*msg)
+      stderr.puts(*msg)
+    end
+
     def quit(*args)
       @cli.send(:quit, *args)
     end
 
+    def deprecate(old, new, obj = self)
+      unless @deprecated[[source = obj.class.name.sub(/\ALingo::/, ''), old]]
+        warn(
+          "DEPRECATION WARNING: #{source} option `#{old}' is deprecated " <<
+          "and will be removed in Lingo 1.9. Please use `#{new}' instead."
+        )
+      end
+    end
+
     private
 
     def key_to_nodes(key)
@@ -91,8 +124,8 @@ class Lingo
     end
 
     def load_config(key, type = key.to_sym)
-      file = Lingo.find(type, @opts[key], &method(:quit))
-      @opts.update(File.open(file, encoding: ENC, &YAML.method(:load)))
+      file = Lingo.find(type, @opts[key]) { quit }
+      @opts.update(File.open(file, encoding: ENC) { |f| YAML.load(f) })
     end
 
   end

data/lib/lingo/ctl.rb

@@ -39,59 +39,52 @@ class Lingo
       h[k] = COMMANDS.has_key?(k) ? k : 'usage'
     }
 
-    ALIASES['ls']  # OCCUPY
-
-    { config: %w[configuration],
-      lang:   %w[language],
-      dict:   %w[dictionary dictionaries],
-      store:  %w[store],
-      sample: %w[sample\ text\ file] }.each { |what, (sing, plur)|
-      COMMANDS["list#{what}"] = [
-        "List available #{plur || "#{sing}s"}",  'Arguments: [name...]'
-      ] if what != :store
-      COMMANDS["find#{what}"] = [
-        "Find #{sing} in Lingo search path",     'Arguments: name'
-      ]
-      COMMANDS["copy#{what}"] = [
-        "Copy #{sing} to local Lingo directory", 'Arguments: name'
-      ] if what != :store
-
-      %w[list find copy].each { |method|
-        next unless COMMANDS.has_key?(name = "#{method}#{what}")
-        class_eval %Q{def do_#{name}; #{method}(:#{what}); end}
-
-        [0, -1].repeated_permutation(2) { |i, j|
-          key = "#{method[i]}#{what[j]}"
-          break ALIASES[key] = name unless ALIASES.has_key?(key)
-        }
-      }
-
-      if what == :store
-        COMMANDS['clearstore'] = [
-          'Remove store files to force rebuild', 'Arguments: name'
-        ]
-        ALIASES['cs'] = 'clearstore'
-      end
-    }
-
-    { demo:    ['Initialize demo directory (Default: current directory)',
-                'Arguments: [path]'],
-      path:    'Print search path for dictionaries and configurations',
-      help:    'Print help for available commands',
-      version: 'Print Lingo version number' }.each { |what, description|
-      COMMANDS[name = what.to_s] = description; ALIASES[name[0]] = name
-    }
-
-    USAGE = <<EOT
+    USAGE = <<-EOT
 Usage: #{PROG} <command> [arguments] [options]
        #{PROG} [-h|--help] [--version]
-EOT
+    EOT
 
     def ctl
       parse_options
       send("do_#{ALIASES[ARGV.shift]}")
     end
 
+    def self.cmd(name, short, desc, args = nil, default = nil)
+      if name.is_a?(Array)
+        m, f, k = name
+        name, short = "#{m}#{k}", "#{f}#{short}"
+        class_eval %Q{private; def do_#{name}; #{m}(:#{k}); end}
+      end
+
+      if args
+        desc = [desc, args = "Arguments: #{args}"]
+        args << " (Default: #{default})" if default
+      end
+
+      COMMANDS[name], ALIASES[short] = desc, name
+    end
+
+    { config: %w[c configuration],
+      lang:   %w[l language],
+      dict:   %w[d dictionary dictionaries],
+      store:  %w[s store],
+      sample: %w[e sample\ text\ file]
+    }.each { |n, (s, q, r)|
+      t = n == :store
+
+      cmd([:list,  :l, n], s, "List available #{r || "#{q}s"}", '[name...]') if !t
+      cmd([:find,  :f, n], s, "Find #{q} in Lingo search path",      'name')
+      cmd([:copy,  :c, n], s, "Copy #{q} to local Lingo directory",  'name') if !t
+      cmd([:clear, :c, n], s, 'Remove store files to force rebuild', 'name') if  t
+    }
+
+    { demo:    [:d, 'Initialize demo directory', '[path]', 'current directory'],
+      rackup:  [:r, 'Print path to rackup file', 'name'],
+      path:    [:p, 'Print search path for dictionaries and configurations'],
+      help:    [:h, 'Print help for available commands'],
+      version: [:v, 'Print Lingo version number']
+    }.each { |n, (s, *a)| cmd(n.to_s, s.to_s, *a) }
+
     private
 
     def list(what, doit = true)
@@ -103,20 +96,20 @@ EOT
     end
 
     def find(what, doit = true)
-      name = ARGV.shift or do_usage('Required argument `name\' missing.')
+      name = ARGV.shift or missing_arg(:name)
       no_args
 
-      file = Lingo.find(what, name, path: path_for_scope, &method(:do_usage))
+      file = Lingo.find(what, name, path: path_for_scope) { usage }
       doit ? puts(file) : file
     end
 
     def copy(what)
-      do_usage('Source and target are the same.') if OPTIONS[:scope] == :local
+      usage('Source and target are the same.') if OPTIONS[:scope] == :local
 
       source = find(what, false)
       target = File.join(path_for_scope(:local), Lingo.basepath(what, source))
 
-      do_usage('Source and target are the same.') if source == target
+      usage('Source and target are the same.') if source == target
 
       FileUtils.mkdir_p(File.dirname(target))
       FileUtils.cp(source, target, verbose: true)
@@ -137,6 +130,19 @@ EOT
       copy_list(:sample)
     end
 
+    def do_rackup(doit = true)
+      name = ARGV.shift or missing_arg(:name)
+      no_args
+
+      require 'lingo/app'
+
+      if file = Lingo::App.rackup(name)
+        doit ? puts(file) : file
+      else
+        usage("Invalid app name `#{name.inspect}'.")
+      end
+    end
+
     def do_path
       no_args
       puts path_for_scope || PATH
@@ -172,10 +178,6 @@ EOT
       doit ? puts(msg) : msg
     end
 
-    def do_usage(msg = nil)
-      abort "#{"#{PROGNAME}: #{msg}\n\n" if msg}#{USAGE}"
-    end
-
     def parse_options
       OptionParser.new(USAGE, OPTWIDTH) { |opts|
         opts.separator ''
@@ -185,7 +187,7 @@ EOT
           OPTIONS[:scope] = :system
         }
 
-        opts.on('--global', 'Restrict command to the user\'s personal Lingo directory') {
+        opts.on('--global', "Restrict command to the user's personal Lingo directory") {
           OPTIONS[:scope] = :global
         }
 
@@ -212,17 +214,27 @@ EOT
         when :global then [HOME]
         when :local  then [OPTIONS[:path] || CURR]
         when nil
-        else do_usage("Invalid scope `#{scope.inspect}'.")
+        else usage("Invalid scope `#{scope.inspect}'.")
       end
     end
 
+    def usage(msg = nil)
+      abort "#{"#{PROGNAME}: #{msg}\n\n" if msg}#{USAGE}"
+    end
+
+    alias_method :do_usage, :usage
+
+    def missing_arg(arg)
+      usage("Required argument `#{arg}' missing.")
+    end
+
     def no_args
-      do_usage('Too many arguments.') unless ARGV.empty?
+      usage('Too many arguments.') unless ARGV.empty?
     end
 
     def copy_list(what)
       files = list(what, false)
-      files.select!(&Proc.new) if block_given?
+      files.select! { |i| yield i } if block_given?
       files.each { |file| ARGV.replace([file]); copy(what) }
     end
 

data/lib/lingo/database/hash_store.rb

@@ -30,20 +30,19 @@ class Lingo
 
     module HashStore
 
-      def to_h
-        @db.dup
-      end
-
+      # Never close, because we can't restore.
       def close
         self
       end
 
       private
 
+      # Never up-to-date.
       def uptodate?
         false
       end
 
+      # Nothing to do.
       def uptodate!
         nil
       end
@@ -56,10 +55,16 @@ class Lingo
         {}
       end
 
+      # Never closed.
       def _closed?
         false
       end
 
+      # Dup key, because we're reusing everything.
+      def _each
+       @db.each { |key, val| yield key.dup, val }
+     end
+
     end
 
   end

data/lib/lingo/database/sdbm_store.rb

@@ -34,6 +34,8 @@ class Lingo
 
       Database.register(self, %w[dir pag], -1, false)
 
+      MAX_LENGTH = 950
+
       private
 
       def uptodate?
@@ -48,15 +50,10 @@ class Lingo
         SDBM.open(@stofile)
       end
 
-      def _get(key)
-        val = super
-        val && val.encode(ENC)
-      end
-
       def _set(key, val)
-        if val.length > 950
+        if val.bytesize > MAX_LENGTH
           warn "Warning: Entry `#{key}' (#{@srcfile}) too long for SDBM. Truncating..."
-          val = val[0, 950]
+          val = val.byteslice(0, MAX_LENGTH)
         end
 
         super

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

@@ -50,7 +50,7 @@ class Lingo
         private
 
         def convert_line(line, key, val)
-          values = line.split(@sep).each(&:strip!)
+          values = line.split(@sep).each { |i| i.strip! }
           [values.shift, values]
         end
 

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

@@ -49,7 +49,7 @@ class Lingo
         private
 
         def convert_line(line, key, val)
-          [nil, line.split(@sep).each(&:strip!)]
+          [nil, line.split(@sep).each { |i| i.strip! }]
         end
 
       end

data/lib/lingo/database/source.rb

@@ -47,24 +47,6 @@ class Lingo
 
     class Source
 
-      # Define printable characters for tokenizer for UTF-8 encoding
-      UTF8_DIGIT  = '[0-9]'
-      # Define Basic Latin printable characters for UTF-8 encoding from U+0000 to U+007f
-      UTF8_BASLAT = '[A-Za-z]'
-      # Define Latin-1 Supplement printable characters for UTF-8 encoding from U+0080 to U+00ff
-      UTF8_LAT1SP = '[\xc3\x80-\xc3\x96\xc3\x98-\xc3\xb6\xc3\xb8-\xc3\xbf]'
-      # Define Latin Extended-A printable characters for UTF-8 encoding from U+0100 to U+017f
-      UTF8_LATEXA = '[\xc4\x80-\xc4\xbf\xc5\x80-\xc5\xbf]'
-      # Define Latin Extended-B printable characters for UTF-8 encoding from U+0180 to U+024f
-      UTF8_LATEXB = '[\xc6\x80-\xc6\xbf\xc7\x80-\xc7\xbf\xc8\x80-\xc8\xbf\xc9\x80-\xc9\x8f]'
-      # Define IPA Extension printable characters for UTF-8 encoding from U+024f to U+02af
-      UTF8_IPAEXT = '[\xc9\xa0-\xc9\xbf\xca\xa0-\xca\xaf]'
-      # Collect all UTF-8 printable characters in Unicode range U+0000 to U+02af
-      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)
         Lingo.get_const(name, self).new(*args)
       end
@@ -89,7 +71,7 @@ class Lingo
         @def = @config.fetch('def-wc', Language::LA_UNKNOWN).downcase
         @sep = @config['separator']
 
-        @wrd = "(?:#{PRINTABLE_CHAR}|#{LEGAL_CHAR})+"
+        @wrd = "(?:#{Language::Char::ANY})+"
         @pat = /^#{@wrd}$/
 
         @pos = 0
@@ -108,7 +90,7 @@ class Lingo
           next if line =~ /\A\s*#/ || line.strip.empty?
 
           line.chomp!
-          line.downcase!
+          line.replace(Unicode.downcase(line))
 
           if length < 4096 && line =~ @pat
             yield convert_line(line, $1, $2)

data/lib/lingo/database.rb

@@ -39,8 +39,6 @@ class Lingo
 
   class Database
 
-    include Cachable
-
     FLD_SEP = '|'
     IDX_REF = '^'
     KEY_REF = '*'
@@ -58,7 +56,7 @@ class Lingo
 
       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 }
+        Array(ext).each { |i| BACKEND_BY_EXT[i.insert(0, '.')] = name }
 
         klass.const_set(:EXT, ext)
         klass.class_eval('def store_ext; EXT; end', __FILE__, __LINE__) if meth
@@ -78,6 +76,8 @@ class Lingo
       @srcfile = Lingo.find(:dict, @config['name'], relax: true)
       @crypter = @config.has_key?('crypt') && Crypter.new
 
+      @val = Hash.new { |h, k| h[k] = [] }
+
       begin
         @stofile = Lingo.find(:store, @srcfile)
         FileUtils.mkdir_p(File.dirname(@stofile))
@@ -89,13 +89,12 @@ class Lingo
       end
 
       use_backend(backend, skip_ext)
-      init_cachable
 
       convert unless uptodate?
     end
 
     def closed?
-      @db.nil? || _closed?
+      !@db || _closed?
     end
 
     def open
@@ -108,16 +107,20 @@ class Lingo
     end
 
     def close
-      @db.close unless closed?
+      _close unless closed?
       @db = nil
 
       self
     end
 
     def to_h
-      {}.tap { |hash| @db.each { |key, val|
-        hash[key.force_encoding(ENC).freeze] = val.force_encoding(ENC)
-      } unless closed? }
+      hash = {}
+      each { |key, val| hash[key.freeze] = val }
+      hash
+    end
+
+    def each
+      _each { |key, val| yield _encode!(key), _encode!(val) } unless closed?
     end
 
     def [](key)
@@ -133,15 +136,15 @@ class Lingo
     def []=(key, val)
       return if closed?
 
-      val = val.dup
-      val.concat(retrieve(key)) if hit?(key)
-
-      val.sort!
+      val = @val[key].concat(val).sort!
       val.uniq!
-      store(key, val)
 
-      arg = [key, val.join(FLD_SEP)]
-      _set(*@crypter ? @crypter.encode(*arg) : arg)
+      val = val.join(FLD_SEP)
+      @crypter ? _set(*@crypter.encode(key, val)) : _set(key, val)
+    end
+
+    def warn(*msg)
+      @lingo.warn(*msg)
     end
 
     private
@@ -193,10 +196,18 @@ class Lingo
       raise NotImplementedError
     end
 
+    def _close
+      @db.close
+    end
+
     def _closed?
       @db.closed?
     end
 
+    def _each
+      @db.each { |key, val| yield key, val }
+    end
+
     def _set(key, val)
       @db[key] = val
     end
@@ -207,13 +218,13 @@ class Lingo
 
     def _val(key)
       if val = _get(@crypter ? @crypter.digest(key) : key)
-        val.force_encoding(ENC)
+        _encode!(val)
         @crypter ? @crypter.decode(key, val) : val
       end
     end
 
-    def warn(*msg)
-      @lingo.warn(*msg)
+    def _encode!(str)
+      str.force_encoding(ENC)
     end
 
     def convert(verbose = @lingo.config.stderr.tty?)

data/lib/lingo/debug.rb

@@ -0,0 +1,79 @@
+# encoding: utf-8
+
+#--
+###############################################################################
+#                                                                             #
+# Lingo -- A full-featured automatic indexing system                          #
+#                                                                             #
+# Copyright (C) 2005-2007 John Vorhauer                                       #
+# Copyright (C) 2007-2012 John Vorhauer, Jens Wille                           #
+#                                                                             #
+# Lingo is free software; you can redistribute it and/or modify it under the  #
+# terms of the GNU Affero General Public License as published by the Free     #
+# Software Foundation; either version 3 of the License, or (at your option)   #
+# any later version.                                                          #
+#                                                                             #
+# Lingo is distributed in the hope that it will be useful, but WITHOUT ANY    #
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS   #
+# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for     #
+# more details.                                                               #
+#                                                                             #
+# You should have received a copy of the GNU Affero General Public License    #
+# along with Lingo. If not, see <http://www.gnu.org/licenses/>.               #
+#                                                                             #
+###############################################################################
+#++
+
+class Lingo
+
+  module Debug
+
+    extend self
+
+    PS_COMMAND = ENV['LINGO_PS_COMMAND'] || '/bin/ps'
+    PS_COLUMNS = ENV['LINGO_PS_COLUMNS'] || 'vsz,rss,sz,%mem,%cpu,time,etime,pid'
+
+    PS_RE = File.executable?(PS_COMMAND) ? %r{\A#{ENV['LINGO_DEBUG_PS']}\z} : nil
+
+    PS_NO_HEADING = Hash.new { |h, k| h[k] = true; false }
+
+    def ps(name)
+      system(PS_COMMAND,
+        '-o', PS_COLUMNS,
+        "--#{'no-' if PS_NO_HEADING[name]}heading",
+        Process.pid.to_s) if name =~ PS_RE
+    end
+
+    def profile(base)
+      return yield unless base
+
+      require 'ruby-prof'
+
+      result = RubyProf.profile { yield }
+      result.eliminate_methods! [/\b(?:Gem|HighLine)\b/,
+        /\A(?:Benchmark|FileUtils|Pathname|Util)\b/]
+
+      if base.is_a?(IO)
+        RubyProf::FlatPrinter.new(result).print(base)
+      else
+        FileUtils.mkdir_p(File.dirname(base))
+
+        mode = ENV['RUBY_PROF_MEASURE_MODE']
+        base += "-#{mode}" if mode && !mode.empty?
+
+        {
+          :txt   => :FlatPrinter,
+          :lines => :FlatPrinterWithLineNumbers,
+          :html  => :GraphHtmlPrinter,
+          :stack => :CallStackPrinter
+        }.each { |ext, name|
+          File.open("#{base}.#{ext}", 'a+', encoding: ENC) { |f|
+            RubyProf.const_get(name).new(result).print(f)
+          }
+        }
+      end
+    end
+
+  end
+
+end