vimamsa 0.1.0 → 0.1.1

data/lib/vimamsa/encrypt.rb

@@ -0,0 +1,47 @@
+
+require "openssl"
+
+class Encrypt
+  def initialize(pass_phrase)
+    salt = "uvgixEtU"
+    @enc = OpenSSL::Cipher.new "AES-128-CBC"
+    @enc.encrypt
+    @enc.pkcs5_keyivgen pass_phrase, salt
+    @dec = OpenSSL::Cipher.new "AES-128-CBC"
+    @dec.decrypt
+    @dec.pkcs5_keyivgen pass_phrase, salt
+  end
+
+  def encrypt(text)
+    cipher=@enc
+    encrypted = cipher.update text
+    encrypted << cipher.final
+    encrypted = encrypted.unpack('H*')[0].upcase
+    @enc.reset
+    return encrypted
+  end
+
+  def decrypt(encrypted)
+    cipher=@dec
+    encrypted = [encrypted].pack("H*").unpack("C*").pack("c*")
+    plain = cipher.update encrypted
+    plain << cipher.final
+    plain.force_encoding("utf-8")
+    @dec.reset
+    return plain
+  end
+end
+
+def decrypt_cur_buffer(password, b = nil)
+  $buffer.decrypt(password)
+end
+
+def encrypt_cur_buffer()
+  callback = proc{|x|encrypt_cur_buffer_callback(x)}
+  gui_one_input_action("Encrypt", "Password:", "Encrypt", callback)
+end
+
+def encrypt_cur_buffer_callback(password,b=nil)
+  $buffer.set_encrypted(password)
+end
+

data/lib/vimamsa/file_finder.rb

@@ -0,0 +1,103 @@
+require "parallel"
+
+class FileFinder
+  def initialize()
+    $hook.register(:shutdown, self.method("save"))
+    $dir_list = vma.marshal_load("file_index")
+  end
+
+  def save()
+    vma.marshal_save("file_index", $dir_list)
+  end
+
+  def start_gui()
+    if $search_dirs.empty?
+      message("FileFinder: No $search_dirs defined")
+      return
+    end
+    l = []
+    $select_keys = ["h", "l", "f", "d", "s", "a", "g", "z"]
+    if $dir_list == nil
+      Thread.new { recursively_find_files() }
+    end
+
+    qt_select_update_window(l, $select_keys.collect { |x| x.upcase },
+                            "gui_file_finder_select_callback",
+                            "gui_file_finder_update_callback")
+  end
+end
+
+def update_file_index()
+  message("Start updating file index")
+  Thread.new {
+    recursively_find_files()
+    message("Finnish updating file index")
+  }
+end
+
+def recursively_find_files()
+  debug("START find files")
+  dlist = []
+
+  for d in $search_dirs
+    debug("FIND FILEs IN #{d}")
+    dlist = dlist + Dir.glob("#{d}/**/*").select { |e| File.file?(e) and $find_extensions.include?(File.extname(e)) }
+    debug("FIND FILEs IN #{d} END")
+  end
+  #$dir_list = Dir.glob('./**/*').select { |e| File.file? e }
+  debug("END find files2")
+  $dir_list = dlist
+  debug("END find files")
+  return $dir_list
+end
+
+def filter_files(search_str)
+  dir_hash = {}
+  scores = Parallel.map($dir_list, in_threads: 8) do |file|
+    [file, srn_dst(search_str, file)]
+  end
+  for s in scores
+    dir_hash[s[0]] = s[1] if s[1] > 0
+  end
+  # puts scores
+  dir_hash = dir_hash.sort_by { |k, v| -v }
+  dir_hash = dir_hash[0..20]
+  dir_hash.map do |file, d|
+    puts "D:#{d} #{file}"
+  end
+  return dir_hash
+end
+
+def gui_file_finder_update_callback(search_str = "")
+  puts "FILE FINDER UPDATE CALLBACK: #{search_str}"
+  if (search_str.size > 1)
+    files = filter_files(search_str)
+    $file_search_list = files
+    return files
+    #puts files.inspect
+    #return files.values
+  end
+  return []
+end
+
+def gui_file_finder_select_callback(search_str, idx)
+  selected_file = $file_search_list[idx][0]
+  debug "FILE FINDER SELECT CALLBACK: s=#{search_str},i=#{idx}: #{selected_file}"
+  qt_select_window_close(0)
+  open_new_file(selected_file)
+end
+
+def gui_file_finder_handle_char(c)
+  puts "BUFFER SELECTOR INPUT CHAR: #{c}"
+  buffer_i = $select_keys.index(c)
+  if buffer_i != nil
+    gui_file_finder_callback(buffer_i)
+  end
+end
+
+# TODO: delete?
+def gui_file_finder_init()
+  $kbd.add_mode("Z", :filefinder)
+  bindkey "Z enter", "$kbd.set_mode(:command)"
+  bindkey "Z return", "$kbd.set_mode(:command)"
+end

data/lib/vimamsa/file_history.rb

@@ -0,0 +1,100 @@
+# History of previously opened files
+
+class FileHistory
+  attr_accessor :history
+
+  def initialize()
+    # puts self.method("update")
+    # x = self.method("update")
+    # x.call("ASFASF")
+
+    $hook.register(:change_buffer, self.method("update"))
+    $hook.register(:shutdown, self.method("save"))
+
+    reg_act(:fhist_remove_nonexisting, proc { remove_nonexisting }, "Cleanup history, remove non-existing files")
+
+    @history = vma.marshal_load("file_history", {})
+    $search_list = []
+  end
+
+  # def self.init()
+  # end
+
+  def update(buf)
+    puts "FileHistory.update(buf=#{buf.fname})"
+    return if !buf.fname
+    @history[buf.fname] if !@history[buf.fname]
+    if !@history[buf.fname]
+      @history[buf.fname] = 1
+    else
+      @history[buf.fname] += 1
+    end
+    puts @history
+
+    # puts "FileHistory.update(buf=#{buf})"
+  end
+
+  def save()
+    vma.marshal_save("file_history", @history)
+  end
+
+  def remove_nonexisting()
+    size_orig = @history.size
+    for k, v in @history
+      if !File.exist?(k)
+        @history.delete(k)
+        log_message("Delete #{k} from history")
+      end
+    end
+    size_new = @history.size
+    message("History size #{size_orig} => #{size_new}")
+  end
+
+  def start_gui()
+    return if $vma.fh.history.empty?
+    l = []
+    $select_keys = ["h", "l", "f", "d", "s", "a", "g", "z"]
+
+    qt_select_update_window(l, $select_keys.collect { |x| x.upcase },
+                            "gui_file_history_select_callback",
+                            "gui_file_history_update_callback")
+  end
+end
+
+def fuzzy_filter(search_str, list, maxfinds)
+  h = {}
+  scores = Parallel.map(list, in_threads: 8) do |l|
+    [l, srn_dst(search_str, l)]
+  end
+  for s in scores
+    h[s[0]] = s[1] if s[1] > 0
+  end
+  h = h.sort_by { |k, v| -v }
+  h = h[0..maxfinds]
+  # h.map do |i, d|
+  # puts "D:#{d} #{i}"
+  # end
+  return h
+end
+
+def gui_file_history_update_callback(search_str = "")
+  puts "gui_file_history_update_callback: #{search_str}"
+  return [] if $vma.fh.history.empty?
+  $search_list = []
+  files = $vma.fh.history.keys.sort.collect { |x| [x, 0] }
+
+  if (search_str.size > 1)
+    files = fuzzy_filter(search_str, $vma.fh.history.keys, 40)
+  end
+  $search_list = files
+  return files
+end
+
+def gui_file_history_select_callback(search_str, idx)
+  # selected_file = $file_search_list[idx][0]
+  selected_file = $search_list[idx][0]
+
+  debug "FILE HISTORY SELECT CALLBACK: s=#{search_str},i=#{idx}: #{selected_file}"
+  qt_select_window_close(0)
+  open_new_file(selected_file)
+end

data/lib/vimamsa/file_manager.rb

@@ -0,0 +1,144 @@
+class FileManager
+  @@cur
+
+  def initialize()
+    @buf = nil
+  end
+
+  def self.chdir_parent()
+    @@cur.chdir_parent
+  end
+
+  def self.cur()
+    return @@cur
+  end
+
+  def self.init()
+    reg_act(:start_file_selector, proc { FileManager.new.run; $kbd.set_mode(:file_exp) }, "File selector")
+
+    reg_act(:fexp_chdir_parent, proc { FileManager.chdir_parent }, "File selector")
+    reg_act(:fexp_select, proc { buf.module.select_line }, "")
+
+    reg_act(:fexp_sort_mtime, proc { FileManager.cur.sort_mtime }, "Sort based on time")
+    reg_act(:fexp_sort_fname, proc { FileManager.cur.sort_fname }, "Sort based on file name")
+
+    bindkey "C , j f", :start_file_selector
+    bindkey "C , f", :start_file_selector
+
+    # bindkey "C o", :delete_state
+
+    $kbd.add_minor_mode("fexp", :file_exp, :command)
+    
+    bindkey "fexp o m", :fexp_sort_mtime
+    bindkey "fexp o f", :fexp_sort_fname   
+
+    # bindkey "fexp l", [:fexp_right, proc { puts "==fexp_right==" }, ""]
+    bindkey "fexp h", :fexp_chdir_parent
+    bindkey "fexp esc", [:fexp_quit, proc { $kbd.set_mode(:command) }, ""]
+    bindkey "fexp enter", :fexp_select
+    bindkey "fexp l", :fexp_select
+
+    @sort_by = :name
+  end
+
+  def chdir_parent
+    dir_to_buf(fullp(".."))
+  end
+
+  def run
+    @@cur = self
+    ld = buflist.get_last_dir
+    dir_to_buf(ld)
+    # puts "ld=#{ld}"
+    # dlist = Dir["#{ld}/*"]
+  end
+
+  def sort_mtime
+    @sort_by = :mtime
+    dir_to_buf(@ld)
+  end
+
+  def sort_fname
+    @sort_by = :name
+    dir_to_buf(@ld)
+  end
+
+  def dir_to_buf(dirpath, b = nil)
+    # File.stat("testfile").mtime
+    dirpath = File.expand_path(dirpath)
+    @header = []
+    @header << "#{dirpath}"
+    @header << "=" * 40
+    @ld = dirpath
+    @dlist = Dir.children(@ld).sort
+    @cdirs = []
+    @cfiles = []
+    for x in @dlist
+      fpath = fullp(x)
+
+      ok = true
+      begin
+        fstat = File.stat(fpath)
+      rescue Errno::ENOENT # Broken link or something
+        next
+      end
+      next if x[0] == "."
+      if File.directory?(fpath) 
+        # if f.directory?(fpath)
+        @cdirs << x
+      else
+        @cfiles << [x, fstat]
+      end
+    end
+
+    # sort_by = :mtime
+    # sort_by = :name
+    # Ripl.start :binding => binding
+    @cfiles.sort_by! { |x| x[1].mtime }.reverse! if @sort_by == :mtime
+    @cfiles.sort_by! { |x| x[1].size }.reverse! if @sort_by == :size
+    @cfiles.sort_by! { |x| x[0] } if @sort_by == :name
+
+    s = ""
+    s << @header.join("\n")
+    s << "\n"
+    s << "..\n"
+    s << @cdirs.join("\n")
+    s << "\n"
+    s << "\n"
+    for f in @cfiles
+      s << "#{f[0]}\n"
+      # s << @cfiles.join("\n")
+    end
+
+    if @buf.nil?
+      @buf = create_new_file(nil, s)
+      @buf.module = self
+      @buf.active_kbd_mode = :file_exp
+    else
+      @buf.set_content(s)
+    end
+    @buf.set_line_and_column_pos(@header.size, 0)
+  end
+
+  def fullp(fn)
+    "#{@ld}/#{fn}"
+  end
+
+  def select_line
+    return if @buf.lpos < @header.size
+    # puts "def select_line"
+    fn = fullp(@buf.get_current_line[0..-2])
+    if File.directory?(fn)
+      puts "CHDIR: #{fn}"
+      dir_to_buf(fn)
+      # elsif vma.can_open_extension?(fn)
+      # jump_to_file(fn)
+    elsif file_is_text_file(fn)
+      bufs.close_current_buffer
+      jump_to_file(fn)
+    else
+      open_with_default_program(fn)
+    end
+    # puts l.inspect
+  end
+end

data/lib/vimamsa/hook.rb

@@ -0,0 +1,46 @@
+
+class HookItem
+  attr_writer :method_name, :weight
+
+  def initialize(hook_method, weight)
+    @method_name = hook_method.to_s
+
+    if hook_method.class == Method
+      @call_func = hook_method
+    elsif hook_method.class == String
+      @call_func = method(hook_method)
+    end
+    @weight = weight
+  end
+
+  def call(x = nil)
+    @call_func.call(x) if x != nil
+    @call_func.call() if x == nil
+  end
+end
+
+#$hook.register(:puts,"puts")
+#$hook.call(:puts,"AAAA")
+
+class Hook < Hash
+
+  #attr_reader :pos,
+  #attr_writer :call_func
+
+  def initialize()
+  end
+
+  def register(hook_id, hook_method, weight = 0)
+    self[hook_id] = [] if self[hook_id] == nil
+    self[hook_id] << HookItem.new(hook_method, weight)
+  end
+
+  def call(hook_id, x = nil)
+    if self[hook_id]
+      self[hook_id].each { |hi|
+        hi.call(x) if x != nil
+        hi.call() if x == nil
+      }
+    end
+  end
+end

data/lib/vimamsa/hyper_plain_text.rb

@@ -0,0 +1,61 @@
+
+
+def hpt_open_link()
+end
+
+def hpt_check_cur_word(w)
+  puts "check_cur_word(w)"
+  m = w.match(/⟦(.*)⟧/)
+  if m
+    fpfx = m[1]
+    if $buffer.fname
+      dn = File.dirname($buffer.fname)
+
+      fcands = []
+      fcands << "#{dn}/#{fpfx}"
+      fcands << "#{dn}/#{fpfx}.txt"
+      fcands << File.expand_path("#{fpfx}")
+      fcands << File.expand_path("#{fpfx}.txt")
+
+      fn = nil
+      for fc in fcands
+        if File.exists?(fc)
+          fn = fc
+          break
+        end
+      end
+
+      if fn
+        message "HPT opening file #{fn}"
+        return fn
+        # open_existing_file(fn)
+        # return true
+      else
+        message "File not found: #{fpfx}"
+      end
+    end
+  end
+  return nil
+end
+
+def hpt_scan_images()
+  return if !buf.fname
+  return if !buf.fname.match(/.*txt$/)
+  imgpos = scan_indexes(buf, /⟦img:.+?⟧/)
+  imgtags = buf.scan(/(⟦img:(.+?)⟧)/)
+  # i = 0
+  c = 0
+  imgpos.each.with_index { |x, i|
+    a = imgpos[i]
+    t = imgtags[i]
+    insert_pos = a + t[0].size + c
+    imgfn = File.expand_path(t[1])
+    # Ripl.start :binding => binding
+    next if !File.exist?(imgfn)
+    if buf[insert_pos..(insert_pos + 2)] != "\n \n"
+      buf.insert_txt_at("\n \n", insert_pos)
+      c += 3
+    end
+    buf.add_image(imgfn, insert_pos + 1)
+  }
+end