cmdline-sub 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2fd227736fa0bc8d59c84b1909f3c7abfd63ec86325a855ae5e4e2302693f35b
+  data.tar.gz: 84c336782e6d58eddba82d06874809d22074c968fd94a82c61a88043d922bb52
+SHA512:
+  metadata.gz: e1955cee9482f5b650924d6302185519553bc82dc9959b28449e57c5bb2f5527e2553eb18be60fe5a7f8cb9d752d5baf68709bab3448b66dfda3d196b2ad51e5
+  data.tar.gz: 9435447e39679f02f4e2365faa2c01cd2b7e9fb3ca88388e5d894b913c6edf5885fde6a32504e85cd4da29d75a8c0395ae265dbdd3d5917265ca4fc3dd4116e8

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,9 @@
+MIT
+
+Copyright (c) 2024 Luke Gruber
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,79 @@
+Sub
+===
+
+sub v0.1.0
+Usage: sub COMMANDLINE -- (PATTERN/SUBSTITUTION[/SUB_OPTIONS])+ (/GLOBAL_OPTIONS)?
+
+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
+the 'g' flag is given. There are various options that change the way substitutions
+are performed or the way matches are made. Patterns can have regular expression
+wildcards (special characters) in them, and the regular expression engine used is
+Ruby's. Special characters are interpreted as special unless the 'L' flag is given.
+
+See [https://docs.ruby-lang.org/en/master/Regexp.html#class-Regexp-label-Special+Characters]
+for more information on the special characters that can be used inside patterns.
+
+The sub utility is useful mainly when editing long commandlines, so you don't have to
+<ctrl-b> and <ctrl-f> (or <left> and <right>) through the commandline to edit it. The
+examples given here don't feature long commandlines for the sake of being brief and
+explanatory.
+
+Ex: sub ld -m elf_i386 ex4.o -o ex4 -- ex4/ex5
+    This will output the following, and then execute it:
+    ld -m elf_i386 ex5.o -o ex5
+
+Multiple substitutions:
+
+  Multiple substitutions can be given as well, such as:
+
+  Ex: sub ld -m elf_i386 ex4.o -o ex4 -- ex4/ex5 i386/arm64
+      ld -m elf_arm64 ex5.o -o ex5
+
+  If multiple substitutions are given, each subsitution pattern is matched with
+  each word, then the next substitution pattern does the same.
+
+Global flags:
+  Global flags can be given as the last argument:
+
+  ex: sub find . | grep '.txt' -- txt/md /p
+  In this example, the print flag is given as a final argument.
+  See flags information below.
+
+Flags:
+
+Substitution flags:
+-f:	Substitute first matching word only.
+  	  ex: sub wget https://wget.com -- wget/curl/f #=> curl https://wget.com
+-l:	Substitute last matching word only
+  	  ex: sub ls -al -- l//l #=> ls -a
+-L:	Interpret wildcards in pattern as literals
+  	  ex: sub cp here.txt there.txt -- ./_/L #=> cp here_txt there_txt
+-i:	Set pattern to ignore the case of the match
+  	  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
+Global flags:
+-p:	Print the command instead of executing it
+-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
+
+Install:
+	cd $HOME
+	git clone git@github.com:luke-gru/sub.git
+	cd sub
+	sudo rake install # creates /usr/local/bin/sub
+	# or
+	# INSTALL_PREFIX="/bin" sudo rake install
+
+Uninstall:
+	cd $HOME/sub
+	sudo rake uninstall # removes /usr/local/bin/sub
+	# or
+	# INSTALL_PREFIX="/bin" sudo rake uninstall # removes /bin/sub
+
+License: MIT

data/Rakefile

@@ -0,0 +1,85 @@
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/*_test.rb']
+  t.verbose = true
+end
+
+desc "auto-generate README"
+task :readme do
+  header = "Sub\n===\n\n"
+  help = `./bin/sub --help`
+  if $?.exitstatus != 0
+    $stderr.puts "./bin/sub --help not found!"
+    exit 1
+  end
+  before = File.read("README")
+  File.open("README", 'w+') do |f|
+    f.write(header + help)
+  end
+  after = File.read("README")
+  puts "generated README"
+  puts "changed: #{before != after}"
+end
+
+desc "Install (copy files to /usr/local/bin or INSTALL_PREFIX). Use sudo if necessary."
+task :install do
+  require "fileutils"
+  install_dir = ENV["INSTALL_PREFIX"] || "/usr/local/bin"
+  unless File.directory?(install_dir)
+    $stderr.puts "Directory #{install_dir} does not exist. Install failed."
+    exit 1
+  end
+  paths = ENV["PATH"].split(":")
+  unless paths.include?(install_dir)
+    $stderr.puts "#{install_dir} is not in your PATH. Install failed."
+  end
+  bin_file = File.join(File.dirname(__FILE__), "bin", "sub")
+  unless File.exist?(bin_file)
+    $stderr.puts "File #{bin_file} doesn't exist. Error: install failed."
+    exit 1
+  end
+  begin
+    FileUtils.cp(bin_file, install_dir)
+  rescue Errno::EACCES => e
+    $stderr.puts "Failed to install"
+    $stderr.puts e.message
+    if `logname`.strip != 'root'
+      $stderr.puts "Hint: Try using sudo before the command: sudo rake install"
+    end
+    exit 1
+  end
+  if (which = `which sub`.strip) != File.join(install_dir, 'sub')
+    $stderr.puts "Warning: `which sub` returned wrong value: '#{which}'"
+  end
+  exit 0
+end
+
+desc "Uninstall (removes /usr/local/bin/sub or $(INSTALL_PREFIX)/sub). Use sudo if necessary."
+task :uninstall do
+  install_dir = ENV["INSTALL_PREFIX"] || "/usr/local/bin"
+  unless File.directory?(install_dir)
+    $stderr.puts "Directory #{install_dir} does not exist. Uninstall failed."
+    exit 1
+  end
+  bin_file = File.join(install_dir, "sub")
+  unless File.exist?(bin_file)
+    $stderr.puts "File #{bin_file} doesn't exist."
+    exit 0
+  end
+  begin
+    FileUtils.rm(bin_file)
+  rescue Errno::EACCES => e
+    $stderr.puts "Failed to uninstall"
+    $stderr.puts e.message
+    if `logname`.strip != 'root'
+      $stderr.puts "Hint: Try using sudo before the command: sudo rake uninstall"
+    end
+    exit 1
+  end
+  system("which sub")
+  if $?.exitstatus == 0
+    $stderr.puts "Warning: sub is still in your PATH"
+  end
+  exit 0
+end

data/bin/sub

@@ -0,0 +1,426 @@
+#!/usr/bin/env ruby
+# vim: set ft=ruby
+# frozen_string_literal: true
+
+VERSION = "0.1.1"
+
+USAGE = <<EOF
+Usage: sub COMMANDLINE -- (PATTERN/SUBSTITUTION[/SUB_OPTIONS])+ (/GLOBAL_OPTIONS)?
+
+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
+the 'g' flag is given. There are various options that change the way substitutions
+are performed or the way matches are made. Patterns can have regular expression
+wildcards (special characters) in them, and the regular expression engine used is
+Ruby's. Special characters are interpreted as special unless the 'L' flag is given.
+
+See [https://docs.ruby-lang.org/en/master/Regexp.html#class-Regexp-label-Special+Characters]
+for more information on the special characters that can be used inside patterns.
+
+The sub utility is useful mainly when editing long commandlines, so you don't have to
+<ctrl-b> and <ctrl-f> (or <left> and <right>) through the commandline to edit it. The
+examples given here don't feature long commandlines for the sake of being brief and
+explanatory.
+
+Ex: sub ld -m elf_i386 ex4.o -o ex4 -- ex4/ex5
+    This will output the following, and then execute it:
+    ld -m elf_i386 ex5.o -o ex5
+
+Multiple substitutions:
+
+  Multiple substitutions can be given as well, such as:
+
+  Ex: sub ld -m elf_i386 ex4.o -o ex4 -- ex4/ex5 i386/arm64
+      ld -m elf_arm64 ex5.o -o ex5
+
+  If multiple substitutions are given, each subsitution pattern is matched with
+  each word, then the next substitution pattern does the same.
+
+Global flags:
+  Global flags can be given as the last argument:
+
+  ex: sub find . | grep '.txt' -- txt/md /p
+  In this example, the print flag is given as a final argument.
+  See flags information below.
+EOF
+
+INSTALLATION = <<EOF
+Install:
+\tcd $HOME
+\tgit clone git@github.com:luke-gru/sub.git
+\tcd sub
+\tsudo rake install # creates /usr/local/bin/sub
+\t# or
+\t# INSTALL_PREFIX="/bin" sudo rake install
+EOF
+
+UNINSTALLATION = <<EOF
+Uninstall:
+\tcd $HOME/sub
+\tsudo rake uninstall # removes /usr/local/bin/sub
+\t# or
+\t# INSTALL_PREFIX="/bin" sudo rake uninstall # removes /bin/sub
+EOF
+
+LICENSE = "License: MIT"
+
+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",
+  },
+  { flag: 'l', name: :last_match, desc: "Substitute last matching word only",
+    example: "sub ls -al -- l//l #=> ls -a",
+  },
+  { flag: 'L', name: :literal, desc: "Interpret wildcards in pattern as literals",
+    example: "sub cp here.txt there.txt -- ./_/L #=> cp here_txt there_txt",
+  },
+  { flag: 'i', name: :ignorecase, desc: "Set pattern to ignore the case of the match",
+    example: "sub cp here.txt there.txt -- CP/mv/i #=> mv here.txt there.txt",
+  },
+  { 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" ]
+  },
+  nil, # separator
+  # 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)" },
+  { flag: 'c', name: :copy_to_clipboard, desc: "Copy the command to clipboard instead of executing it" },
+  { flag: 'I', name: :interactive, desc: "Set interactive mode: shows the command and asks if you want to execute it" },
+  { 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
+
+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"
+    if ex = fhash[:example]
+      case ex
+      when String
+        output << "  \t  ex: #{ex}\n"
+      when Array
+        ex.each do |x|
+          output << "  \t  ex: #{x}\n"
+        end
+      end
+    end
+  end
+  if full
+    output << "\n" << INSTALLATION
+    output << "\n" << UNINSTALLATION
+    output << "\n" << LICENSE
+  end
+  $stdout.puts output
+end
+
+def print_version
+  $stdout.puts VERSION
+end
+
+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
+  else
+    last_dashdash_idx = argv.rindex('--')
+    argv.each_with_index do |arg, i|
+      if arg == '--' && i == last_dashdash_idx
+        j = i+1
+        while sub_str = argv[j]
+          sub_strs << sub_str
+          j += 1
+        end
+        break
+      else
+        ret_argv << arg
+      end
+    end
+  end
+  if sub_strs.empty?
+    cmd = ret_argv.shift
+    if cmd == "--help" || cmd == "-h"
+      print_help(full: cmd == "--help")
+      exit 0
+    elsif cmd == "--version" || cmd == "-v"
+      print_version
+      exit 0
+    end
+    exec cmd, *ret_argv
+  end
+  [ret_argv, sub_strs]
+end
+
+argv, sub_strs = parse_argv_and_sub_strs(ARGV)
+
+def 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}"
+end
+
+def raw_global_options?(raw_flags)
+  raw_flags = raw_flags.strip
+  return false if raw_flags.empty?
+  raw_flags.gsub(Regexp.new(GLOBAL_FLAGS.join('|')), '').empty?
+end
+
+def parse_sub_strs(sub_strs)
+  ret = []
+  pats = []
+  subs = []
+  match_flags = []
+  global_flags = GLOBAL_FLAGS_MAP.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])
+      flags = sub_str[1..-1]
+    else
+      pat, sub, flags = sub_str.split(/(?<!\\)\//)
+      pat = pat.to_s.dup
+      sub = sub.to_s.dup
+      flags = flags.to_s.dup
+      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)),
+      }
+      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
+    unless flags.empty?
+      $stderr.puts "Warning: unknown flag#{'s' if flags.size != 1}: #{flags}"
+    end
+  end
+
+  ret << pats << subs << match_flags << raw_flags << global_flags
+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]"
+  exit 1
+end
+
+def build_regexps(pats, flags_hashes)
+  ret = []
+  pats.each_with_index do |pat, idx|
+    flags = flags_hashes[idx]
+    regexp_opts = String.new
+    regexp_opts << 'i' if flags.fetch(:ignorecase)
+    ret << if flags.fetch(:literal)
+      Regexp.new Regexp.escape(pat), regexp_opts
+    else
+      Regexp.new(pat, regexp_opts)
+    end
+  end
+  ret
+end
+
+regexps = build_regexps(pats, flags_hashes)
+
+NextRegexpIteration = Class.new(StopIteration)
+
+def argv_replace!(argv, regexps, subs, flags)
+  raise ArgumentError unless [regexps.size, subs.size, flags.size].uniq.size == 1
+  num_replacements = 0
+
+  argv.map! { |arg| arg.frozen? ? arg.dup : arg } # make sure they're mutable
+
+  regexps.each_with_index do |regexp, i|
+    begin
+      iter_method = flags[i].fetch(:last_match) ? :reverse_each : :each
+      argv.send(iter_method) do |arg|
+        if arg =~ regexp
+          if flags[i].fetch(:general)
+            new_arg = arg.gsub(regexp, subs[i])
+            scan_size = arg.scan(regexp).size
+          else
+            new_arg = arg.sub(regexp, subs[i])
+            scan_size = arg.scan(regexp).size
+            scan_size = 1 if scan_size > 1
+          end
+          if new_arg != arg || new_arg == subs[i]
+            num_replacements += scan_size
+          end
+          arg.replace(new_arg)
+          if flags[i].fetch(:first_match) || flags[i].fetch(:last_match)
+            raise NextRegexpIteration
+          end
+        end
+      end
+    rescue NextRegexpIteration
+      # continue
+    end
+  end
+
+  argv.delete_if { |arg| arg.strip.empty? }
+
+  num_replacements
+end
+
+num_replacements = argv_replace!(argv, regexps, subs, flags_hashes)
+
+def copy!(cmd_line, global_flags)
+  cmd_line = cmd_line.dup
+  cmd_line << "\n" if cmd_line.empty?
+  if /linux/i =~ RUBY_PLATFORM
+    copy_bin = "xclip"
+    copy_cmd = "xclip -selection clipboard"
+    copy_proc = lambda do |f|
+      system("#{copy_cmd} < #{f.path}", out: "/dev/null")
+    end
+  elsif /darwin/i =~ RUBY_PLATFORM
+    copy_bin = "pbcopy"
+    copy_cmd = copy_bin
+    copy_proc = lambda do |f|
+      system("cat #{f.path} | #{copy_cmd}", out: "/dev/null")
+    end
+  else
+    $stderr.puts "Warning: don't know how to get copy command for #{RUBY_PLATFORM}"
+    global_flags[:print_only] = true
+    return
+  end
+  system("which #{copy_bin}", out: "/dev/null")
+  unless $?.success?
+    $stderr.puts "Warning: can't find #{copy_bin}, please install it and put it in your PATH"
+    global_flags[:print_only] = true
+    return
+  end
+  require "tempfile"
+  Tempfile.create("sub_cmd") do |f|
+    f.write cmd_line
+    f.flush
+    copy_proc.call(f)
+    puts "Copied" if $?.success?
+  end
+end
+
+def exec_cmd(argv, regexps, subs, raw_flags, num_replacements, global_flags)
+  if global_flags.fetch(:debug)
+    puts "Patterns: #{regexps.inspect}"
+    puts "Substitutions: #{subs.inspect}"
+    puts "Flags: #{raw_flags.inspect}"
+  end
+  if global_flags.fetch(:verbose)
+    puts "#{num_replacements} replacement#{'s' if num_replacements != 1}"
+  end
+
+  if argv.empty?
+    copy!("", global_flags) if global_flags.fetch(:copy_to_clipboard)
+    if global_flags.fetch(:print_only)
+      puts ""
+    elsif global_flags.fetch(:print_only_no_newline)
+      print "" # does nothing
+    else
+      puts "Nothing to execute"
+    end
+    exit 0
+  end
+
+  cmd = argv.shift
+  cmd_line = "#{cmd} #{argv.join(' ')}"
+  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
+    ans = $stdin.gets().strip
+    if ans !~ /y(es)?/i # treat as no
+      exit 1
+    end
+  end
+  if global_flags.fetch(:print_only) || global_flags.fetch(:print_only_no_newline) || !global_flags.fetch(:interactive)
+    print_method = global_flags.fetch(:print_only_no_newline) ? :print : :puts
+    $stdout.send(print_method, cmd_line)
+    $stdout.flush
+  end
+  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
+  rescue SystemCallError => e
+    if e.class == Errno::ENOENT
+      # act like a shell
+      $stderr.puts "#{cmd}: command not found"
+    else
+      $stderr.puts "#{e.class}: #{e.message}"
+    end
+    exit e.errno
+  end
+end
+
+exec_cmd(argv, regexps, subs, raw_flags, num_replacements, global_flags)

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: cmdline-sub
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Luke Gruber
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-11-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: debug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.9.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.9.2
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.25.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.25.1
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 13.2.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 13.2.1
+description: |
+  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
+  the 'g' flag is given. There are various options that change the way substitutions
+  are performed or the way matches are made. Patterns can have regular expression
+  wildcards (special characters) in them, and the regular expression engine used is
+  Ruby's. Special characters are interpreted as special unless the 'L' flag is given.
+email: luke.gru@gmail.com
+executables:
+- sub
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- README
+- Rakefile
+- bin/sub
+homepage: https://github.com/luke-gru/sub
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.16
+signing_key:
+specification_version: 4
+summary: Sub is a commandline substitution editor
+test_files: []