cr.rb 3.17.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7bcff493846a9384661cdbeccdb88a225d5f0a7b180f97e04feeda0ba3e1c5e4
+  data.tar.gz: a4916f5e641026b1905ccd88c3e7f4ab94f55aff93be0caca2b2a4e6cc75cbc6
+SHA512:
+  metadata.gz: 100baa0634561310d3cbaa612b3cebb2b22d59215bdb4c0f19d74bbf6c5517fc10f80c75b289dd1fe3e2c3b1583a2198f5413a0018e8d9b135bbe0b65f23db45
+  data.tar.gz: 90a547412b1a4139dd49e93459ef0873501a3b796fee0b616922532746bdaec43d5eec8caca3820e9c3f5233c6fd826e452494952b7f1253d45cac76f1d6f6f3

data/bin/cr

@@ -0,0 +1,714 @@
+#!/usr/bin/env ruby
+# coding: utf-8
+# ------------------------------------------------------
+# File          : cr.rb
+# Authors       : ccmywish <ccmywish@qq.com>
+# Created on    : <2021-07-08>
+# Last modified : <2022-04-11>
+#
+# cr:
+#
+#   This file is used to explain a CRyptic command
+# or an acronym's real meaning in computer world or 
+# other fields.  
+#
+# ------------------------------------------------------
+
+require 'tomlrb'
+require 'fileutils'
+
+CRYPTIC_RESOLVER_HOME = File.expand_path("~/.cryptic-resolver")
+CRYPTIC_DEFAULT_DICTS = {
+  computer: "https://github.com/cryptic-resolver/cryptic_computer.git",
+  common:   "https://github.com/cryptic-resolver/cryptic_common.git",
+  science:  "https://github.com/cryptic-resolver/cryptic_science.git",
+  economy:  "https://github.com/cryptic-resolver/cryptic_economy.git",
+  medicine: "https://github.com/cryptic-resolver/cryptic_medicine.git"
+}
+
+CR_GEM_VERSION = "3.17.0"
+
+
+####################
+# 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
+
+
+####################
+# core: logic
+####################
+
+def is_there_any_dict?
+  unless Dir.exist? CRYPTIC_RESOLVER_HOME
+    Dir.mkdir CRYPTIC_RESOLVER_HOME
+  end
+
+  !Dir.empty? CRYPTIC_RESOLVER_HOME 
+end
+
+
+def add_default_dicts_if_none_exists
+  unless is_there_any_dict?
+    puts "cr: Adding default dictionaries..."
+
+    begin
+    if RUBY_PLATFORM.include? "mingw"
+      # Windows doesn't have fork
+      CRYPTIC_DEFAULT_DICTS.each do |key, dict|
+        puts "cr: Pulling cryptic_#{key}..."
+        `git -C #{CRYPTIC_RESOLVER_HOME} clone #{dict} -q`
+      end
+    else
+      # *nix
+      CRYPTIC_DEFAULT_DICTS.each do |key, dict|
+        fork do 
+          puts "cr: Pulling cryptic_#{key}..."
+          `git -C #{CRYPTIC_RESOLVER_HOME} clone #{dict} -q`
+        end
+      end
+      Process.waitall      
+    end
+
+    rescue Interrupt
+      puts "cr: Cancel add default dicts"
+      exit 1
+    end
+    
+    puts "cr: Add done"
+    word_count(p: false)
+    puts 
+    puts "#{$WordCount} words added"
+    
+    # Really added
+    return true
+  end
+  # Not added
+  return false
+end
+
+
+def update_dicts()
+  return if add_default_dicts_if_none_exists
+
+  word_count(p: false)
+  old_wc = [$DefaultWordCount, $WordCount-$DefaultWordCount, $WordCount]
+
+  puts "cr: Updating all dictionaries..."
+
+  begin
+  Dir.chdir CRYPTIC_RESOLVER_HOME do 
+    
+    if RUBY_PLATFORM.include? "mingw"
+      # Windows doesn't have fork
+      Dir.children(CRYPTIC_RESOLVER_HOME).each do |dict|
+        puts "cr: Wait to update #{dict}..."
+        `git -C ./#{dict} pull -q`
+      end
+    else
+      # *nix
+      Dir.children(CRYPTIC_RESOLVER_HOME).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
+  end
+
+
+  puts "cr: Update done"
+
+  # clear
+  $DefaultWordCount, $WordCount = 0, 0
+  # recount
+  word_count(p: false)
+  new_wc = [$DefaultWordCount, $WordCount-$DefaultWordCount, $WordCount]
+  diff = []
+  new_wc.each_with_index do 
+    diff[_2] = _1 - old_wc[_2]
+  end
+
+  puts
+  puts "#{diff.[]2} words added: default/#{diff.[]0} user/#{diff.[]1}"
+
+end
+
+
+def add_dict(repo)
+  if repo.nil? 
+    puts bold(red("cr: Need an argument!"))
+    exit -1
+  end
+
+  begin
+    puts "cr: Adding new dictionary..."
+    `git -C #{CRYPTIC_RESOLVER_HOME} clone #{repo} -q`
+  rescue Interrupt
+    puts "cr: Cancel add dict"
+    exit 1
+  end
+
+  puts "cr: Add new dictionary done"
+
+  # github/com/ccmywish/ruby_knowledge(.git)
+  dict = repo.split('/')[-1].delete_suffix('.git')
+  count_dict_words(dict)
+  puts
+  puts "#$WordCount words added"
+
+end
+
+
+def del_dict(repo)
+  if repo.nil? 
+    puts bold(red("cr: Need an argument!"))
+    exit -1
+  end
+  Dir.chdir CRYPTIC_RESOLVER_HOME 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
+      puts bold(red("cr: #{e}"))
+      list_dictionaries
+    end
+  end
+end
+
+
+def load_sheet(dict, sheet_name)
+  file = CRYPTIC_RESOLVER_HOME + "/#{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
+
+
+#
+# Pretty print the info of the given word
+#
+# A info looks like this
+#   emacs = {
+#     disp = "Emacs" 
+#     desc = "edit macros"
+#     full = "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)
+  disp = info['disp'] || red("No name!")  # keyword `or` is invalid here in Ruby
+  
+  desc = info['desc']
+  full = info['full']
+  
+  if desc 
+    puts "\n  #{disp}: #{desc}"
+    print "\n  ",full,"\n" if full
+  else
+    puts "\n  #{disp}"
+    print "\n  ",full,"\n" if full
+  end
+
+  if see_also = info['see']
+    print "\n", purple("SEE ALSO ")
+    see_also.each {|x| print underline(x),' '}
+    puts
+  end 
+  puts
+end
+
+# Print default cryptic_ dictionaries
+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]
+#   disp = "BlaH" # You may want to display a better name first
+#   same = "XDG downloader <=>xdg.Download" # this is correct
+#
+#
+def pp_same_info(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
+  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
+  
+  if same.chr == x
+    # No need to load another dictionary if match
+    sheet_content = cache_content
+  else
+    sheet_content = load_sheet(dict, same.chr.downcase)
+  end
+
+  if category.nil?
+    info = sheet_content[same]
+  else
+    info = sheet_content[same][category]
+  end
+
+  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['disp']
+    return pp_same_info(dict, same, cache_content, same_key, own_name)
+  else
+    pp_info(info)
+    return true
+  end
+end
+
+
+
+#
+# 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(dict, file, word)
+  sheet_content = load_sheet(dict, file) 
+  return false if sheet_content.nil?
+
+  info = sheet_content[word]
+  return false if info.nil?
+
+  # 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
+
+
+
+  # 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 
+
+  # synonym info print
+  if same_key = info['same']
+    own_name = info['disp']
+    pp_dict(dict)
+    pp_same_info(dict, word, sheet_content, same_key, own_name)
+    # It's also a type 1
+    type_1_exist_flag = true
+    is_jump = true
+  end
+
+  # normal info print
+  # To developer:
+  #   The word should at least has one of `desc` and `full`
+  #   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?('full'))
+    pp_dict(dict)
+    pp_info(info)
+    type_1_exist_flag = true
+  end
+
+  # Meanings with category specifier
+  # We call this meaning as type 2
+  categories = info.keys - ["disp", "desc", "full", "same", "see"]
+
+  if !categories.empty?
+
+    if type_1_exist_flag
+      print  blue(bold("OR")),"\n"
+    else
+      pp_dict(dict)
+    end
+
+    categories.each do |meaning|
+      info0 = sheet_content[word][meaning]
+      if same_key = info0['same']
+        own_name = info0['disp']
+        pp_same_info(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
+    end
+    return true
+  elsif type_1_exist_flag
+    return true
+  else
+    return false
+  end
+end
+
+
+#
+# The main procedure of `cr`
+#   1. Search the default's first dict first
+#   2. Search the rest dictionaries in the cryptic dictionaries default dir
+# 
+# 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 dictionaries. So a welcomed
+# contribution is printed on the screen.
+#
+def solve_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 = '0123456789'
+  end
+  
+  # Default's first should be 1st to consider
+  first_dict = "cryptic_" + CRYPTIC_DEFAULT_DICTS.keys[0].to_s # When Ruby3, We can use DICTS.key(0)
+
+  # cache lookup results
+  results = []
+  results << lookup(first_dict,index,word)
+  # return if result == true # We should consider all dicts
+
+  # Then else
+  rest = Dir.children(CRYPTIC_RESOLVER_HOME)
+  rest.delete first_dict
+  rest.each do |dict|
+    results << lookup(dict,index,word)
+    # continue if result == false # We should consider all dicts
+  end
+
+  unless results.include? true
+    puts <<-NotFound
+cr: Not found anything.
+
+You may use `cr -u` to update all dictionaries.
+Or you could contribute to:
+
+  1. computer:   #{CRYPTIC_DEFAULT_DICTS[:computer]}
+  2. common:     #{CRYPTIC_DEFAULT_DICTS[:common]}
+  3. science:    #{CRYPTIC_DEFAULT_DICTS[:science]}
+  4. economy:    #{CRYPTIC_DEFAULT_DICTS[:economy]}
+  5. medicine:   #{CRYPTIC_DEFAULT_DICTS[:medicine]}
+
+NotFound
+
+  else
+    return
+  end
+  
+end
+
+
+
+#
+# The search word process is quite like `solve_word``
+# Notice:
+#   We handle two cases
+#   
+#   1. the 'pattern' is the regexp itself
+#   2. the 'pattern' is like '/blahblah/'
+#                       
+#  The second is what Ruby and Perl users like to do, handle it!
+#
+def search_word(pattern)
+
+  if pattern.nil? 
+    puts bold(red("cr: Need an argument!"))
+    exit -1
+  end
+
+  add_default_dicts_if_none_exists
+
+  if pattern =~ /^\/(.*)\/$/
+    regexp = %r[#$1]
+  else
+    regexp = %r[#{pattern}]
+  end
+  
+  found = false
+
+  #
+  # Try to match every word in all dictionaries
+  #
+  Dir.children(CRYPTIC_RESOLVER_HOME).each do |dict|
+    sheets = Dir.children(File.join(CRYPTIC_RESOLVER_HOME, dict)).select do
+      _1.end_with?('.toml')
+    end
+
+    similar_words_in_a_dict = []
+
+    sheets.each do |sheet|
+      sheet_content = load_sheet(dict, File.basename(sheet,'.toml'))
+
+      sheet_content.keys.each do 
+        if _1 =~ regexp
+          found = true
+          similar_words_in_a_dict << _1
+        end
+      end
+    # end of each sheet in a dict
+    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)
+      end
+      puts 
+    end
+  end
+  if !found
+    puts red("cr: No words match with #{regexp.inspect}")
+    puts
+  end
+end
+
+
+def help
+  word_count(p: false)
+  user_words = $WordCount - $DefaultWordCount
+  puts <<-HELP
+cr: Cryptic Resolver v#{CR_GEM_VERSION} (#{$WordCount} words: default/#{$DefaultWordCount} user/#{user_words})
+
+usage:
+  cr -v                  => Print version
+  cr -h                  => Print this help
+  cr -c                  => Print word count
+  cr -l                  => List local dictionaries
+  cr -u                  => Update all dictionaries
+  cr -a xx.com/repo.git  => Add a new dictionary
+  cr -d cryptic_xx       => Delete a dictionary
+  cr -s pattern          => Search words matched with pattern
+  cr emacs               => Edit macros: a feature-rich editor
+
+HELP
+
+  add_default_dicts_if_none_exists
+
+end
+
+
+def print_version
+  puts "cr: Cryptic Resolver version #{CR_GEM_VERSION} in Ruby "
+end
+
+
+def list_dictionaries
+  Dir.chdir CRYPTIC_RESOLVER_HOME do 
+    Dir.children(CRYPTIC_RESOLVER_HOME).each_with_index do |dict,i|
+      puts "#{blue(i+1)}. #{bold(green(dict))}"
+    end
+  end
+end
+
+
+# All dictionaries word count
+$WordCount = 0
+# Default dictionaries word count
+$DefaultWordCount = 0
+
+def count_dict_words(dict)
+  
+  dict_dir = CRYPTIC_RESOLVER_HOME + "/#{dict}"
+  
+  wc = 0
+
+  Dir.children(dict_dir).each do |entry|
+    next unless entry.end_with?('.toml')
+    sheet_content = load_sheet(dict, entry.delete_suffix('.toml'))
+    count = sheet_content.keys.count
+  
+    # puts "#{entry}: #{count}"
+    wc = wc + count
+  end
+
+  $WordCount += wc
+
+  return wc
+
+end
+
+
+def word_count(p:)
+
+  # Always check before Dir.children (this method creates dir if not exists)
+  is_there_any_dict?
+
+  # real dicts in user's directory
+  locals = []
+  Dir.children(CRYPTIC_RESOLVER_HOME).each do |dict|
+    locals << dict
+  end
+
+  # pre-defined default
+  defaults = CRYPTIC_DEFAULT_DICTS.keys.map do |s|
+    "cryptic_#{s}"
+  end
+
+  # user may delete some default dicts
+  defaults &= locals
+
+  unless defaults.empty?
+    puts(bold(green("Default dict: "))) if p
+    defaults.each do |s|
+      wc = count_dict_words(s)
+      $DefaultWordCount += wc
+      # With color, ljust not works, so we disable color
+      puts("  #{s.ljust(17)}: #{wc}") if p
+    end
+  end
+
+  users = locals - defaults
+  user_words = 0
+  unless users.empty?
+    wc = 0
+    puts(bold(blue("\nUser's dict:"))) if p
+    users.each do |s|
+      wc = count_dict_words(s)
+      # no need to add to $WordCount，
+      # because it's done in `count_dict_words` func
+      puts("  #{s.ljust(17)}: #{wc}") if p
+    end
+
+    user_words = $WordCount - $DefaultWordCount
+  end
+
+  if p 
+  puts
+  puts "#{$DefaultWordCount.to_s.rjust(4)} words in default dictionaries"
+  puts "#{user_words.to_s.rjust(4)} words in user's  dictionaries"
+  puts "#{$WordCount.to_s.rjust(4)} words altogether"
+  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_dictionaries
+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
+  solve_word arg
+end
+ 

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: cr.rb
+version: !ruby/object:Gem::Version
+  version: 3.17.0
+platform: ruby
+authors:
+- ccmywish
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-04-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: tomlrb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: ls_table
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+description: |
+  This command line tool `cr` is used to record and explain cryptic commands, acronyms(initialism), abbreviations and so forth in daily life.
+  Not only can it be used in computer filed via our default sheet cryptic_computer, but also you can use this to manage your own knowledge base easily.
+email: ccmywish@qq.com
+executables:
+- cr
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/cr
+homepage: https://github.com/cryptic-resolver/cr
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/cryptic-resolver/cr/issues
+  source_code_uri: https://github.com/cryptic-resolver/cr
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key: 
+specification_version: 4
+summary: 'cr: Cryptic Resolver'
+test_files: []