howzit 1.2.11 → 1.2.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 24b630c81dbd81b43b8572bbc91baabe96063a17c3cb6295a8026e6a3176dd39
-  data.tar.gz: 04c98ab9c7a9c57e8c7536e7709b57d51b965a76cc315c846c46dca3a0a2105e
+  metadata.gz: 3858dec6b009f75173d3d72067a94c330cb826b0e367109c7416b2db19065fa8
+  data.tar.gz: 2e05520b1ff9d5da82aba03b1af3ed31ee0a635f3fe42c50b3a515c45337c38b
 SHA512:
-  metadata.gz: 3ce4d9a3cd8cd8970cd37e5b90c7154c0b66de06827780c4e38bb4f358d517b8c81d720383cbaa8fa84ff74f56a9f1f60e554f92614cf12e4f1f563092d9d651
-  data.tar.gz: 5187fbd097d9171ddd3756f9df92e62b0df5309d7e1d2e0aef26551f6641340d65ade5f49f1c9b0a47852e6913c64d5914d334732e15a1ac71f2277edde38fe7
+  metadata.gz: 90cb7e647c7956823e73eac6e4884a1ffe26875acd531cc70be6a1b334aa9653213cafbf0830cd69a634579c7fa61553585bbbc95f997a02b0192d093a85be1b
+  data.tar.gz: bfba515bc66d5f15ae33d967866e83e2e9e4c887160d0c66269542ee909acf8383742fd0e64f5639013a1ccdc16253664a3c90cd150fd5a67529280473ed1a88

data/.gitignore

@@ -41,3 +41,4 @@ Gemfile.lock
 
 # unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
 .rvmrc
+results.log

data/CHANGELOG.md

@@ -1,3 +1,30 @@
+### 1.2.14
+
+2022-08-02 11:01
+
+#### NEW
+
+- Config option and flag to determine how to handle multiple results (first, best, all, choose)
+- --config-get and --config-set flags for working with config options
+
+#### IMPROVED
+
+- Allow multiple selections when using fzf
+- Clean up newlines in output
+
+### 1.2.13
+
+2022-08-01 20:50
+
+### 1.2.12
+
+2022-08-01 16:23
+
+#### IMPROVED
+
+- Replace ANSI escape codes with color template system
+- When @including an external file, if the file doesn't contain any level 2+ headers, import it as plain text.
+
 ### 1.2.11
 
 2022-08-01 08:23

data/README.md

@@ -24,11 +24,10 @@ Howzit is a tool that allows you to keep Markdown-formatted notes about a projec
 
 ## Getting Started
 
-Howzit is a simple, self-contained script (at least until I get stupid and make a gem out of it).
-
 ### Prerequisites
 
 - Ruby 2.4+ (It probably works on older Rubys, but is untested prior to 2.4.1.)
+- Optional: if [`fzf`](https://github.com/junegunn/fzf) is available, it will be used for handling multiple choice selections
 - Optional: if [`bat`](https://github.com/sharkdp/bat) is available it will page with that
 - Optional: [`mdless`](https://github.com/ttscoff/mdless) or [`mdcat`](https://github.com/lunaryorn/mdcat) for formatting output
 
@@ -200,6 +199,10 @@ Include a topic name to see just that topic, or no argument to display all.
 
     howzit build
 
+You can combine multiple topic searches by separating with a comma. When multiple results are returned, the `:multiple_results:` configuration determines how they're handled.
+
+    howzit build,deploy
+
 Use `-l` to list all topics.
 
     howzit -l
@@ -216,12 +219,15 @@ Other options:
 
     Options:
         -c, --create                     Create a skeleton build note in the current working directory
-        -e, --edit                       Edit buildnotes file in current working directory using editor.sh
+        -e, --edit                       Edit buildnotes file in current working directory
+                    using $EDITOR
             --grep PATTERN               Display sections matching a search pattern
         -L, --list-completions           List topics for completion
         -l, --list                       List available topics
         -m, --matching TYPE              Topics matching type
                                          (partial, exact, fuzzy, beginswith)
+            --multiple TYPE              Multiple result handling
+                                         (first, all, choose)
         -R, --list-runnable              List topics containing @ directives (verbose)
         -r, --run                        Execute @run, @open, and/or @copy commands for given topic
         -s, --select                     Select topic from menu
@@ -229,10 +235,10 @@ Other options:
         -t, --title                      Output title with build notes
         -q, --quiet                      Silence info message
             --verbose                    Show all messages
-        -u, --upstream                   Traverse up parent directories for additional build notes
+        -u, --[no-]upstream              Traverse up parent directories for additional build notes
             --show-code                  Display the content of fenced run blocks
         -w, --wrap COLUMNS               Wrap to specified width (default 80, 0 to disable)
-            --edit-config                Edit configuration file using editor.sh
+            --edit-config                Edit configuration file using default $EDITOR
             --title-only                 Output title only
             --templates                  List available templates
             --[no-]color                 Colorize output (default on)
@@ -240,6 +246,7 @@ Other options:
             --[no-]pager                 Paginate output (default on)
         -h, --help                       Display this screen
         -v, --version                    Display version number
+            --default                    Answer all prompts with default response
 
 
 ## Configuration
@@ -257,6 +264,7 @@ Some of the command line options can be set as defaults. The first time you run
     :matching: partial
     :include_upstream: false
     :log_level: 1
+    :multiple_matches: choose
 
 If `:color:` is false, output will not be colored, and markdown highlighting will be bypassed.
 
@@ -272,6 +280,8 @@ If `:include_upstream:` is true, build note files in parent directories will be
 
 Set `:log_level:` to 0 for debug messages, or 3 to suppress superfluous info messages.
 
+`:multiple_matches:` determines how howzit will handle cases where a search results in multiple matches. It can be set to "first" (first match in notes), "best" (shortest topic match), "all" (display all results), or "choose" (displays a menu of results). Default is "choose." When grepping for results, only "all" or "choose" are valid, if the default is something else, "choose" will be used. Can be overridden with the `--multiple TYPE` flag.
+
 ### Matching
 
 All matching is case insensitive. This setting can be overridden by the `--matching TYPE` flag on the command line.

data/Rakefile

@@ -18,3 +18,19 @@ RuboCop::RakeTask.new do |t|
 end
 
 YARD::Rake::YardocTask.new
+
+desc 'Development version check'
+task :ver do
+  gver = `git ver`
+  cver = IO.read(File.join(File.dirname(__FILE__), 'CHANGELOG.md')).match(/^#+ (\d+\.\d+\.\d+(\w+)?)/)[1]
+  res = `grep VERSION lib/howzit/version.rb`
+  version = res.match(/VERSION *= *['"](\d+\.\d+\.\d+(\w+)?)/)[1]
+  puts "git tag: #{gver}"
+  puts "version.rb: #{version}"
+  puts "changelog: #{cver}"
+end
+
+desc 'Changelog version check'
+task :cver do
+  puts IO.read(File.join(File.dirname(__FILE__), 'CHANGELOG.md')).match(/^#+ (\d+\.\d+\.\d+(\w+)?)/)[1]
+end

data/bin/howzit

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby
+#!/usr/bin/env ruby -W1
 # frozen_string_literal: true
 
 $LOAD_PATH.unshift File.join(__dir__, '..', 'lib')
@@ -6,4 +6,3 @@ require 'howzit'
 
 how = Howzit::BuildNotes.new(ARGV)
 how.process
-

data/lib/howzit/buildnotes.rb

@@ -2,8 +2,9 @@ module Howzit
   # Primary Class for this module
   class BuildNotes
     include Prompt
+    include Color
 
-    attr_accessor :cli_args, :arguments, :metadata
+    attr_accessor :cli_args, :options, :arguments, :metadata
 
     def topics
       @topics ||= read_help
@@ -40,8 +41,8 @@ module Howzit
     # favoring environment settings
     def which_pager
       if @options[:pager] =~ /auto/i
-        pagers = [ENV['GIT_PAGER'], ENV['PAGER'],
-                  'bat', 'less', 'more', 'cat', 'pager']
+        pagers = [ENV['PAGER'], ENV['GIT_PAGER'],
+                  'bat', 'less', 'more', 'pager']
         pagers.delete_if(&:nil?).select!(&:available?)
         return nil if pagers.empty?
 
@@ -123,7 +124,7 @@ module Howzit
         pipes = "|#{hl}" if hl
       end
 
-      output = `echo #{Shellwords.escape(string.strip)}#{pipes}`
+      output = `echo #{Shellwords.escape(string.strip)}#{pipes}`.strip
 
       if @options[:paginate]
         page(output)
@@ -145,12 +146,12 @@ module Howzit
       choices.each do |choice|
         case choice
         when /[A-Z]/
-          out.push("\e[1;32m#{choice}\e[0;32m")
+          out.push(Color.template("{bg}#{choice}{xg}"))
         else
-          out.push(choice)
+          out.push(Color.template("{w}#{choice}"))
         end
       end
-      "\e[0;32m[#{out.join('/')}]\e[0m"
+      Color.template("{g}[#{out.join('/')}{g}]{x}")
     end
 
     # Create a buildnotes skeleton
@@ -159,30 +160,40 @@ module Howzit
         warn "\nCanceled"
         exit!
       end
+      default = !$stdout.isatty || @options[:default]
       # First make sure there isn't already a buildnotes file
       if note_file
-        fname = "\e[1;33m#{note_file}\e[1;37m"
-        res = yn("#{fname} exists and appears to be a build note, continue anyway?", false)
-        unless res
-          puts 'Canceled'
-          Process.exit 0
+        fname = Color.template("{by}#{note_file}{bw}")
+        unless default
+          res = yn("#{fname} exists and appears to be a build note, continue anyway?", false)
+          unless res
+            puts 'Canceled'
+            Process.exit 0
+          end
         end
       end
 
       title = File.basename(Dir.pwd)
-      printf "\e[1;37mProject name \e[0;32m[#{title}]\e[1;37m: \e[0m"
-      input = STDIN.gets.chomp
-      title = input unless input.empty?
-
+      if default
+        input = title
+      else
+        printf Color.template("{bw}Project name {xg}[#{title}]{bw}: {x}")
+        input = $stdin.gets.chomp
+        title = input unless input.empty?
+      end
       summary = ''
-      printf "\e[1;37mProject summary: \e[0m"
-      input = STDIN.gets.chomp
-      summary = input unless input.empty?
+      unless default
+        printf Color.template('{bw}Project summary: {x}')
+        input = $stdin.gets.chomp
+        summary = input unless input.empty?
+      end
 
-      filename = 'buildnotes.md'
-      printf "\e[1;37mBuild notes filename (must begin with 'howzit' or 'build')\n\e[0;32m[#{filename}]\e[1;37m: \e[0m"
-      input = STDIN.gets.chomp
-      filename = input unless input.empty?
+      fname = 'buildnotes.md'
+      unless default
+        printf Color.template("{bw}Build notes filename (must begin with 'howzit' or 'build')\n{xg}[#{fname}]{bw}: {x}")
+        input = $stdin.gets.chomp
+        fname = input unless input.empty?
+      end
 
       note = <<~EOBUILDNOTES
         # #{title}
@@ -209,8 +220,8 @@ module Howzit
 
       EOBUILDNOTES
 
-      if File.exist?(filename)
-        file = "\e[1;33m#{filename}"
+      if File.exist?(fname) && !default
+        file = Color.template("{by}#{fname}")
         res = yn("Are you absolutely sure you want to overwrite #{file}", false)
 
         unless res
@@ -219,9 +230,9 @@ module Howzit
         end
       end
 
-      File.open(filename, 'w') do |f|
+      File.open(fname, 'w') do |f|
         f.puts note
-        puts "Build notes for #{title} written to #{filename}"
+        puts Color.template("{by}Build notes for #{title} written to #{fname}")
       end
     end
 
@@ -229,8 +240,8 @@ module Howzit
     def format_header(title, opts = {})
       options = {
         hr: "\u{254C}",
-        color: '1;32',
-        border: '0',
+        color: '{bg}',
+        border: '{x}',
         mark: false
       }
 
@@ -239,29 +250,29 @@ module Howzit
       cols = TTY::Screen.columns
 
       cols = @options[:wrap] if (@options[:wrap]).positive? && cols > @options[:wrap]
-      title = "\e[#{options[:border]}m#{options[:hr] * 2}( \e[#{options[:color]}m#{title}\e[#{options[:border]}m )"
+      title = Color.template("#{options[:border]}#{options[:hr] * 2}( #{options[:color]}#{title}#{options[:border]} )")
 
       tail = if should_mark_iterm?
                "#{options[:hr] * (cols - title.uncolor.length - 15)}#{options[:mark] ? iterm_marker : ''}"
              else
                options[:hr] * (cols - title.uncolor.length)
              end
-      "#{title}#{tail}\e[0m"
+      Color.template("#{title}#{tail}{x}")
     end
 
     def os_open(command)
       os = RbConfig::CONFIG['target_os']
-      out = "\e[1;32mOpening \e[3;37m#{command}"
+      out = Color.template("{bg}Opening {bw}#{command}")
       case os
       when /darwin.*/i
-        warn "#{out} (macOS)\e[0m" if @options[:log_level] < 2
+        warn Color.template("#{out} (macOS){x}") if @options[:log_level] < 2
         `open #{Shellwords.escape(command)}`
       when /mingw|mswin/i
-        warn "#{out} (Windows)\e[0m" if @options[:log_level] < 2
+        warn Color.template("#{out} (Windows){x}") if @options[:log_level] < 2
         `start #{Shellwords.escape(command)}`
       else
         if 'xdg-open'.available?
-          warn "#{out} (Linux)\e[0m" if @options[:log_level] < 2
+          warn Color.template("#{out} (Linux){x}") if @options[:log_level] < 2
           `xdg-open #{Shellwords.escape(command)}`
         else
           warn out if @options[:log_level] < 2
@@ -300,7 +311,7 @@ module Howzit
         directives.each do |c|
           if c[0].nil?
             title = c[3] ? c[3].strip : ''
-            warn "\e[1;32mRunning block \e[3;37m#{title}\e[0m" if @options[:log_level] < 2
+            warn Color.template("{bg}Running block {bw}#{title}{x}") if @options[:log_level] < 2
             block = c[4].strip
             script = Tempfile.new('howzit_script')
             begin
@@ -322,18 +333,18 @@ module Howzit
                 warn "No topic match for @include(#{search})"
               else
                 if @included.include?(matches[0])
-                  warn "\e[1;33mTasks from \e[3;37m#{matches[0]} already included, skipping\e[0m" if @options[:log_level] < 2
+                  warn Color.template("{by}Tasks from {bw}#{matches[0]} already included, skipping{x}") if @options[:log_level] < 2
                 else
-                  warn "\e[1;33mIncluding tasks from \e[3;37m#{matches[0]}\e[0m" if @options[:log_level] < 2
+                  warn Color.template("{by}Including tasks from {bw}#{matches[0]}{x}") if @options[:log_level] < 2
                   process_topic(matches[0], true)
-                  warn "\e[1;33mEnd include \e[3;37m#{matches[0]}\e[0m" if @options[:log_level] < 2
+                  warn Color.template("{by}End include {bw}#{matches[0]}{x}") if @options[:log_level] < 2
                 end
               end
             when /run/i
-              warn "\e[1;32mRunning \e[3;37m#{obj}\e[0m" if @options[:log_level] < 2
+              warn Color.template("{bg}Running {bw}#{obj}{x}") if @options[:log_level] < 2
               system(obj)
             when /copy/i
-              warn "\e[1;32mCopied \e[3;37m#{obj}\e[1;32m to clipboard\e[0m" if @options[:log_level] < 2
+              warn Color.template("{bg}Copied {bw}#{obj}{bg} to clipboard{x}") if @options[:log_level] < 2
               `echo #{Shellwords.escape(obj)}'\\c'|pbcopy`
             when /open|url/i
               os_open(obj)
@@ -341,11 +352,13 @@ module Howzit
           end
         end
       else
-        warn "\e[0;31m--run: No \e[1;31m@directive\e[0;31;40m found in \e[1;37m#{key}\e[0m"
+        warn Color.template("{r}--run: No {br}@directive{xr} found in {bw}#{key}{x}")
       end
       output.push("Ran #{tasks} #{tasks == 1 ? 'task' : 'tasks'}") if @options[:log_level] < 2
 
-      puts postreqs.join("\n\n")
+      puts postreqs.join("\n\n") unless postreqs.empty?
+
+      output
     end
 
     # Output a topic with fancy title and bright white text.
@@ -371,12 +384,12 @@ module Howzit
           unless matches.empty?
             if opt[:single]
               title = "From #{matches[0]}:"
-              color = '33;40'
-              rule = '30;40'
+              color = '{Kyd}'
+              rule = '{kKd}'
             else
               title = "Include #{matches[0]}"
-              color = '33;40'
-              rule = '0'
+              color = '{Kyd}'
+              rule = '{kKd}'
             end
             output.push(format_header("#{'> ' * @nest_level}#{title}", { color: color, hr: '.', border: rule })) unless @included.include?(matches[0])
 
@@ -405,15 +418,15 @@ module Howzit
                  when /open|url/
                    "\u{279A}"
                  end
-          output.push("\e[1;35;40m#{icon} \e[3;37;40m#{obj}\e[0m")
+          output.push(Color.template("{bmK}#{icon} {bwK}#{obj}{x}"))
         when /(`{3,})run *(.*?)$/i
           m = Regexp.last_match
           desc = m[2].length.positive? ? "Block: #{m[2]}" : 'Code Block'
-          output.push("\e[1;35;40m\u{25B6} \e[3;37;40m#{desc}\e[0m\n```")
+          output.push(Color.template("{bmK}\u{25B6} {bwK}#{desc}{x}\n```"))
         when /@@@run *(.*?)$/i
           m = Regexp.last_match
           desc = m[1].length.positive? ? "Block: #{m[1]}" : 'Code Block'
-          output.push("\e[1;35;40m\u{25B6} \e[3;37;40m#{desc}\e[0m")
+          output.push(Color.template("{bmK}\u{25B6} {bwK}#{desc}{x}"))
         else
           l.wrap!(@options[:wrap]) if (@options[:wrap]).positive?
           output.push(l)
@@ -438,15 +451,15 @@ module Howzit
                else
                  output_topic(key, {single: single})
                end
-      output.nil? ? '' : output.join("\n")
+      output.nil? ? '' : output.join("\n").strip
     end
 
     # Output a list of topic titles
     def list_topics
       output = []
-      output.push("\e[1;32mTopics:\e[0m\n")
+      output.push(Color.template("{bg}Topics:{x}\n"))
       topics.each_key do |title|
-        output.push("- \e[1;37m#{title}\e[0m")
+        output.push(Color.template("- {bw}#{title}{x}"))
       end
       output.join("\n")
     end
@@ -456,14 +469,14 @@ module Howzit
       topics.keys.join("\n")
     end
 
-    def get_note_title(filename, truncate = 0)
+    def get_note_title(truncate = 0)
       title = nil
-      help = IO.read(filename).strip
+      help = IO.read(note_file).strip
       title = help.match(/(?:^(\S.*?)(?=\n==)|^# ?(.*?)$)/)
       title = if title
                 title[1].nil? ? title[2] : title[1]
               else
-               filename.sub(/(\.\w+)?$/, '')
+               note_file.sub(/(\.\w+)?$/, '')
              end
 
       title && truncate.positive? ? title.trunc(truncate) : title
@@ -486,7 +499,7 @@ module Howzit
 
     def list_runnable
       output = []
-      output.push(%(\e[1;32m"Runnable" Topics:\e[0m\n))
+      output.push(Color.template(%({bg}"Runnable" Topics:{x}\n)))
       topics.each do |title, sect|
         s_out = []
         lines = sect.split(/\n/)
@@ -507,7 +520,7 @@ module Howzit
           end
         end
         unless s_out.empty?
-          output.push("- \e[1;37m#{title}\e[0m")
+          output.push(Color.template("- {bw}#{title}{x}"))
           output.push(s_out.join("\n"))
         end
       end
@@ -531,8 +544,8 @@ module Howzit
           required = t_meta['required'].strip.split(/\s*,\s*/)
           required.each do |req|
             unless @metadata.keys.include?(req.downcase)
-              warn %(\e[0;31mERROR: Missing required metadata key from template '\e[1;37m#{File.basename(template, '.md')}\e[0;31m'\e[0m)
-              warn %(\e[0;31mPlease define \e[1;33m#{req.downcase}\e[0;31m in build notes\e[0m)
+              warn Color.template(%({xr}ERROR: Missing required metadata key from template '{bw}#{File.basename(template, '.md')}{xr}'{x}))
+              warn Color.template(%({xr}Please define {by}#{req.downcase}{xr} in build notes{x}))
               Process.exit 1
             end
           end
@@ -581,6 +594,24 @@ module Howzit
       template_topics
     end
 
+    def include_file(m)
+      file = File.expand_path(m[1])
+
+      return m[0] unless File.exist?(file)
+
+      content = IO.read(file)
+      home = ENV['HOME']
+      short_path = File.dirname(file.sub(/^#{home}/, '~'))
+      prefix = "#{short_path}/#{File.basename(file)}:"
+      parts = content.split(/^##+/)
+      parts.shift
+      if parts.empty?
+        content
+      else
+        "## #{parts.join('## ')}".gsub(/^(##+ *)(?=\S)/, "\\1#{prefix}")
+      end
+    end
+
     # Read in the build notes file and output a hash of "Title" => contents
     def read_help_file(path = nil)
       filename = path.nil? ? note_file : path
@@ -588,21 +619,7 @@ module Howzit
       help = IO.read(filename)
 
       help.gsub!(/@include\((.*?)\)/) do
-        m = Regexp.last_match
-        file = File.expand_path(m[1])
-        if File.exist?(file)
-          content = IO.read(file)
-          home = ENV['HOME']
-          short_path = File.dirname(file.sub(/^#{home}/, '~'))
-          prefix = "#{short_path}:"
-          parts = content.split(/^##+/)
-          parts.shift
-          content = '## ' + parts.join('## ')
-          content.gsub!(/^(##+ *)(?=\S)/, "\\1#{prefix}")
-          content
-        else
-          m[0]
-        end
+        include_file(Regexp.last_match)
       end
 
       template_topics = get_template_topics(help)
@@ -674,6 +691,7 @@ module Howzit
     end
 
     def initialize(args = [])
+      Color.coloring = $stdout.isatty
       flags = {
         run: false,
         list_topics: false,
@@ -683,7 +701,9 @@ module Howzit
         title_only: false,
         choose: false,
         quiet: false,
-        verbose: false
+        verbose: false,
+        default: false,
+        grep: nil
       }
 
       defaults = {
@@ -698,7 +718,7 @@ module Howzit
         show_all_on_error: false,
         include_upstream: false,
         show_all_code: false,
-        grep: nil,
+        multiple_matches: 'choose',
         log_level: 1 # 0: debug, 1: info, 2: warn, 3: error
       }
 
@@ -727,7 +747,7 @@ module Howzit
         end
 
         opts.on('-e', '--edit', "Edit buildnotes file in current working directory
-                using #{File.basename(ENV['EDITOR'])}") do
+                using $EDITOR") do
           edit_note
           Process.exit 0
         end
@@ -750,6 +770,11 @@ module Howzit
           @options[:matching] = c
         end
 
+        opts.on('--multiple TYPE', MULTIPLE_OPTIONS,
+                'Multiple result handling', "(#{MULTIPLE_OPTIONS.join(', ')}, default choose)") do |c|
+          @options[:multiple_matches] = c.to_sym
+        end
+
         opts.on('-R', '--list-runnable', 'List topics containing @ directives (verbose)') do
           @options[:list_runnable] = true
         end
@@ -779,8 +804,8 @@ module Howzit
           @options[:log_level] = 0
         end
 
-        opts.on('-u', '--upstream', 'Traverse up parent directories for additional build notes') do
-          @options[:include_upstream] = true
+        opts.on('-u', '--[no-]upstream', 'Traverse up parent directories for additional build notes') do |p|
+          @options[:include_upstream] = p
         end
 
         opts.on('--show-code', 'Display the content of fenced run blocks') do
@@ -791,7 +816,40 @@ module Howzit
           @options[:wrap] = w.to_i
         end
 
-        opts.on('--edit-config', "Edit configuration file using #{File.basename(ENV['EDITOR'])}") do
+        opts.on('--config-get [KEY]', 'Display the configuration settings or setting for a specific key') do |k|
+
+          if k.nil?
+            config.sort_by { |key, _| key }.each do |key, val|
+              print "#{key}: "
+              p val
+            end
+          else
+            k.sub!(/^:/, '')
+            if config.key?(k.to_sym)
+              puts config[k.to_sym]
+            else
+              puts "Key #{k} not found"
+            end
+          end
+          Process.exit 0
+        end
+
+        opts.on('--config-set KEY=VALUE', 'Set a config value (must be a valid key)') do |key|
+          raise 'Argument must be KEY=VALUE' unless key =~ /\S=\S/
+
+          k, v = key.split(/=/)
+          k.sub!(/^:/, '')
+
+          if config.key?(k.to_sym)
+            config[k.to_sym] = v.to_config_value(config[k.to_sym])
+          else
+            puts "Key #{k} not found"
+          end
+          write_config(config)
+          Process.exit 0
+        end
+
+        opts.on('--edit-config', "Edit configuration file using default $EDITOR") do
           edit_config(defaults)
           Process.exit 0
         end
@@ -805,21 +863,21 @@ module Howzit
           Dir.chdir(template_folder)
           Dir.glob('*.md').each do |file|
             template = File.basename(file, '.md')
-            puts "\e[7;30;45mtemplate: \e[7;33;40m#{template}\e[0m"
-            puts "\e[1;30m[\e[1;37mtasks\e[1;30m]──────────────────────────────────────┐\e[0m"
+            puts Color.template("{Mk}template:{Yk}#{template}{x}")
+            puts Color.template("{bk}[{bl}tasks{bk}]──────────────────────────────────────┐{x}")
             metadata = file.extract_metadata
             topics = read_help_file(file)
             topics.each_key do |topic|
-              puts " \e[1;30m│\e[1;37m-\e[0m \e[1;36;40m#{template}:#{topic.sub(/^.*?:/, '')}\e[0m"
+              puts Color.template(" {bk}│{bw}-{x} {bcK}#{template}:#{topic.sub(/^.*?:/, '')}{x}")
             end
             if metadata.size > 0
               meta = []
-              meta << metadata['required'].split(/\s*,\s*/).map {|m| "*\e[1;37m#{m}\e[0;37m" } if metadata.key?('required')
+              meta << metadata['required'].split(/\s*,\s*/).map {|m| "*{bw}#{m}{xw}" } if metadata.key?('required')
               meta << metadata['optional'].split(/\s*,\s*/).map {|m| "#{m}" } if metadata.key?('optional')
-              puts "\e[1;30m[\e[1;34mmeta\e[1;30m]───────────────────────────────────────┤\e[0m"
-              puts " \e[1;30m│\e[1;37m \e[0;37m#{meta.join(", ")}\e[0m"
+              puts Color.template("{bk}[{bl}meta{bk}]───────────────────────────────────────┤{x}")
+              puts Color.template(" {bk}│ {xw}#{meta.join(", ")}{x}")
             end
-            puts " \e[1;30m└───────────────────────────────────────────┘\e[0m"
+            puts Color.template(" {bk}└───────────────────────────────────────────┘{x}")
           end
           Process.exit 0
         end
@@ -846,8 +904,14 @@ module Howzit
           puts "Howzit v#{VERSION}"
           Process.exit 0
         end
+
+        opts.on('--default', 'Answer all prompts with default response') do
+          @options[:default] = true
+        end
       end.parse!(args)
 
+      @options[:multiple_matches] = @options[:multiple_matches].to_sym
+
       @cli_args = args
     end
 
@@ -980,12 +1044,20 @@ module Howzit
 
     def choose(matches)
       if command_exist?('fzf')
-        res = `echo #{Shellwords.escape(matches.join("\n"))} | fzf -0 -1 --height #{matches.count + 2} --prompt 'Select a section > '`.strip
+        settings = [
+          '-0',
+          '-1',
+          '-m',
+          "--height=#{matches.count + 2}",
+          '--header="Use tab to mark multiple selections, enter to display/run"',
+          '--prompt="Select a section > "'
+        ]
+        res = `echo #{Shellwords.escape(matches.join("\n"))} | fzf #{settings.join(' ')}`.strip
         if res.nil? || res.empty?
           warn 'Cancelled'
           Process.exit 0
         end
-        return res
+        return res.split(/\n/)
       end
 
       res = matches[0..9]
@@ -1034,7 +1106,7 @@ module Howzit
       File.join(config_dir, 'templates')
     end
 
-    def create_config
+    def create_config(defaults)
       dir, file = [config_dir, config_file]
       unless File.directory?(dir)
         warn "Creating config directory at #{dir}"
@@ -1049,7 +1121,7 @@ module Howzit
     end
 
     def load_config(defaults)
-      file = create_config
+      file = create_config(defaults)
       config = YAML.load(IO.read(file))
       newconfig = config ? defaults.merge(config) : defaults
       write_config(newconfig)
@@ -1083,13 +1155,13 @@ module Howzit
       end
 
       if @options[:title_only]
-        out = get_note_title(note_file, 20)
+        out = get_note_title(20)
         $stdout.print(out.strip)
         Process.exit(0)
-      elsif @options[:output_title]
-        title = get_note_title(note_file)
+      elsif @options[:output_title] && !@options[:run]
+        title = get_note_title
         if title && !title.empty?
-          header = format_header(title, { hr: "\u{2550}", color: '1;37;40' })
+          header = format_header(title, { hr: "\u{2550}", color: '{bwK}' })
           output.push("#{header}\n")
         end
       end
@@ -1115,33 +1187,49 @@ module Howzit
         Process.exit(0)
       end
 
-      topic_match = nil
+      topic_matches = []
       if @options[:grep]
-        topic_match = choose(grep_topics(@options[:grep]))
+        matches = grep_topics(@options[:grep])
+        case @options[:multiple_matches]
+        when :all
+          topic_matches.concat(matches.sort)
+        else
+          topic_matches.concat(choose(matches))
+        end
       elsif @options[:choose]
-        topic_match = choose(topics.keys)
+        topic_matches.concat(choose(topics.keys))
       # If there are arguments use those to search for a matching topic
       elsif !@cli_args.empty?
+        search = @cli_args.join(' ').strip.downcase.split(/ *, */).map(&:strip)
 
-        search = @cli_args.join(' ').strip.downcase
-        matches = match_topic(search)
+        search.each do |s|
+          matches = match_topic(s)
 
-        if matches.empty?
-          output.push(%(\e[0;31mERROR: No topic match found for \e[1;33m#{search}\e[0m\n))
-          if !@options[:show_all_on_error]
-            show(output.join("\n"), { color: true, highlight: false, paginate: false, wrap: 0 })
-            Process.exit 1
+          if matches.empty?
+            output.push(Color.template(%({bR}ERROR:{xr} No topic match found for {bw}#{s}{x}\n)))
+          else
+            case @options[:multiple_matches]
+            when :first
+              topic_matches.push(matches[0])
+            when :best
+              topic_matches.push(matches.sort.min_by(&:length))
+            when :all
+              topic_matches.concat(matches)
+            else
+              topic_matches.concat(choose(matches))
+            end
           end
-        elsif matches.length == 1
-          topic_match = matches[0]
-        else
-          topic_match = choose(matches)
+        end
+
+        if topic_matches.empty? && !@options[:show_all_on_error]
+          show(output.join("\n"), { color: true, highlight: false, paginate: false, wrap: 0 })
+          Process.exit 1
         end
       end
 
-      if topic_match
+      if !topic_matches.empty?
         # If we found a match
-        output.push(process_topic(topic_match, @options[:run], true))
+        topic_matches.each { |topic_match| output.push(process_topic(topic_match, @options[:run], true)) }
       else
         # If there's no argument or no match found, output all
         topics.each_key { |k| output.push(process_topic(k, false, false)) }

data/lib/howzit/colors.rb

@@ -0,0 +1,323 @@
+# frozen_string_literal: true
+
+# Cribbed from <https://github.com/flori/term-ansicolor>
+module Howzit
+  # Terminal output color functions.
+  module Color
+    ESCAPE_REGEX = /(?<=\[)(?:(?:(?:[349]|10)[0-9]|[0-9])?;?)+(?=m)/.freeze
+    # All available color names. Available as methods and string extensions.
+    #
+    # @example Use a color as a method. Color reset will be added to end of string.
+    #   Color.yellow('This text is yellow') => "\e[33mThis text is yellow\e[0m"
+    #
+    # @example Use a color as a string extension. Color reset added automatically.
+    #   'This text is green'.green => "\e[1;32mThis text is green\e[0m"
+    #
+    # @example Send a text string as a color
+    #   Color.send('red') => "\e[31m"
+    ATTRIBUTES = [
+      [:clear,               0], # String#clear is already used to empty string in Ruby 1.9
+      [:reset,               0], # synonym for :clear
+      [:bold,                1],
+      [:dark,                2],
+      [:italic,              3], # not widely implemented
+      [:underline,           4],
+      [:underscore,          4], # synonym for :underline
+      [:blink,               5],
+      [:rapid_blink,         6], # not widely implemented
+      [:negative,            7], # no reverse because of String#reverse
+      [:concealed,           8],
+      [:strikethrough,       9], # not widely implemented
+      [:strike,              9], # not widely implemented
+      [:black,              30],
+      [:red,                31],
+      [:green,              32],
+      [:yellow,             33],
+      [:blue,               34],
+      [:magenta,            35],
+      [:purple,             35],
+      [:cyan,               36],
+      [:white,              37],
+      [:bgblack,            40],
+      [:bgred,              41],
+      [:bggreen,            42],
+      [:bgyellow,           43],
+      [:bgblue,             44],
+      [:bgmagenta,          45],
+      [:bgpurple,           45],
+      [:bgcyan,             46],
+      [:bgwhite,            47],
+      [:boldblack,          90],
+      [:boldred,            91],
+      [:boldgreen,          92],
+      [:boldyellow,         93],
+      [:boldblue,           94],
+      [:boldmagenta,        95],
+      [:boldpurple,         95],
+      [:boldcyan,           96],
+      [:boldwhite,          97],
+      [:boldbgblack,       100],
+      [:boldbgred,         101],
+      [:boldbggreen,       102],
+      [:boldbgyellow,      103],
+      [:boldbgblue,        104],
+      [:boldbgmagenta,     105],
+      [:boldbgpurple,      105],
+      [:boldbgcyan,        106],
+      [:boldbgwhite,       107],
+      [:softpurple,  '0;35;40'],
+      [:hotpants,    '7;34;40'],
+      [:knightrider, '7;30;40'],
+      [:flamingo,    '7;31;47'],
+      [:yeller,      '1;37;43'],
+      [:whiteboard,  '1;30;47'],
+      [:chalkboard,  '1;37;40'],
+      [:led,         '0;32;40'],
+      [:redacted,    '0;30;40'],
+      [:alert,       '1;31;43'],
+      [:error,       '1;37;41'],
+      [:default, '0;39']
+    ].map(&:freeze).freeze
+
+    ATTRIBUTE_NAMES = ATTRIBUTES.transpose.first
+
+    # Returns true if Howzit::Color supports the +feature+.
+    #
+    # The feature :clear, that is mixing the clear color attribute into String,
+    # is only supported on ruby implementations, that do *not* already
+    # implement the String#clear method. It's better to use the reset color
+    # attribute instead.
+    def support?(feature)
+      case feature
+      when :clear
+        !String.instance_methods(false).map(&:to_sym).include?(:clear)
+      end
+    end
+
+    # Template coloring
+    class ::String
+      ##
+      ## Extract the longest valid %color name from a string.
+      ##
+      ## Allows %colors to bleed into other text and still
+      ## be recognized, e.g. %greensomething still finds
+      ## %green.
+      ##
+      ## @return     [String] a valid color name
+      ##
+      def validate_color
+        valid_color = nil
+        compiled = ''
+        normalize_color.split('').each do |char|
+          compiled += char
+          valid_color = compiled if Color.attributes.include?(compiled.to_sym) || compiled =~ /^([fb]g?)?#([a-f0-9]{6})$/i
+        end
+
+        valid_color
+      end
+
+      ##
+      ## Normalize a color name, removing underscores,
+      ## replacing "bright" with "bold", and converting
+      ## bgbold to boldbg
+      ##
+      ## @return     [String] Normalized color name
+      ##
+      def normalize_color
+        gsub(/_/, '').sub(/bright/i, 'bold').sub(/bgbold/, 'boldbg')
+      end
+
+      # Get the calculated ANSI color at the end of the
+      # string
+      #
+      # @return     ANSI escape sequence to match color
+      #
+      def last_color_code
+        m = scan(ESCAPE_REGEX)
+
+        em = ['0']
+        fg = nil
+        bg = nil
+        rgbf = nil
+        rgbb = nil
+
+        m.each do |c|
+          case c
+          when '0'
+            em = ['0']
+            fg, bg, rgbf, rgbb = nil
+          when /^[34]8/
+            case c
+            when /^3/
+              fg = nil
+              rgbf = c
+            when /^4/
+              bg = nil
+              rgbb = c
+            end
+          else
+            c.split(/;/).each do |i|
+              x = i.to_i
+              if x <= 9
+                em << x
+              elsif x >= 30 && x <= 39
+                rgbf = nil
+                fg = x
+              elsif x >= 40 && x <= 49
+                rgbb = nil
+                bg = x
+              elsif x >= 90 && x <= 97
+                rgbf = nil
+                fg = x
+              elsif x >= 100 && x <= 107
+                rgbb = nil
+                bg = x
+              end
+            end
+          end
+        end
+
+        escape = "\e[#{em.join(';')}m"
+        escape += "\e[#{rgbb}m" if rgbb
+        escape += "\e[#{rgbf}m" if rgbf
+        escape + "\e[#{[fg, bg].delete_if(&:nil?).join(';')}m"
+      end
+    end
+
+    class << self
+      # Returns true if the coloring function of this module
+      # is switched on, false otherwise.
+      def coloring?
+        @coloring
+      end
+
+      attr_writer :coloring
+
+      ##
+      ## Enables colored output
+      ##
+      ## @example Turn color on or off based on TTY
+      ##   Howzit::Color.coloring = STDOUT.isatty
+      def coloring
+        @coloring ||= true
+      end
+
+      ##
+      ## Convert a template string to a colored string.
+      ## Colors are specified with single letters inside
+      ## curly braces. Uppercase changes background color.
+      ##
+      ## w: white, k: black, g: green, l: blue, y: yellow, c: cyan,
+      ## m: magenta, r: red, b: bold, u: underline, i: italic,
+      ## x: reset (remove background, color, emphasis)
+      ##
+      ## @example Convert a templated string
+      ##   Color.template('{Rwb}Warning:{x} {w}you look a little {g}ill{x}')
+      ##
+      ## @param      input  [String, Array] The template
+      ##                    string. If this is an array, the
+      ##                    elements will be joined with a
+      ##                    space.
+      ##
+      ## @return     [String] Colorized string
+      ##
+      def template(input)
+        input = input.join(' ') if input.is_a? Array
+        input.gsub!(/%/, '%%')
+        fmt = input.gsub(/\{(\w+)\}/) do
+          Regexp.last_match(1).split('').map { |c| "%<#{c}>s" }.join('')
+        end
+
+        colors = { w: white, k: black, g: green, l: blue,
+                   y: yellow, c: cyan, m: magenta, r: red,
+                   W: bgwhite, K: bgblack, G: bggreen, L: bgblue,
+                   Y: bgyellow, C: bgcyan, M: bgmagenta, R: bgred,
+                   d: dark, b: bold, u: underline, i: italic, x: reset }
+
+        format(fmt, colors)
+      end
+    end
+
+    ATTRIBUTES.each do |c, v|
+      new_method = <<-EOSCRIPT
+        def #{c}(string = nil)
+          result = ''
+          result << "\e[#{v}m" if Howzit::Color.coloring?
+          if block_given?
+            result << yield
+          elsif string.respond_to?(:to_str)
+            result << string.to_str
+          elsif respond_to?(:to_str)
+            result << to_str
+          else
+            return result #only switch on
+          end
+          result << "\e[0m" if Howzit::Color.coloring?
+          result
+        end
+      EOSCRIPT
+
+      module_eval(new_method)
+
+      next unless c =~ /bold/
+
+      # Accept brightwhite in addition to boldwhite
+      new_method = <<-EOSCRIPT
+        def #{c.to_s.sub(/bold/, 'bright')}(string = nil)
+          result = ''
+          result << "\e[#{v}m" if Howzit::Color.coloring?
+          if block_given?
+            result << yield
+          elsif string.respond_to?(:to_str)
+            result << string.to_str
+          elsif respond_to?(:to_str)
+            result << to_str
+          else
+            return result #only switch on
+          end
+          result << "\e[0m" if Howzit::Color.coloring?
+          result
+        end
+      EOSCRIPT
+
+      module_eval(new_method)
+    end
+
+    def rgb(hex)
+      is_bg = hex.match(/^bg?#/) ? true : false
+      hex_string = hex.sub(/^([fb]g?)?#/, '')
+
+      parts = hex_string.match(/(?<r>..)(?<g>..)(?<b>..)/)
+      t = []
+      %w[r g b].each do |e|
+        t << parts[e].hex
+      end
+      color =
+      "\e[#{is_bg ? '48' : '38'};2;#{t.join(';')}m"
+    end
+
+    # Regular expression that is used to scan for ANSI-sequences while
+    # uncoloring strings.
+    COLORED_REGEXP = /\e\[(?:(?:[349]|10)[0-7]|[0-9])?m/.freeze
+
+    # Returns an uncolored version of the string, that is all
+    # ANSI-sequences are stripped from the string.
+    def uncolor(string = nil) # :yields:
+      if block_given?
+        yield.to_str.gsub(COLORED_REGEXP, '')
+      elsif string.respond_to?(:to_str)
+        string.to_str.gsub(COLORED_REGEXP, '')
+      elsif respond_to?(:to_str)
+        to_str.gsub(COLORED_REGEXP, '')
+      else
+        ''
+      end
+    end
+
+    # Returns an array of all Howzit::Color attributes as symbols.
+    def attributes
+      ATTRIBUTE_NAMES
+    end
+    extend self
+  end
+end

data/lib/howzit/prompt.rb

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
 module Howzit
+  # Command line prompt utils
   module Prompt
   	def yn(prompt, default = true)
+      return default if !$stdout.isatty
+
     	system 'stty cbreak'
     	yn = color_single_options(default ? %w[Y n] : %w[y N])
     	$stdout.syswrite "\e[1;37m#{prompt} #{yn}\e[1;37m? \e[0m"

data/lib/howzit/stringutils.rb

@@ -3,6 +3,31 @@
 module Howzit
   # String Extensions
   module StringUtils
+    # Convert a string to a valid YAML value
+    def to_config_value(orig_value = nil)
+      if orig_value
+        case orig_value.class.to_s
+        when /Integer/
+          to_i
+        when /(True|False)Class/
+          self =~ /^(t(rue)?|y(es)?|1)$/i ? true : false
+        else
+          self
+        end
+      else
+        case self
+        when /^[0-9]+$/
+          to_i
+        when /^(t(rue)?|y(es)?)$/i
+          true
+        when /^(f(alse)?|n(o)?)$/i
+          false
+        else
+          self
+        end
+      end
+    end
+
     # Just strip out color codes when requested
     def uncolor
       gsub(/\e\[[\d;]+m/, '').gsub(/\e\]1337;SetMark/,'')

data/lib/howzit/version.rb

@@ -2,5 +2,5 @@
 # Primary module for this gem.
 module Howzit
   # Current Howzit version.
-  VERSION = '1.2.11'.freeze
+  VERSION = '1.2.14'.freeze
 end

data/lib/howzit.rb

@@ -1,5 +1,6 @@
 require 'howzit/version'
 require 'howzit/prompt'
+require 'howzit/colors'
 require 'howzit/buildnotes'
 require 'howzit/stringutils'
 require 'optparse'
@@ -15,3 +16,4 @@ CONFIG_DIR = '~/.config/howzit'
 CONFIG_FILE = 'howzit.yaml'
 IGNORE_FILE = 'ignore.yaml'
 MATCHING_OPTIONS = %w[partial exact fuzzy beginswith].freeze
+MULTIPLE_OPTIONS = %w[first best all choose].freeze

data/spec/ruby_gem_spec.rb

@@ -9,3 +9,32 @@ describe Howzit::BuildNotes do
     end
   end
 end
+
+describe Howzit::BuildNotes do
+  Dir.chdir('spec')
+  how = Howzit::BuildNotes.new(['--no-upstream', '--default'])
+  how.create_note
+  subject { how }
+
+  describe ".note_file" do
+    it "locates a build note file" do
+      expect(subject.note_file).not_to be_empty
+    end
+  end
+
+  describe ".grep_topics" do
+    it "finds editable" do
+      expect(subject.grep_topics('editable')).to include('File Structure')
+      expect(subject.grep_topics('editable')).not_to include('Build')
+    end
+  end
+
+  describe ".list_topic_titles" do
+    it "finds 4 topics" do
+      expect(subject.topics.keys.count).to eq 4
+    end
+    it "outputs a newline-separated string" do
+      expect(subject.list_topic_titles.scan(/\n/).count).to eq 3
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: howzit
 version: !ruby/object:Gem::Version
-  version: 1.2.11
+  version: 1.2.14
 platform: ruby
 authors:
 - Brett Terpstra
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-08-01 00:00:00.000000000 Z
+date: 2022-08-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -269,6 +269,7 @@ files:
 - lib/.rubocop.yml
 - lib/howzit.rb
 - lib/howzit/buildnotes.rb
+- lib/howzit/colors.rb
 - lib/howzit/prompt.rb
 - lib/howzit/stringutils.rb
 - lib/howzit/version.rb