cmdline-sub 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2fd227736fa0bc8d59c84b1909f3c7abfd63ec86325a855ae5e4e2302693f35b
-  data.tar.gz: 84c336782e6d58eddba82d06874809d22074c968fd94a82c61a88043d922bb52
+  metadata.gz: c389766a40ec1f0894ff39ae9156d8ab1f737e32da5e6a83ac82e758fd420e06
+  data.tar.gz: cbe56894e3d43b63ec14da75db54b820c9347a197e32c9ae6a5cc649ddabdb1c
 SHA512:
-  metadata.gz: e1955cee9482f5b650924d6302185519553bc82dc9959b28449e57c5bb2f5527e2553eb18be60fe5a7f8cb9d752d5baf68709bab3448b66dfda3d196b2ad51e5
-  data.tar.gz: 9435447e39679f02f4e2365faa2c01cd2b7e9fb3ca88388e5d894b913c6edf5885fde6a32504e85cd4da29d75a8c0395ae265dbdd3d5917265ca4fc3dd4116e8
+  metadata.gz: 71806a610d4b0a4e3e14e6ed75ab31f0dc4d1c34ac72767b3b8e063ed139322685f1c0585929f58f447a25e07f717171892d7ed35ace82f4a8d67ad9dd00b394
+  data.tar.gz: d08f7dd174f7546d4b451a5ee6a0639eea308ca894db10c861dbd3556efbe6965770c2529a822da2a64821de52a68444d3771fa253a9e6f46ba17923e65b77fb

data/README

@@ -1,8 +1,8 @@
 Sub
 ===
 
-sub v0.1.0
-Usage: sub COMMANDLINE -- (PATTERN/SUBSTITUTION[/SUB_OPTIONS])+ (/GLOBAL_OPTIONS)?
+sub v0.1.3
+Usage: sub COMMANDLINE -- (PATTERN/SUBSTITUTION[/SUB_FLAGS])+ (/GLOBAL_FLAGS)?
 
 sub substitutes the matching pattern in every word in the command line with the
 substitution. Only the first matched pattern in the word is substituted unless
@@ -53,16 +53,22 @@ Substitution flags:
   	  ex: sub cp here.txt there.txt -- CP/mv/i #=> mv here.txt there.txt
 -g:	General substitution: substitute all matches in the word, not just the first
   	  ex: sub cp here.txt there.txt -- ./_/g #=> __ ________ _________
--e:	Expand * in commandline after replacements are made
-  	  ex: sub ls mydir -- mydir/*/e #=> ls bin README
+-r:	Don't escape substituted value, allow shell to expand and split it
+  	  ex: sub ls mydir -- 'mydir/*/r' #=> ls bin README
 Global flags:
--p:	Print the command instead of executing it
+-p:	Print the command instead of executing it (adds newline)
+-P:	Print the command instead of executing it (doesn't add newline)
 -c:	Copy the command to clipboard instead of executing it
 -I:	Set interactive mode: shows the command and asks if you want to execute it
 -v:	Set verbose mode
 -D:	Set debug mode
+Other flags:
+-h,--help:	Show help (-h shows short help, --help shows full)
+-v,--version:	Show version followed by a newline
 
 Install:
+	 gem install cmdline-sub
+or:
 	cd $HOME
 	git clone git@github.com:luke-gru/sub.git
 	cd sub
@@ -71,6 +77,8 @@ Install:
 	# INSTALL_PREFIX="/bin" sudo rake install
 
 Uninstall:
+	 gem uninstall cmdline-sub
+or:
 	cd $HOME/sub
 	sudo rake uninstall # removes /usr/local/bin/sub
 	# or

data/Rakefile

@@ -57,6 +57,7 @@ end
 
 desc "Uninstall (removes /usr/local/bin/sub or $(INSTALL_PREFIX)/sub). Use sudo if necessary."
 task :uninstall do
+  require "fileutils"
   install_dir = ENV["INSTALL_PREFIX"] || "/usr/local/bin"
   unless File.directory?(install_dir)
     $stderr.puts "Directory #{install_dir} does not exist. Uninstall failed."

data/bin/sub

@@ -2,10 +2,15 @@
 # vim: set ft=ruby
 # frozen_string_literal: true
 
-VERSION = "0.1.1"
+if ENV["TESTING_SUB_CMD"] == "1" && ENV["DEBUGGING_SUB_CMD"] == "1"
+  require "debug"
+end
+require "shellwords"
+
+VERSION = "0.1.3"
 
 USAGE = <<EOF
-Usage: sub COMMANDLINE -- (PATTERN/SUBSTITUTION[/SUB_OPTIONS])+ (/GLOBAL_OPTIONS)?
+Usage: sub COMMANDLINE -- (PATTERN/SUBSTITUTION[/SUB_FLAGS])+ (/GLOBAL_FLAGS)?
 
 sub substitutes the matching pattern in every word in the command line with the
 substitution. Only the first matched pattern in the word is substituted unless
@@ -46,6 +51,8 @@ EOF
 
 INSTALLATION = <<EOF
 Install:
+\t gem install cmdline-sub
+or:
 \tcd $HOME
 \tgit clone git@github.com:luke-gru/sub.git
 \tcd sub
@@ -56,6 +63,8 @@ EOF
 
 UNINSTALLATION = <<EOF
 Uninstall:
+\t gem uninstall cmdline-sub
+or:
 \tcd $HOME/sub
 \tsudo rake uninstall # removes /usr/local/bin/sub
 \t# or
@@ -64,7 +73,7 @@ EOF
 
 LICENSE = "License: MIT"
 
-FLAGS = [
+SUB_FLAGS = [
   # per substitution flags
   { flag: 'f', name: :first_match, desc: "Substitute first matching word only.",
     example: "sub wget https://wget.com -- wget/curl/f #=> curl https://wget.com",
@@ -81,10 +90,11 @@ FLAGS = [
   { flag: 'g', name: :general, desc: "General substitution: substitute all matches in the word, not just the first",
     example: "sub cp here.txt there.txt -- ./_/g #=> __ ________ _________",
   },
-  { flag: 'e', name: :expand_star, desc: "Expand * in commandline after replacements are made",
-    example: [ "sub ls mydir -- mydir/*/e #=> ls bin README" ]
+  { flag: 'r', name: :raw_mode, desc: "Don't escape substituted value, allow shell to expand and split it",
+    example: [ "sub ls mydir -- 'mydir/*/r' #=> ls bin README" ]
   },
-  nil, # separator
+]
+GLOBAL_FLAGS = [
   # global flags
   { flag: 'p', name: :print_only, desc: "Print the command instead of executing it (adds newline)" },
   { flag: 'P', name: :print_only_no_newline, desc: "Print the command instead of executing it (doesn't add newline)" },
@@ -93,28 +103,26 @@ FLAGS = [
   { flag: 'v', name: :verbose, desc: "Set verbose mode" },
   { flag: 'D', name: :debug, desc: "Set debug mode" },
 ]
-GLOBAL_FLAGS_MAP = {
-  print_only: 'p',
-  print_only_no_newline: 'P',
-  copy_to_clipboard: 'c',
-  interactive: 'I',
-  verbose: 'v',
-  debug: 'D',
-}
-GLOBAL_FLAGS = GLOBAL_FLAGS_MAP.values
+OTHER_FLAGS = [
+  { flag: ['h', '--help'], name: :help, desc: "Show help (-h shows short help, --help shows full)", },
+  { flag: ['v', '--version'], name: :version, desc: "Show version followed by a newline" },
+]
+FLAGS = SUB_FLAGS + GLOBAL_FLAGS + OTHER_FLAGS
+FLAGS_BY_NAME = FLAGS.map do |f|
+  { f[:name] => f[:flag] }
+end.inject(Hash.new) { |memo, h| memo.merge(h) }
+GLOBAL_FLAGS_BY_NAME = GLOBAL_FLAGS.map do |f|
+  { f[:name] => f[:flag] }
+end.inject(Hash.new) { |memo, h| memo.merge(h) }
+RAW_GLOBAL_FLAGS = GLOBAL_FLAGS_BY_NAME.values
 
 def print_help(full: true)
   output = String.new
   output << "sub v#{VERSION}" << "\n"
   output << USAGE << "\n"
-  output << "Flags:\n\n"
-  output << "Substitution flags:\n"
-  FLAGS.each do |fhash|
-    if fhash.nil?
-      output << "Global flags:\n"
-      next
-    end
-    output << "-#{fhash[:flag]}:\t#{fhash[:desc]}\n"
+  output_flag_info = lambda do |fhash|
+    flags = Array(fhash[:flag])
+    output << "-#{flags.join(',')}:\t#{fhash[:desc]}\n"
     if ex = fhash[:example]
       case ex
       when String
@@ -126,6 +134,13 @@ def print_help(full: true)
       end
     end
   end
+  output << "Flags:\n\n"
+  output << "Substitution flags:\n"
+  SUB_FLAGS.each(&output_flag_info)
+  output << "Global flags:\n"
+  GLOBAL_FLAGS.each(&output_flag_info)
+  output << "Other flags:\n"
+  OTHER_FLAGS.each(&output_flag_info)
   if full
     output << "\n" << INSTALLATION
     output << "\n" << UNINSTALLATION
@@ -142,11 +157,8 @@ def parse_argv_and_sub_strs(argv)
   ret_argv = []
   sub_strs = []
   if argv.size == 0
-    require "readline"
-    line = Readline.readline "cmd: ", true
-    ret_argv.replace line.strip.split(/\s+/)
-    line = Readline.readline "pat/sub[/options]: ", true
-    sub_strs << line.strip
+    print_help(full: true)
+    exit 1
   else
     last_dashdash_idx = argv.rindex('--')
     argv.each_with_index do |arg, i|
@@ -178,26 +190,28 @@ end
 
 argv, sub_strs = parse_argv_and_sub_strs(ARGV)
 
-def flag(flags_str, char)
+def parse_simple_flag!(flags_str, char)
   flag = flags_str.include?(char)
   flags_str.delete!(char)
   flag
 end
 
 def flag_by_name(name)
-  FLAGS.each do |fhash|
-    next if fhash.nil?
-    if fhash[:name] == name
-      return fhash[:flag]
-    end
-  end
-  raise ArgumentError, "bad flag: #{name}"
+  FLAGS_BY_NAME.fetch(name)
 end
 
-def raw_global_options?(raw_flags)
+def raw_global_flags?(raw_flags)
   raw_flags = raw_flags.strip
   return false if raw_flags.empty?
-  raw_flags.gsub(Regexp.new(GLOBAL_FLAGS.join('|')), '').empty?
+  raw_flags.gsub(Regexp.new(RAW_GLOBAL_FLAGS.join('|')), '').empty?
+end
+
+def parse_global_flag!(name, flags, global_flags)
+  if global_flags[name]
+    flags.delete!(GLOBAL_FLAGS_BY_NAME[name])
+  else
+    global_flags[name] = parse_simple_flag!(flags, flag_by_name(name))
+  end
 end
 
 def parse_sub_strs(sub_strs)
@@ -205,11 +219,11 @@ def parse_sub_strs(sub_strs)
   pats = []
   subs = []
   match_flags = []
-  global_flags = GLOBAL_FLAGS_MAP.transform_values { nil }
+  global_flags = GLOBAL_FLAGS_BY_NAME.transform_values { nil }
   raw_flags = []
   sub_strs.each_with_index do |sub_str, sub_i|
     # global flags at end of substitutions list, starts with /, ex: /o
-    if sub_strs[sub_i+1].nil? && sub_str[0] == '/' && raw_global_options?(sub_str[1..-1])
+    if sub_strs[sub_i+1].nil? && sub_str[0] == '/' && raw_global_flags?(sub_str[1..-1])
       flags = sub_str[1..-1]
     else
       pat, sub, flags = sub_str.split(/(?<!\\)\//)
@@ -219,48 +233,27 @@ def parse_sub_strs(sub_strs)
       flags.strip!
       raw_flags << flags.dup
       flags_hash = {
-        first_match: flag(flags, flag_by_name(:first_match)),
-        last_match: flag(flags, flag_by_name(:last_match)),
-        expand_star: flag(flags, flag_by_name(:expand_star)),
-        literal: flag(flags, flag_by_name(:literal)),
-        ignorecase: flag(flags, flag_by_name(:ignorecase)),
-        general: flag(flags, flag_by_name(:general)),
+        first_match: parse_simple_flag!(flags, flag_by_name(:first_match)),
+        last_match: parse_simple_flag!(flags, flag_by_name(:last_match)),
+        raw_mode: parse_simple_flag!(flags, flag_by_name(:raw_mode)),
+        literal: parse_simple_flag!(flags, flag_by_name(:literal)),
+        ignorecase: parse_simple_flag!(flags, flag_by_name(:ignorecase)),
+        general: parse_simple_flag!(flags, flag_by_name(:general)),
       }
+      if flags_hash[:raw_mode]
+        flags_hash[:raw_mode] = 0 # bitfield
+      end
       pats << pat
       subs << sub
       match_flags << flags_hash
     end
 
-    if global_flags[:interactive]
-      flags.delete!(GLOBAL_FLAGS_MAP[:interactive])
-    else
-      global_flags[:interactive] = flag(flags, flag_by_name(:interactive)) || ARGV.size == 0
-    end
-    if global_flags[:print_only]
-      flags.delete!(GLOBAL_FLAGS_MAP[:print_only])
-    else
-      global_flags[:print_only] = flag(flags, flag_by_name(:print_only))
-    end
-    if global_flags[:print_only_no_newline]
-      flags.delete!(GLOBAL_FLAGS_MAP[:print_only_no_newline])
-    else
-      global_flags[:print_only_no_newline] = flag(flags, flag_by_name(:print_only_no_newline))
-    end
-    if global_flags[:copy_to_clipboard]
-      flags.delete!(GLOBAL_FLAGS_MAP[:copy_to_clipboard])
-    else
-      global_flags[:copy_to_clipboard] = flag(flags, flag_by_name(:copy_to_clipboard))
-    end
-    if global_flags[:verbose]
-      flags.delete!(GLOBAL_FLAGS_MAP[:verbose])
-    else
-      global_flags[:verbose] = flag(flags, flag_by_name(:verbose))
-    end
-    if global_flags[:debug]
-      flags.delete!(GLOBAL_FLAGS_MAP[:debug])
-    else
-      global_flags[:debug] = flag(flags, flag_by_name(:debug))
-    end
+    parse_global_flag!(:interactive, flags, global_flags)
+    parse_global_flag!(:print_only, flags, global_flags)
+    parse_global_flag!(:print_only_no_newline, flags, global_flags)
+    parse_global_flag!(:copy_to_clipboard, flags, global_flags)
+    parse_global_flag!(:verbose, flags, global_flags)
+    parse_global_flag!(:debug, flags, global_flags)
     unless flags.empty?
       $stderr.puts "Warning: unknown flag#{'s' if flags.size != 1}: #{flags}"
     end
@@ -272,7 +265,7 @@ end
 pats, subs, flags_hashes, raw_flags, global_flags = parse_sub_strs(sub_strs)
 
 if pats.empty? && flags_hashes.empty? && global_flags.empty?
-  $stderr.puts "Incorrect substitution, format is: pattern/substitution[/options]"
+  $stderr.puts "Incorrect substitution, format is: pattern/substitution[/flags]"
   exit 1
 end
 
@@ -314,6 +307,9 @@ def argv_replace!(argv, regexps, subs, flags)
             scan_size = arg.scan(regexp).size
             scan_size = 1 if scan_size > 1
           end
+          if flags[i].fetch(:raw_mode)
+            flags[i][:raw_mode] |= i+1
+          end
           if new_arg != arg || new_arg == subs[i]
             num_replacements += scan_size
           end
@@ -370,7 +366,7 @@ def copy!(cmd_line, global_flags)
   end
 end
 
-def exec_cmd(argv, regexps, subs, raw_flags, num_replacements, global_flags)
+def exec_cmd(argv, regexps, subs, flags_hashes, raw_flags, global_flags, num_replacements)
   if global_flags.fetch(:debug)
     puts "Patterns: #{regexps.inspect}"
     puts "Substitutions: #{subs.inspect}"
@@ -393,11 +389,24 @@ def exec_cmd(argv, regexps, subs, raw_flags, num_replacements, global_flags)
   end
 
   cmd = argv.shift
-  cmd_line = "#{cmd} #{argv.join(' ')}"
+  argv_string = String.new
+  argv.each_with_index do |arg, i|
+    raw_mode = flags_hashes.any? { |flags_hash| flags_hash[:raw_mode] && (flags_hash[:raw_mode] & i+1) != 0 }
+    if raw_mode
+      argv_string << arg
+    else
+      argv_string << Shellwords.escape(arg)
+    end
+    unless argv[i+1].nil?
+      argv_string << " "
+    end
+  end
+  cmd_line = "#{cmd} #{argv_string}"
   action = global_flags.fetch(:copy_to_clipboard) ? "copy" : "execute"
   if global_flags.fetch(:interactive) && !global_flags.fetch(:print_only)
     $stdout.puts "Would you like to #{action} the following command? [y(es),n(o)]"
     $stdout.puts cmd_line
+    $stdout.flush
     ans = $stdin.gets().strip
     if ans !~ /y(es)?/i # treat as no
       exit 1
@@ -411,7 +420,7 @@ def exec_cmd(argv, regexps, subs, raw_flags, num_replacements, global_flags)
   copy!(cmd_line, global_flags) if global_flags.fetch(:copy_to_clipboard)
   exit 0 if global_flags.fetch(:print_only) || global_flags.fetch(:print_only_no_newline) || global_flags.fetch(:copy_to_clipboard)
   begin
-    exec cmd, *argv
+    exec cmd_line
   rescue SystemCallError => e
     if e.class == Errno::ENOENT
       # act like a shell
@@ -423,4 +432,4 @@ def exec_cmd(argv, regexps, subs, raw_flags, num_replacements, global_flags)
   end
 end
 
-exec_cmd(argv, regexps, subs, raw_flags, num_replacements, global_flags)
+exec_cmd(argv, regexps, subs, flags_hashes, raw_flags, global_flags, num_replacements)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cmdline-sub
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Luke Gruber
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-20 00:00:00.000000000 Z
+date: 2024-12-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: debug