cr.rb 4.0.3 → 4.1.0

data/bin/cr

@@ -3,813 +3,585 @@
 # File          : cr.rb
 # Authors       : ccmywish <ccmywish@qq.com>
 # Created on    : <2021-07-08>
-# Last modified : <2023-02-05>
+# Last modified : <2023-02-12>
 #
 # cr:
 #
 #   This file is used to explain a CRyptic command
 # or an acronym's real meaning in computer world or
 # other fields.
-#
 # ------------------------------------------------------
 
 require 'cr'
-require 'tomlrb'
-require 'fileutils'
 
-CR_DEFAULT_LIBRARY = File.expand_path("~/.cryptic-resolver")
+class CrypticResolver::CliHandler
 
-$CR_DEFAULT_DICTS = [
-  "https://github.com/cryptic-resolver/cryptic_common.git",
-  "https://github.com/cryptic-resolver/cryptic_computer.git",
-  "https://github.com/cryptic-resolver/cryptic_windows.git",
-  "https://github.com/cryptic-resolver/cryptic_linux.git",
-  "https://github.com/cryptic-resolver/cryptic_technology"
-]
+  def initialize(args)
+    option = args.shift
 
-# The config file will override the default dicts, but not default library!
-if ENV['CRYPTIC_RESOLVER_CONFIG']
-  file = ENV['CRYPTIC_RESOLVER_CONFIG']
-  if test('f', file)
-    config = Tomlrb.load_file file
+    case option when nil, '-h','--help' then help or exit end
 
-    CR_EXTRA_LIBRARY ||= config['EXTRA_LIBRARY']
+    reslvr = CrypticResolver::Resolver.new
 
-    if config['DEFAULT_DICTS']
-      CR_DEFAULT_DICTS = config['DEFAULT_DICTS']
-    else
-      CR_DEFAULT_DICTS = $CR_DEFAULT_DICTS
-    end
+    reslvr.add_default_dicts_if_none_exists
 
-  else
-    puts "FATAL: Your CRYPTIC_RESOLVER_CONFIG is NOT a file!"
-    exit 1
+    case option
+    when '-l'   then reslvr.list_dicts
+    when '-c'   then reslvr.word_count
+    when '-u'   then reslvr.update_dicts
+    when '-s'   then reslvr.search_word args.shift
+    when '-a'   then reslvr.add_dict args.shift
+    when '-d'   then reslvr.del_dict args.shift
+    else reslvr.resolve_word option end
   end
 
-else
-  # if user doesn't specify, we use the hard-coded defaults
-  CR_EXTRA_LIBRARY = nil
-  CR_DEFAULT_DICTS = $CR_DEFAULT_DICTS
-end
 
+  def help
+    puts <<~HELP
+    cr: Cryptic Resolver v#{CrypticResolver::GEM_VERSION}
 
-# Prevent runtime error
-if not CR_EXTRA_LIBRARY.nil?
-  if ! test('d', CR_EXTRA_LIBRARY)
-    puts "FATAL: Your CRYPTIC_RESOLVER_CONFIG's option 'EXTRA_LIBRARY' is NOT a legal directory!"
-    exit 1
-  end
-end
+    Usage:
+      cr <keyword>   Search the keyword
+      cr emacs       => Edit macros: A feature-rich editor
 
+    Options:
+      -c             Print word count
+      -s <pattern>   Search words matched with pattern
+      -h             Print this help
 
-# This is used to display what you are pulling when adding dicts
-CR_DEFAULT_DICTS_USER_AND_NAMES = CR_DEFAULT_DICTS.map do |e|
-  user, repo = e.split('/').last(2)
-  repo = repo.split('.').first
-  user + '/' + repo
-end
+    Dictionaries:
+      -l                      List local dicts and official dicts
+      -u                      Update all dicts in Default library
+      -a <https://repo[.git]> Add a new dict
+      -a <user/repo>          Add a new dict from Github
+      -a <dict_name>          Add an official dict, use -l to see
+      -d <dict_name>          Delete a dict
 
-# Same with the pulled repo dirs' names in CR_DEFAULT_LIBRARY
-CR_DEFAULT_DICTS_NAMES = CR_DEFAULT_DICTS.map do |e|
-  e.split('/').last.split('.').first
-end
-
-
-####################
-# helper: for color
-####################
-
-def bold(str)       "\e[1m#{str}\e[0m" end
-def underline(str)  "\e[4m#{str}\e[0m" end
-def red(str)        "\e[31m#{str}\e[0m" end
-def green(str)      "\e[32m#{str}\e[0m" end
-def yellow(str)     "\e[33m#{str}\e[0m" end
-def blue(str)       "\e[34m#{str}\e[0m" end
-def purple(str)     "\e[35m#{str}\e[0m" end
-def cyan(str)       "\e[36m#{str}\e[0m" end
+    HELP
+  end
 
+end
 
-####################
-# core: logic
-####################
 
-def is_there_any_dict?
-  unless Dir.exist? CR_DEFAULT_LIBRARY
-    Dir.mkdir CR_DEFAULT_LIBRARY
-  end
+class CrypticResolver::Resolver
 
-  !Dir.empty? CR_DEFAULT_LIBRARY
-end
+  # Notice that we only update the Default library, not Extra library
+  def update_dicts
 
+    @counter.count_def_lib(display: false)
+    old_wc = @counter.word_count_of_def_lib
 
-def add_default_dicts_if_none_exists
-  unless is_there_any_dict?
-    puts "cr: Adding default dicts..."
+    puts "cr: Updating all dicts in Default library..."
 
     begin
-    if RUBY_PLATFORM.include? "mingw"
-      # Windows doesn't have fork
-      CR_DEFAULT_DICTS_USER_AND_NAMES.each_with_index do |name, i|
-        puts "cr: Pulling #{name}..."
-        `git -C #{CR_DEFAULT_LIBRARY} clone #{CR_DEFAULT_DICTS[i]} -q`
-      end
-    else
-      # *nix-like
-      CR_DEFAULT_DICTS_USER_AND_NAMES.each_with_index do |name, i|
-        fork do
-          puts "cr: Pulling #{name}..."
-          `git -C #{CR_DEFAULT_LIBRARY} clone #{CR_DEFAULT_DICTS[i]} -q`
+    Dir.chdir DEFAULT_LIB_PATH do
+      if Gem.win_platform?
+        # Windows doesn't have fork
+        Dir.children(DEFAULT_LIB_PATH).each do |dict|
+          next if File.file? dict
+          puts "cr: Wait to update #{dict}..."
+          `git -C ./#{dict} pull -q`
         end
-      end
-      Process.waitall
+      else
+        # *nix
+        Dir.children(DEFAULT_LIB_PATH).each do |dict|
+          next if File.file? dict
+          fork do
+            puts "cr: Wait to update #{dict}..."
+          `git -C ./#{dict} pull -q`
+          end
+        end
+        Process.waitall
+      end # end if/else
     end
 
     rescue Interrupt
-      puts "cr: Cancel add default dicts"
-      exit 1
+    abort "cr: Cancel update"
     end
 
-    puts "cr: Add done"
-    word_count(p: false)
-    puts
-    puts "#{$DefaultLibWordCount} words added"
-
-    # Really added
-    return true
-  end
-  # Not added
-  return false
-end
-
+    puts "cr: Update done"
 
-# Notice that we only update the Default library, not Extra library
-def update_dicts()
-  return if add_default_dicts_if_none_exists
+    # clear
+    @counter.word_count_of_def_lib = 0
+    # recount
+    @counter.count_def_lib(display: false)
 
-  word_count(p: false)
-  old_wc = $DefaultLibWordCount
-
-  puts "cr: Updating all dicts in Default library..."
-
-  begin
-  Dir.chdir CR_DEFAULT_LIBRARY do
-
-    if RUBY_PLATFORM.include? "mingw"
-      # Windows doesn't have fork
-      Dir.children(CR_DEFAULT_LIBRARY).each do |dict|
-        puts "cr: Wait to update #{dict}..."
-        `git -C ./#{dict} pull -q`
-      end
-    else
-      # *nix
-      Dir.children(CR_DEFAULT_LIBRARY).each do |dict|
-        fork do
-          puts "cr: Wait to update #{dict}..."
-         `git -C ./#{dict} pull -q`
-        end
-      end
-      Process.waitall
-
-    end # end if/else
-  end
-
-  rescue Interrupt
-    puts "cr: Cancel update"
-    exit 1
+    new_wc = @counter.word_count_of_def_lib
+    puts ; puts "#{new_wc - old_wc} words added in Default library"
   end
 
-  puts "cr: Update done"
-
-  # clear
-  $DefaultLibWordCount = 0
-  # recount
-  word_count(p: false)
 
-  new_wc = $DefaultLibWordCount
-
-  puts
-  puts "#{new_wc - old_wc} words added in Default library"
-
-end
-
-
-def add_dict(repo)
-  if repo.nil?
-    puts bold(red("cr: Need an argument!"))
-    exit -1
-  end
-
-  # Ensure the cr home dir exists
-  FileUtils.mkdir_p(CR_DEFAULT_LIBRARY)
+  def add_dict(repo)
+    if repo.nil?
+      abort bold(red("cr: Need an argument!"))
+    end
 
-  # Simplify adding dictionary
-  if !repo.start_with?("https://") and !repo.start_with?("git@")
-    if repo.include?('/')
-      repo = "https://github.com/#{repo}.git"
-    else
-      repo = "https://github.com/cryptic-resolver/cryptic_#{repo}.git"
+    # Simplify adding dictionary
+    if !repo.start_with?("https://") and !repo.start_with?("git@")
+      if repo.include?('/')
+        repo = "https://github.com/#{repo}.git"
+      else
+        repo = "https://github.com/cryptic-resolver/cryptic_#{repo}.git"
+      end
     end
-  end
 
-  begin
+    begin
     puts "cr: Adding new dictionary..."
-    `git -C #{CR_DEFAULT_LIBRARY} clone #{repo} -q`
-  rescue Interrupt
-    puts "cr: Cancel add dict"
-    exit 1
-  end
-
-  puts "cr: Add new dictionary done"
+    `git -C #{DEFAULT_LIB_PATH} clone #{repo} -q`
+    rescue Interrupt
+    abort "cr: Cancel add dict"
+    end
 
-  # github/com/ccmywish/ruby_knowledge(.git)
-  dict = repo.split('/')[-1].delete_suffix('.git')
-  wc = count_dict_words(CR_DEFAULT_LIBRARY ,dict)
-  puts
-  puts "#{wc} words added"
+    puts "cr: Add new dictionary done"
 
-end
+    # github/com/ccmywish/ruby_knowledge(.git)
+    dict = repo.split('/')[-1].delete_suffix('.git')
+    wc = @counter.count_dict_words(DEFAULT_LIB_PATH ,dict)
+    puts ; puts "#{wc} words added"
+  end
 
 
-def del_dict(repo)
-  if repo.nil?
-    puts bold(red("cr: Need an argument!"))
-    exit -1
-  end
-  Dir.chdir CR_DEFAULT_LIBRARY do
-    begin
+  def del_dict(repo)
+    if repo.nil?
+      abort bold(red("cr: Need an argument!"))
+    end
+    Dir.chdir DEFAULT_LIB_PATH do
+      begin
       # Dir.rmdir repo        # Can't rm a filled dir
       # FileUtils.rmdir repo  # Can't rm a filled dir
       FileUtils.rm_rf repo
       puts "cr: Delete dictionary #{bold(green(repo))} done"
-    rescue Exception => e
+      rescue Exception => e
       puts bold(red("cr: #{e}"))
       list_dicts
+      end
     end
   end
-end
-
 
-def load_sheet(library, dict, sheet_name)
-  file = library + "/#{dict}/#{sheet_name}.toml"
 
-  if File.exist? file
-    return Tomlrb.load_file file # gem 'tomlrb'
-    # return TOML.load_file file # gem 'toml'
-  else
-    nil
+  def load_sheet(library, dict, sheet_name)
+    file = library + "/#{dict}/#{sheet_name}.toml"
+    if File.exist? file
+      return Tomlrb.load_file file # gem 'tomlrb'
+      # return TOML.load_file file # gem 'toml'
+    else nil end
   end
-end
 
 
-#
-# Pretty print the info of the given word
-#
-# A info looks like this
-#   emacs = {
-#     name = "Emacs"
-#     desc = "edit macros"
-#     more = "a feature-rich editor"
-#     see  = ["Vim"]
-#   }
-#
-# @param info [Hash] the information of the given word (mapped to a keyword in TOML)
-#
-def pp_info(info)
-  name = info['name'] || red("No name!")  # keyword `or` is invalid here in Ruby
-
-  desc = info['desc']
-  more = info['more']
-
-  if desc
-    puts "\n  #{name}: #{desc}"
-    print "\n  ",more,"\n" if more
-  else
-    puts "\n  #{name}"
-    print "\n  ",more,"\n" if more
-  end
+=begin
+Pretty print the info of the given word
 
-  if see_also = info['see']
-    print "\n", purple("SEE ALSO ")
-    if see_also.is_a?(Array)
-      last_ndx = see_also.size - 1
-      see_also.each_with_index do |x,i|
-        if last_ndx == i
-          print underline(x)  # Last word doesn't show space
-        else
-          print underline(x),' '
+A info looks like this
+  emacs = {
+    name = "Emacs"
+    desc = "edit macros"
+    more = "a feature-rich editor"
+    see  = ["Vim"]
+  }
+
+@param info [Hash] the information of the given word (mapped to a keyword in TOML)
+=end
+  def pp_info(info)
+    name = info['name'] || red("No name!")  # keyword `or` is invalid here in Ruby
+
+    desc = info['desc']
+    more = info['more']
+
+    if desc
+      puts "\n  #{name}: #{desc}"
+      print "\n  ",more,"\n" if more
+    else
+      puts "\n  #{name}"
+      print "\n  ",more,"\n" if more
+    end
+
+    if see_also = info['see']
+      print "\n", purple("SEE ALSO ")
+      if see_also.is_a?(Array)
+        last_ndx = see_also.size - 1
+        see_also.each_with_index do |x,i|
+          if last_ndx == i
+            print underline(x)  # Last word doesn't show space
+          else
+            print underline(x),' '
+          end
         end
+      else
+        print underline(see_also)
       end
-    else
-      print underline(see_also)
+      puts
     end
     puts
   end
-  puts
-end
-
-# Print default cryptic_ dicts
-def pp_dict(dict)
-    puts green("From: #{dict}")
-end
-
 
-#
-# Used for synonym jump
-# Because we absolutely jump to a must-have word
-# So we can directly lookup to it
-#
-# Notice that, we must jump to a specific word definition
-# So in the toml file, you must specify the precise word.
-# If it has multiple meanings, for example
-#
-#   [blah]
-#   same = "xdg"  # this is wrong, because xdg has multiple
-#                 # definitions, and all of them specify a
-#                 # category
-#
-#   [blah]
-#   same = "XDG downloader =>xdg.Download" # this is correct
-#
-#   [blah]
-#   name = "BlaH" # You may want to display a better name first
-#   same = "XDG downloader =>xdg.Download" # this is correct
-#
-#
-def pp_same_info(library, dict, word, cache_content, same_key, own_name)
-
-  # If it's a synonym for anther word,
-  # we should lookup into this dict again, but maybe with a different file
 
-  # file name
-  x = word.chr.downcase
-
-  #
-  # dictionary maintainer must obey the rule for xxx.yyy word:
-  #   xxx should be lower case
-  #   yyy can be any case
-  #
-  # Because yyy should clearly explain the category info, IBM is better than ibm
-  # Implementation should not be too simple if we want to stress the function we
-  # expect.
-  #
-  # 'jump to' will output to user, so this is important not only inside our sheet.
-  #
-  #     same = "XDM downloader=>xdm.Download"
-  #
-  # We split 'same' key into two parts via spaceship symbol `=>`, first part will
-  # output to user, the second part is for internal jump.
-  #
-
-  jump_to, same = same_key.split("=>")
-  same =  jump_to if same.nil?
-
-  unless own_name
-    own_name = word
+  # Print default cryptic_ dicts
+  def pp_dict(dict)
+    puts green("From: #{dict}")
   end
-  puts blue(bold(own_name)) + ' redirects to ' + blue(bold(jump_to))
 
-  #
-  # As '.' is used to delimit a word and a category, what if
-  # we jump to a dotted word?
-  #
-  #   [eg]
-  #   same = "e.g." # this must lead to a wrong resolution to
-  #                 # word 'e', category 'g'
-  #
-  # All you need is to be like this:
-  #
-  #   [eg]
-  #   same = "'e.g.'" # cr will notice the single quote
-  #
 
-  if same =~ /^'(.*)'$/
-    same, category = $1, nil
-  else
-    same, category = same.split('.')
-  end
+=begin
+  Used for synonym jump
+  Because we absolutely jump to a must-have word
+  So we can directly lookup to it
 
-  if same.chr == x
-    # No need to load another dictionary if match
-    sheet_content = cache_content
-  else
-    sheet_content = load_sheet(library, dict, same.chr.downcase)
-  end
+  Notice that, we must jump to a specific word definition
+  So in the toml file, you must specify the precise word.
+  If it has multiple meanings, for example
 
-  if category.nil?
-    info = sheet_content[same]
-  else
-    info = sheet_content[same][category]
-  end
+  [blah]
+  same = "xdg"  # this is wrong, because xdg has multiple
+                # definitions, and all of them specify a
+                # category
 
-  if info.nil?
-    puts red("WARN: Synonym jumps to the wrong place `#{same}`,
-      Please consider fixing this in `#{x}.toml` of the dictionary `#{dict}`")
-    # exit
-    return false
-  # double or more jumps
-  elsif same_key = info['same']
-    own_name = info['name']
-    return pp_same_info(library, dict, same, cache_content, same_key, own_name)
-  else
-    pp_info(info)
-    return true
-  end
-end
+  [blah]
+  same = "XDG downloader =>xdg.Download" # this is correct
 
+  [blah]
+  name = "BlaH" # You may want to display a better name first
+  same = "XDG downloader =>xdg.Download" # this is correct
+=end
+  def pp_same_info(library, dict, word, cache_content, same_key, own_name)
 
+    # If it's a synonym for anther word,
+    # we should lookup into this dict again, but maybe with a different file
 
-#
-# Lookup the given word in a sheet (a toml file) and also print.
-# The core idea is that:
-#
-# 1. if the word is `same` with another synonym, it will directly jump to
-#   a word in this dictionary, but maybe a different sheet.
-#
-# 2. load the toml file and check the given word
-#   2.1 with no category specifier
-#       [abcd]
-#   2.2 with category specifier
-#       [abcd.tYPe]
-#
-def lookup(library, dict, file, word)
-  sheet_content = load_sheet(library, dict, file)
-  return false if sheet_content.nil?
+    # file name
+    x = word.chr.downcase
 
-  info = sheet_content[word]
-  return false if info.nil?
+=begin
+    dictionary maintainer must obey the rule for xxx.yyy word:
+    xxx should be lower case
+    yyy can be any case
 
-  # Warn if the info is empty. For example:
-  #   emacs = { }
-  if info.size == 0
-    puts red("WARN: Lack of everything of the given word
-      Please consider fixing this in the dict `#{dict}`")
-    exit
-  end
+    Because yyy should clearly explain the category info, IBM is better than ibm
+    Implementation should not be too simple if we want to stress the function we
+    expect.
 
+    'jump to' will output to user, so this is important not only inside our sheet.
 
-  # Word with no category specifier
-  # We call this meaning as type 1
-  type_1_exist_flag = false
+      same = "XDM downloader=>xdm.Download"
 
-  # if already jump, don't check the word itself
-  is_jump = false
+    We split 'same' key into two parts via spaceship symbol `=>`, first part will
+    output to user, the second part is for internal jump.
+=end
+    jump_to, same = same_key.split("=>")
+    same =  jump_to if same.nil?
 
-  # synonym info print
-  if same_key = info['same']
-    own_name = info['name']
-    pp_dict(dict)
-    pp_same_info(library, dict, word, sheet_content, same_key, own_name)
-    # It's also a type 1
-    type_1_exist_flag = true
-    is_jump = true
-  end
+    unless own_name
+      own_name = word
+    end
+    puts blue(bold(own_name)) + ' redirects to ' + blue(bold(jump_to))
 
-  # normal info print
-  # To developer:
-  #   The word should at least has one of `desc` and `more`
-  #   But when none exists, this may not be considered wrong,
-  #   Because the type2 make the case too.
-  #
-  #   So, just ignore it, even if it's really a mistake(insignificant)
-  #   by dictionary maintainers.
-  #
-  if !is_jump && (info.has_key?('desc') || info.has_key?('more'))
-    pp_dict(dict)
-    pp_info(info)
-    type_1_exist_flag = true
-  end
+=begin
+    As '.' is used to delimit a word and a category, what if
+    we jump to a dotted word?
 
-  # Meanings with category specifier
-  # We call this meaning as type 2
-  categories = info.keys - ["name", "desc", "more", "same", "see"]
+      [eg]
+      same = "e.g." # this must lead to a wrong resolution to
+                    # word 'e', category 'g'
 
-  if !categories.empty?
+      All you need is to be like this:
 
-    if type_1_exist_flag
-      print  blue(bold("OR")),"\n"
+      [eg]
+      same = "'e.g.'" # cr will notice the single quote
+=end
+    if same =~ /^'(.*)'$/
+      same, category = $1, nil
     else
-      pp_dict(dict)
+      same, category = same.split('.')
     end
 
-    categories.each do |meaning|
-      info0 = sheet_content[word][meaning]
-      if same_key = info0['same']
-        own_name = info0['name']
-        pp_same_info(library, dict, word, sheet_content, same_key, own_name)
-      else
-        pp_info(info0)
-      end
-
-      # last meaning doesn't show this separate line
-      print  blue(bold("OR")),"\n" unless categories.last == meaning
+    if same.chr == x
+      # No need to load another dictionary if match
+      sheet_content = cache_content
+    else
+      sheet_content = load_sheet(library, dict, same.chr.downcase)
     end
-    return true
-  elsif type_1_exist_flag
-    return true
-  else
-    return false
-  end
-end
-
-
-#
-# The main procedure of `cr`
-#
-#   1. Search the default library first
-#   2. Search the extra library if it does exist
-#
-# The `search` is done via the `lookup` function. It will print
-# the info while finding. If `lookup` always return false then
-# means lacking of this word in our dicts. So a welcomed
-# contribution is printed on the screen.
-#
-def resolve_word(word)
 
-  add_default_dicts_if_none_exists
-
-  word = word.downcase # downcase! would lead to frozen error in Ruby 2.7.2
-  # The index is the toml file we'll look into
-  index = word.chr
-  case index
-  when '0'..'9'
-    index = '0-9'
-  end
-
-  # cache lookup's results
-  results = []
-
-  # First consider the default library
-  default = Dir.children(CR_DEFAULT_LIBRARY)
-  default.each do |dict|
-    results << lookup(CR_DEFAULT_LIBRARY,dict,index,word)
-  end
+    if category.nil?
+      info = sheet_content[same]
+    else
+      info = sheet_content[same][category]
+    end
 
-  # Then is the extra library
-  if CR_EXTRA_LIBRARY
-    extra = Dir.children(CR_EXTRA_LIBRARY)
-    extra.each do |dict|
-      results << lookup(CR_EXTRA_LIBRARY,dict,index,word)
+    if info.nil?
+      puts red("WARN: Synonym jumps to the wrong place `#{same}`,
+      Please consider fixing this in `#{x}.toml` of the dictionary `#{dict}`")
+      # exit
+      return false
+    # double or more jumps
+    elsif same_key = info['same']
+      own_name = info['name']
+      return pp_same_info(library, dict, same, cache_content, same_key, own_name)
+    else
+      pp_info(info)
+      return true
     end
   end
 
-  unless results.include? true
-    puts <<-NotFound
-cr: Not found anything.
-
-You could
-
-  #{blue("case 1: Update all dicts")}
-
-    #{yellow("$cr -u")}
-
-  #{blue("case 2: List available official and feature dicts")}
 
-    #{yellow("$cr -l")}
 
-    #{yellow("$cr -a repo")} (Add a specific dict to default lib)
-
-  #{blue("case 3: Contribute to theses dicts")}
-
-    Visit: https://github.com/cryptic-resolver
+  #
+  # Lookup the given word in a sheet (a toml file) and also print.
+  # The core idea is that:
+  #
+  # 1. if the word is `same` with another synonym, it will directly jump to
+  #   a word in this dictionary, but maybe a different sheet.
+  #
+  # 2. load the toml file and check the given word
+  #   2.1 with no category specifier
+  #       [abcd]
+  #   2.2 with category specifier
+  #       [abcd.tYPe]
+  #
+  def lookup(library, dict, file, word)
+    sheet_content = load_sheet(library, dict, file)
+    return false if sheet_content.nil?
 
-NotFound
+    info = sheet_content[word]
+    return false if info.nil?
 
-  else
-    return
-  end
+    # Warn if the info is empty. For example:
+    #   emacs = { }
+    if info.size == 0
+      abort red("WARN: Lack of everything of the given word
+      Please consider fixing this in the dict `#{dict}`")
+    end
 
-end
+    # Word with no category specifier
+    # We call this meaning as type 1
+    type_1_exist_flag = false
 
+    # if already jump, don't check the word itself
+    is_jump = false
 
-#
-# Delegate to `search_word_internal`
-#
-def search_word(pattern)
-  found_or_not1 = false
-  found_or_not2 = false
+    # synonym info print
+    if same_key = info['same']
+      own_name = info['name']
+      pp_dict(dict)
+      pp_same_info(library, dict, word, sheet_content, same_key, own_name)
+      # It's also a type 1
+      type_1_exist_flag = true
+      is_jump = true
+    end
 
-  found_or_not1 = search_word_internal(pattern, CR_DEFAULT_LIBRARY)
-  if CR_EXTRA_LIBRARY
-    found_or_not2 = search_word_internal(pattern, CR_EXTRA_LIBRARY)
-  end
+    # normal info print
+    # To developer:
+    #   The word should at least has one of `desc` and `more`
+    #   But when none exists, this may not be considered wrong,
+    #   Because the type2 make the case too.
+    #
+    #   So, just ignore it, even if it's really a mistake(insignificant)
+    #   by dictionary maintainers.
+    #
+    if !is_jump && (info.has_key?('desc') || info.has_key?('more'))
+      pp_dict(dict)
+      pp_info(info)
+      type_1_exist_flag = true
+    end
 
-  if (found_or_not1 == false) && (found_or_not2 == false)
-    puts red("cr: No words match with #{pattern.inspect}")
-    puts
-  end
-end
+    # Meanings with category specifier
+    # We call this meaning as type 2
+    categories = info.keys - ["name", "desc", "more", "same", "see"]
 
-#
-# This `search_word_internal` routine is quite like `resolve_word`
-# Notice:
-#   We handle two cases
-#
-#   1. the 'pattern' is the regexp itself
-#   2. the 'pattern' is like '/blah/'
-#
-#  The second is what Ruby and Perl users like to do, handle it!
-#
-def search_word_internal(pattern, library)
+    if !categories.empty?
 
-  if pattern.nil?
-    puts bold(red("cr: Need an argument!"))
-    exit -1
-  end
+      if type_1_exist_flag
+        print  blue(bold("OR")),"\n"
+      else
+        pp_dict(dict)
+      end
 
-  add_default_dicts_if_none_exists
+      categories.each do |meaning|
+        info0 = sheet_content[word][meaning]
+        if same_key = info0['same']
+          own_name = info0['name']
+          pp_same_info(library, dict, word, sheet_content, same_key, own_name)
+        else
+          pp_info(info0)
+        end
 
-  if pattern =~ /^\/(.*)\/$/
-    regexp = %r[#$1]
-  else
-    regexp = %r[#{pattern}]
+        # last meaning doesn't show this separate line
+        print  blue(bold("OR")),"\n" unless categories.last == meaning
+      end
+      return true
+    elsif type_1_exist_flag then return true
+    else return false end
   end
 
-  found_or_not = false
 
   #
-  # Try to match every word in all dicts
+  # The main procedure of `cr`
+  #
+  #   1. Search the default library first
+  #   2. Search the extra library if it does exist
   #
-  Dir.children(library).each do |dict|
-    sheets = Dir.children(File.join(library, dict)).select do
-      _1.end_with?('.toml')
+  # The `search` is done via the `lookup` function. It will print
+  # the info while finding. If `lookup` always return false then
+  # means lacking of this word in our dicts. So a welcomed
+  # contribution is printed on the screen.
+  #
+  def resolve_word(word)
+
+    word = word.downcase # downcase! would lead to frozen error in Ruby 2.7.2
+    # The index is the toml file we'll look into
+    index = word.chr
+    case index
+    when '0'..'9'
+      index = '0-9'
     end
 
-    similar_words_in_a_dict = []
-
-    sheets.each do |sheet|
-      sheet_content = load_sheet(library, dict, File.basename(sheet,'.toml'))
+    # cache lookup's results
+    results = []
 
-      sheet_content.keys.each do
-        if _1 =~ regexp
-          found_or_not = true
-          similar_words_in_a_dict << _1
-        end
-      end
-    # end of each sheet in a dict
+    # First consider the default library
+    default = Dir.children(DEFAULT_LIB_PATH)
+    default.each do |dict|
+      results << lookup(DEFAULT_LIB_PATH,dict,index,word)
     end
 
-    unless similar_words_in_a_dict.empty?
-      pp_dict(dict)
-      require 'ls_table'
-      LsTable.ls(similar_words_in_a_dict) do |e|
-        puts blue(e)
+    # Then is the extra library
+    if @extra_lib_path
+      extra = Dir.children(@extra_lib_path)
+      extra.each do |dict|
+        results << lookup(@extra_lib_path,dict,index,word)
       end
-      puts
     end
-  end
-  return found_or_not
-end
 
+    unless results.include? true
+      puts <<~NotFound
+      cr: Not found anything.
 
-def help
-  word_count(p: false)
-  puts <<-HELP
-cr: Cryptic Resolver v#{CR_GEM_VERSION} (#{$TwoLibWordCount} words: Default lib/#{$DefaultLibWordCount} && Extra lib/#{$ExtraLibWordCount})
+      You could
 
-Usage:
+      #{blue("case 1: Update all dicts")}
 
-  cr emacs          => Edit macros: A feature-rich editor
-  cr -c             => Print word count
-  cr -l             => List local dicts and official dicts
-  cr -u             => Update all dicts in Default library
+        #{yellow("$cr -u")}
 
-  cr -a repo.git    => Add a new dict
-  cr -a user/repo   => Add a new dict from Github
-  cr -a  repo       => Add an official dict from Github
+      #{blue("case 2: List available official and feature dicts")}
 
-  cr -d cryptic_xx  => Delete a dict
-  cr -s pattern     => Search words matched with pattern
-  cr -v             => Print version
-  cr -h             => Print this help
+        #{yellow("$cr -l")}
 
-HELP
+        #{yellow("$cr -a repo")} (Add a specific dict to default lib)
 
-  add_default_dicts_if_none_exists
+      #{blue("case 3: Contribute to theses dicts")}
 
-end
+        Visit: https://github.com/cryptic-resolver
 
+      NotFound
+    else return end
+  end
 
-def print_version
-  puts "cr: Cryptic Resolver version #{CR_GEM_VERSION} in Ruby "
-end
 
+  #
+  # Delegate to `search_word_internal`
+  #
+  def search_word(pattern)
+    found_or_not1 = false
+    found_or_not2 = false
 
-#
-# 1. List Default library's dicts
-# 2. List Extra   library's dicts
-# 3. List official dicts
-#
-def list_dicts
-  Dir.chdir CR_DEFAULT_LIBRARY do
-    puts blue("=> Default library: #{CR_DEFAULT_LIBRARY}")
-    Dir.children(CR_DEFAULT_LIBRARY).each_with_index do |dict,i|
-      puts "#{blue(i+1)}. #{bold(green(dict))}"
+    found_or_not1 = search_word_internal(pattern, DEFAULT_LIB_PATH)
+    if @extra_lib_path
+      found_or_not2 = search_word_internal(pattern, @extra_lib_path)
     end
-  end
 
-  if CR_EXTRA_LIBRARY
-    puts
-    Dir.chdir CR_EXTRA_LIBRARY do
-      puts blue("=> Extra library: #{CR_EXTRA_LIBRARY}")
-      Dir.children(CR_EXTRA_LIBRARY).each_with_index do |dict,i|
-        puts "#{blue(i+1)}. #{bold(green(dict))}"
-      end
+    if (found_or_not1 == false) && (found_or_not2 == false)
+      puts red("cr: No words match with #{pattern.inspect}") ; puts
     end
   end
 
-  puts
-  puts blue("=> Official dicts: (Add it by 'cr -a xxx')")
-  puts CR_OFFICIAL_DICTS
-
-end
-
-
-# Two libraries word count (Default library + Extra library)
-$TwoLibWordCount = 0
-# Default library word count
-$DefaultLibWordCount = 0
-#  Extra  library word count
-$ExtraLibWordCount   = 0
-
-def count_dict_words(library, dict)
+  #
+  # This `search_word_internal` routine is quite like `resolve_word`
+  # Notice:
+  #   We handle two cases
+  #
+  #   1. the 'pattern' is the regexp itself
+  #   2. the 'pattern' is like '/blah/'
+  #
+  #  The second is what Ruby and Perl users like to do, handle it!
+  #
+  def search_word_internal(pattern, library)
 
-  dict_dir = library + "/#{dict}"
+    if pattern.nil?
+      abort bold(red("cr: Need an argument!"))
+    end
 
-  wc = 0
+    if pattern =~ /^\/(.*)\/$/
+      regexp = %r[#$1]
+    else
+      regexp = %r[#{pattern}]
+    end
 
-  Dir.children(dict_dir).each do |entry|
-    next unless entry.end_with?('.toml')
-    sheet_content = load_sheet(library, dict, entry.delete_suffix('.toml'))
-    count = sheet_content.keys.count
+    found_or_not = false
 
-    wc = wc + count
-  end
-  return wc
-end
+    # Try to match every word in all dicts
+    Dir.children(library).each do |dict|
+      sheets = Dir.children(File.join(library, dict)).select do
+        _1.end_with?('.toml')
+      end
 
+      similar_words_in_a_dict = []
 
-def word_count(p:)
-  # Always check before Dir.children (this method creates dir if not exists)
-  is_there_any_dict?
+      sheets.each do |sheet|
+        sheet_content = load_sheet(library, dict, File.basename(sheet,'.toml'))
 
-  default_lib = Dir.children(CR_DEFAULT_LIBRARY)
+        sheet_content.keys.each do
+          if _1 =~ regexp
+            found_or_not = true
+            similar_words_in_a_dict << _1
+          end
+        end
+      # end of each sheet in a dict
+      end
 
-  # Count default library
-  unless default_lib.empty?
-    puts(bold(green("Default library: "))) if p
-    default_lib.each do |s|
-      wc = count_dict_words(CR_DEFAULT_LIBRARY,s)
-      $DefaultLibWordCount += wc
-      # With color, ljust not works, so we disable color
-      puts("  #{s.ljust(17)}: #{wc}") if p
+      unless similar_words_in_a_dict.empty?
+        pp_dict(dict)
+        require 'ls_table'
+        LsTable.ls(similar_words_in_a_dict) do |e|
+          puts blue(e)
+        end
+        puts
+      end
     end
+    return found_or_not
   end
 
 
-  if CR_EXTRA_LIBRARY
-    extra_lib = Dir.children(CR_EXTRA_LIBRARY)
-    extra_lib.reject! do |f|
-      File.file? f
+  # 1. List Default library's dicts
+  # 2. List Extra   library's dicts
+  # 3. List official dicts
+  def list_dicts
+    Dir.chdir DEFAULT_LIB_PATH do
+      puts blue("=> Default library: #{DEFAULT_LIB_PATH}")
+      Dir.children(DEFAULT_LIB_PATH).each_with_index do |dict,i|
+        puts "#{blue(i+1)}. #{bold(green(dict))}"
+      end
     end
-    # Count extra library
-    unless extra_lib.empty?
-      wc = 0
-      puts(bold(blue("\nExtra library:"))) if p
-      extra_lib.each do |s|
-        wc = count_dict_words(CR_EXTRA_LIBRARY,s)
-        $ExtraLibWordCount += wc
-        puts("  #{s.ljust(17)}: #{wc}") if p
+
+    if @extra_lib_path
+      puts
+      Dir.chdir @extra_lib_path do
+        puts blue("=> Extra library: #{@extra_lib_path}")
+        Dir.children(@extra_lib_path).each_with_index do |dict,i|
+          puts "#{blue(i+1)}. #{bold(green(dict))}"
+        end
       end
     end
+
+    puts ; puts blue("=> Official dicts: (Add it by 'cr -a xxx')")
+    puts RECOMMENDED_DICTS
   end
-  $TwoLibWordCount = $DefaultLibWordCount + $ExtraLibWordCount
 
-  if p
-  puts
-  puts "#{$DefaultLibWordCount.to_s.rjust(4)} words in Default library"
-  puts "#{$ExtraLibWordCount.to_s.rjust(4)  } words in  Extra  library"
-  puts "#{$TwoLibWordCount.to_s.rjust(4)    } words altogether"
+
+  def word_count
+    @counter.count!(display: true)
   end
-end
 
+end
 
 ####################
 # main: CLI Handling
 ####################
-arg = ARGV.shift
-
-case arg
-when nil    then help
-when '-v'   then print_version
-when '-h'   then help
-when '-l'   then list_dicts
-when '-c'   then word_count(p: true)
-when '-u'   then update_dicts
-when '-s'   then search_word ARGV.shift
-when '-a'   then add_dict ARGV.shift
-when '-d'   then del_dict ARGV.shift
-when '--help'
-  help
-else
-  resolve_word arg
-end
+cli = CrypticResolver::CliHandler.new ARGV