cmdline-sub 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2fd227736fa0bc8d59c84b1909f3c7abfd63ec86325a855ae5e4e2302693f35b
-  data.tar.gz: 84c336782e6d58eddba82d06874809d22074c968fd94a82c61a88043d922bb52
+  metadata.gz: f8333cc1f6aa8e4eb3b47299c6038d0c04d26b9b0b8e4b2292e54906fc9e766d
+  data.tar.gz: 2b6fa1a2ef48f3ff9fec5aa017c7e4ef94e977085f424e64a4c9378822dc0a4b
 SHA512:
-  metadata.gz: e1955cee9482f5b650924d6302185519553bc82dc9959b28449e57c5bb2f5527e2553eb18be60fe5a7f8cb9d752d5baf68709bab3448b66dfda3d196b2ad51e5
-  data.tar.gz: 9435447e39679f02f4e2365faa2c01cd2b7e9fb3ca88388e5d894b913c6edf5885fde6a32504e85cd4da29d75a8c0395ae265dbdd3d5917265ca4fc3dd4116e8
+  metadata.gz: 3b162147e9a995230fdb3744963af0fa237ec96fe9f6088b561ce82de7a7a6d338096715dda296f2ad5c6060d2d3e826017aa346c283cb79662723884acd64c6
+  data.tar.gz: 2bb7d2a20e123d67ddb0ee09e8c2de7b7e0e46d6a39d31b3364df381b9f9481d15020df0096a0edc0b140b5a3d8ebae97926717f8cb2609fa5f7ea9861f40a41

data/README

@@ -1,8 +1,8 @@
 Sub
 ===
 
-sub v0.1.0
-Usage: sub COMMANDLINE -- (PATTERN/SUBSTITUTION[/SUB_OPTIONS])+ (/GLOBAL_OPTIONS)?
+sub v0.1.2
+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
@@ -56,13 +56,19 @@ Substitution flags:
 -e:	Expand * in commandline after replacements are made
   	  ex: sub ls mydir -- mydir/*/e #=> 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,14 @@
 # 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
+
+VERSION = "0.1.2"
 
 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 +50,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 +62,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 +72,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",
@@ -84,7 +92,8 @@ FLAGS = [
   { flag: 'e', name: :expand_star, desc: "Expand * in commandline after replacements are made",
     example: [ "sub ls mydir -- mydir/*/e #=> 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 +102,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 +133,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 +156,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 +189,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 +218,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 +232,24 @@ 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)),
+        expand_star: parse_simple_flag!(flags, flag_by_name(:expand_star)),
+        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)),
       }
       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 +261,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
 
@@ -398,6 +387,7 @@ def exec_cmd(argv, regexps, subs, raw_flags, num_replacements, global_flags)
   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

metadata

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