vimamsa 0.1.22 → 0.1.24

data/lib/vimamsa/macro.rb

@@ -26,22 +26,51 @@ class Macro
   attr_reader :running_macro
   attr_accessor :recorded_macros, :recording, :named_macros, :last_macro
 
+  NAMED_MACROS_FILE = "named_macros.json"
+
   def initialize()
     @recording = false
-    # @recorded_macros = {}
     @current_recording = []
     @current_name = nil
     @last_macro = "a"
     @running_macro = false
 
-    #TODO:
     @recorded_macros = vma.marshal_load("macros", {})
-    @named_macros = vma.marshal_load("named_macros", {})
+    @named_macros = load_named_macros
     vma.hook.register(:shutdown, self.method("save"))
   end
 
+  def named_macros_path
+    get_dot_path(NAMED_MACROS_FILE)
+  end
+
+  # Save named macros as JSON immediately — called automatically after name_macro.
+  def save_named_macros
+    require "json"
+    File.write(named_macros_path, JSON.pretty_generate(@named_macros))
+  rescue => e
+    error("Failed to save named macros: #{e}")
+  end
+
+  # Load named macros from JSON. Falls back to Marshal data from older versions.
+  def load_named_macros
+    require "json"
+    path = named_macros_path
+    if File.exist?(path)
+      data = JSON.parse(File.read(path))
+      # JSON keys are always strings; action lists are arrays of strings — correct types
+      return data
+    end
+    # Fallback: migrate from old Marshal-based storage
+    vma.marshal_load("named_macros", {})
+  rescue => e
+    error("Failed to load named macros: #{e}")
+    {}
+  end
+
   def save()
     vma.marshal_save("macros", @recorded_macros)
+    # named_macros are kept current via save_named_macros; save a Marshal copy as backup
     vma.marshal_save("named_macros", @named_macros)
   end
 
@@ -56,17 +85,31 @@ class Macro
     $macro_search_list = l
     $select_keys = ["h", "l", "f", "d", "s", "a", "g", "z"]
 
+    delete_cb = proc { |name, refresh|
+      Gui.confirm("Delete macro '#{name}'?", proc {
+        vma.macro.delete_named_macro(name)
+        refresh.call
+      })
+    }
+
     gui_select_update_window(l, $select_keys.collect { |x| x.upcase },
                              "gui_find_macro_select_callback",
-                             "gui_find_macro_update_callback")
+                             "gui_find_macro_update_callback",
+                             { delete_callback: delete_cb })
+  end
+
+  def delete_named_macro(name)
+    @named_macros.delete(name)
+    save_named_macros
+    message("Macro '#{name}' deleted")
   end
 
   def name_macro(name, id = nil)
     debug "NAME MACRO #{name}"
-    if id.nil?
-      id = @last_macro
-    end
+    id = @last_macro if id.nil?
     @named_macros[name] = @recorded_macros[id].clone
+    save_named_macros
+    message("Macro '#{name}' saved")
   end
 
   def start_recording(name)
@@ -122,6 +165,8 @@ class Macro
     isok = true
     # if acts.kind_of?(Array) and acts.any?
     if acts.any?
+      vma.buf&.new_undo_group
+      vma.buf&.instance_variable_set(:@macro_group_active, true)
       @running_macro = true
       # TODO:needed?
       # set_last_command({ method: vma.macro.method("run_macro"), params: [name] })
@@ -138,6 +183,8 @@ class Macro
       end
     end
     @running_macro = false
+    vma.buf&.instance_variable_set(:@macro_group_active, false)
+    vma.buf&.new_undo_group
     buf.set_pos(buf.pos)
     # TODO: Should be a better way to trigger this. Sometimes need to wait for GTK to process things before updating the cursor.
     run_as_idle proc { vma.buf.refresh_cursor; vma.buf.refresh_cursor }, delay: 0.15

data/lib/vimamsa/main.rb

@@ -45,6 +45,7 @@ def buflist()
 end
 
 require "vimamsa/editor.rb"
+require "vimamsa/diff_buffer"
 
 $vma = Editor.new
 def vma()

data/lib/vimamsa/rbvma.rb

@@ -16,6 +16,7 @@ require "cgi"
 require "uri"
 require "vimamsa/conf"
 require "vimamsa/util"
+require "vimamsa/string_util"
 # exit!
 require "vimamsa/main"
 require "vimamsa/terminal"
@@ -30,6 +31,9 @@ require "vimamsa/gui_form_generator"
 require "vimamsa/gui_text"
 require "vimamsa/gui_menu"
 require "vimamsa/gui_dialog"
+require "vimamsa/gui_settings"
+require "vimamsa/gui_file_panel"
+require "vimamsa/gui_func_panel"
 require "vimamsa/gui_select_window"
 require "vimamsa/gui_sourceview"
 require "vimamsa/gui_sourceview_autocomplete"
@@ -46,6 +50,7 @@ require "vimamsa/buffer_manager"
 require "vimamsa/constants"
 require "vimamsa/debug"
 require "vimamsa/tests"
+require "vimamsa/test_framework"
 require "vimamsa/easy_jump"
 require "vimamsa/encrypt"
 require "vimamsa/file_finder"

data/lib/vimamsa/string_util.rb

@@ -0,0 +1,56 @@
+def flip_true_false(str)
+  str.gsub(/\b(true|false)\b/i) do |match|
+    if match.match?(/\Atrue\z/i)
+      replacement = "false"
+    else
+      replacement = "true"
+    end
+
+    # preserve casing style
+    if match == match.upcase
+      replacement.upcase
+    elsif match[0] == match[0].upcase
+      replacement.capitalize
+    else
+      replacement.downcase
+    end
+  end
+end
+
+def to_camel_case(str)
+  words = str.split(/\W+/) # Split the input string into words
+  camel_case_words = words.map.with_index do |word, index|
+    index == 0 ? word.downcase : word.capitalize
+  end
+  camel_case_words.join
+end
+
+# Get all indexes for start of matching regexp
+def scan_indexes(txt, regex)
+  # indexes = txt.enum_for(:scan, regex).map { Regexp.last_match.begin(0) + 1 }
+  indexes = txt.enum_for(:scan, regex).map { Regexp.last_match.begin(0) }
+  return indexes
+end
+
+def is_path(s)
+  m = s.match(/(~[a-z]*)?\/.*\//)
+  if m != nil
+    return true
+  end
+  return false
+end
+
+
+def sanitize_input(str)
+  if str.encoding != Encoding::UTF_8
+    str = text.encode(Encoding::UTF_8)
+  end
+  str.gsub!(/\r\n/, "\n")
+  return str
+end
+
+def is_url(s)
+  return s.match(/(https?|file):\/\/.*/) != nil
+end
+
+

data/lib/vimamsa/test_framework.rb

@@ -0,0 +1,137 @@
+# VmaTest — integration test base class
+#
+# Tests run inside the live GTK app (headless or normal) after vma.start.
+# Each test method gets a fresh empty buffer.
+#
+# Two ways to drive the editor:
+#   act(:action_name)         — execute a registered action directly
+#   act("buf.insert_txt(…)")  — eval a string action
+#   keys("i h e l l o esc")  — simulate a space-separated key sequence
+#
+# Assertions raise VmaTestFailure on mismatch (caught by the runner).
+#
+# Usage:
+#   Run all tests:  run_vma_tests
+#   Run one class:  run_vma_tests(MyTests)
+
+class VmaTestFailure < StandardError; end
+
+class VmaTest
+  attr_reader :failures, :passes
+
+  # Subclasses define test_* methods.
+  # Each receives a fresh buffer and the kbd in :command mode.
+  def run_all
+    @passes = 0
+    @failures = []
+    test_methods = self.class.instance_methods(false)
+                       .select { |m| m.to_s.start_with?("test_") }
+                       .sort
+
+    test_methods.each do |m|
+      _setup_test
+      begin
+        send(m)
+        @passes += 1
+        puts "  PASS  #{self.class}##{m}"
+      rescue VmaTestFailure => e
+        @failures << "#{self.class}##{m}: #{e.message}"
+        puts "  FAIL  #{self.class}##{m}: #{e.message}"
+      rescue => e
+        @failures << "#{self.class}##{m}: #{e.class}: #{e.message}"
+        puts "  ERROR #{self.class}##{m}: #{e.class}: #{e.message}"
+        puts e.backtrace.first(5).join("\n")
+      end
+    end
+  end
+
+  # ── Actions ──────────────────────────────────────────────────────────────
+
+  # Execute one action (symbol, string, or proc)
+  def act(action)
+    exec_action(action)
+    drain_idle
+  end
+
+  # Simulate a space-separated key sequence in the current mode.
+  # E.g.:  keys("i h e l l o esc")
+  # Special tokens: ctrl-x, alt-x, shift-X, esc, enter, backspace, tab, space
+  def keys(seq)
+    seq.split.each do |k|
+      vma.kbd.match_key_conf(k, nil, :key_press)
+      # Emit a key_release for modifier-only keys so state resets correctly
+      vma.kbd.match_key_conf(k + "!", nil, :key_release) if %w[ctrl alt shift].include?(k)
+    end
+    drain_idle
+  end
+
+  # ── Assertions ───────────────────────────────────────────────────────────
+
+  def assert_buf(expected, msg = nil)
+    actual = vma.buf.to_s
+    return if actual == expected
+    raise VmaTestFailure, (msg || "buffer mismatch\n  expected: #{expected.inspect}\n  actual:   #{actual.inspect}")
+  end
+
+  def assert_pos(lpos, cpos, msg = nil)
+    al = vma.buf.lpos
+    ac = vma.buf.cpos
+    return if al == lpos && ac == cpos
+    raise VmaTestFailure, (msg || "position mismatch: expected line #{lpos} col #{cpos}, got line #{al} col #{ac}")
+  end
+
+  def assert_mode(expected_mode, msg = nil)
+    actual = vma.kbd.get_mode
+    return if actual == expected_mode
+    raise VmaTestFailure, (msg || "mode mismatch: expected #{expected_mode.inspect}, got #{actual.inspect}")
+  end
+
+  def assert_eq(expected, actual, msg = nil)
+    return if expected == actual
+    raise VmaTestFailure, (msg || "expected #{expected.inspect}, got #{actual.inspect}")
+  end
+
+  def assert(cond, msg = "assertion failed")
+    raise VmaTestFailure, msg unless cond
+  end
+
+  private
+
+  def _setup_test
+    # Fresh buffer, command mode
+    b = create_new_buffer("\n", "test", true)
+    vma.kbd.set_mode(:command) rescue nil
+    drain_idle
+  end
+
+  # Let any GLib::Idle callbacks run before we check state
+  def drain_idle
+    20.times { GLib::MainContext.default.iteration(false) }
+  end
+end
+
+# ── Runner ───────────────────────────────────────────────────────────────────
+
+def run_vma_tests(*classes)
+  classes = ObjectSpace.each_object(Class)
+                       .select { |c| c < VmaTest }
+                       .sort_by(&:name) if classes.empty?
+
+  total_pass = 0
+  total_fail = []
+
+  classes.each do |klass|
+    puts "\n#{klass}"
+    t = klass.new
+    t.run_all
+    total_pass += t.passes
+    total_fail.concat(t.failures)
+  end
+
+  puts "\n#{"=" * 50}"
+  puts "Results: #{total_pass} passed, #{total_fail.size} failed"
+  total_fail.each { |f| puts "  FAIL: #{f}" }
+  puts "=" * 50
+
+  total_fail.empty?
+end

data/lib/vimamsa/util.rb

@@ -4,7 +4,9 @@ VOWELS = %w(a e i o u)
 CONSONANTS = %w(b c d f g h j k l m n p q r s t v w x y z)
 
 def draw_cursor_bug_workaround()
-  DelayExecutioner.exec(id: :bug_workaround_draw_cursor, wait: 1.0, callable: proc { vma.gui.view.draw_cursor(); debug ":bug_workaround_draw_cursor"; false })
+  if !vma.gui.nil?
+    DelayExecutioner.exec(id: :bug_workaround_draw_cursor, wait: 1.0, callable: proc { vma.gui.view.draw_cursor(); debug ":bug_workaround_draw_cursor"; false })
+  end
 end
 
 def running_wayland?
@@ -24,14 +26,6 @@ def tilde_path(abspath)
   abspath.sub(/^#{Regexp.escape(userhome)}\//, "~/")
 end
 
-def to_camel_case(str)
-  words = str.split(/\W+/) # Split the input string into words
-  camel_case_words = words.map.with_index do |word, index|
-    index == 0 ? word.downcase : word.capitalize
-  end
-  camel_case_words.join
-end
-
 def generate_password(length)
   password = ""
   while password.size < length
@@ -53,13 +47,6 @@ def generate_password_to_buf(length)
   vma.buf.insert_txt(passw)
 end
 
-# Get all indexes for start of matching regexp
-def scan_indexes(txt, regex)
-  # indexes = txt.enum_for(:scan, regex).map { Regexp.last_match.begin(0) + 1 }
-  indexes = txt.enum_for(:scan, regex).map { Regexp.last_match.begin(0) }
-  return indexes
-end
-
 def file_mime_type(fpath)
   fpath = File.expand_path(fpath)
   return nil if !File.readable?(fpath)
@@ -322,18 +309,6 @@ def read_file(text, path)
   return content
 end
 
-def sanitize_input(str)
-  if str.encoding != Encoding::UTF_8
-    str = text.encode(Encoding::UTF_8)
-  end
-  str.gsub!(/\r\n/, "\n")
-  return str
-end
-
-def is_url(s)
-  return s.match(/(https?|file):\/\/.*/) != nil
-end
-
 def expand_if_existing(fpath)
   return nil if fpath.class != String
   fpath = File.expand_path(fpath)
@@ -386,11 +361,3 @@ end
 # #TODO: check contents of file
 # return true
 # end
-
-def is_path(s)
-  m = s.match(/(~[a-z]*)?\/.*\//)
-  if m != nil
-    return true
-  end
-  return false
-end

data/lib/vimamsa/version.rb

@@ -1,3 +1,3 @@
 module Vimamsa
-  VERSION = "0.1.22"
+  VERSION = "0.1.24"
 end