howzit 1.2.10 → 1.2.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fba37c5c428aeab92ed337697a52323d5b98d5f9398776187e000043e3a5173b
-  data.tar.gz: 6f3a3ebfe50f50476837c2d702cd1c9854d49ff4960c51a06641e79d88abb410
+  metadata.gz: 36a27d1566deff8857d39035c0e40f696a29d78b7ae24274a73ceacc54541321
+  data.tar.gz: 7b13d6644bf397e10f629689b159102a33dd5aa2c3610f368819de3dc8736007
 SHA512:
-  metadata.gz: 015bc504dca39d5b7a32b6d81a4df037abf61467f58b392e88389557f38a2abfb078fd3dc5ced7411b5d1654479d5a79b94da843f8384d4cf77216e9efa1c24c
-  data.tar.gz: c0b2003e8c1b24efa1e193520a66e01813fab6e9d8e21318a7d0c82718540fa8ef1c99b075d40dc07254c678015ca3fe687b64a2be6f8ce541c22e786ac63c9a
+  metadata.gz: 9da1ea212df950e75a34006a44b0ade09c02fd4fe7c02ea0fddfffcf2936e6ca5db0d7f0c9e6cc44aac3d65eb4544aa9d4c03c156487f9311f39f08ee12199d4
+  data.tar.gz: 99f9be58ff9184a2f96e7db6fed83e3fc19f0945e31c9d58daa32db022b175a8c99a329a9c023528af52100f46583ac892091eb04ed5d9e9e791087fe8f8c82d

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,24 @@
+### 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
+
+#### IMPROVED
+
+- Code cleanup and refactoring
+
 ### 1.2.10
 
 2022-08-01 07:45
@@ -6,10 +27,6 @@
 
 - Headline formatting when iTerm markers are inserted
 
-### 1.2.9
-
-2022-08-01 07:09
-
 ### 1.2.8
 
 2022-08-01 07:01

data/Gemfile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in howzit.gemspec.

data/Guardfile

@@ -1,4 +1,6 @@
-scope groups: [:doc, :lint, :unit]
+# frozen_string_literal: true
+
+scope groups: %i[doc lint unit]
 
 group :doc do
   guard :yard do

data/README.md

@@ -1,6 +1,7 @@
 # Howzit
 
 [![Gem](https://img.shields.io/gem/v/howzit.svg)](https://rubygems.org/gems/howzit)
+[![Travis](https://img.shields.io/travis/makenew/ruby-gem.svg)](https://travis-ci.org/makenew/ruby-gem)
 [![GitHub license](https://img.shields.io/github/license/ttscoff/howzit.svg)](./LICENSE.txt)
 
 A command-line reference tool for tracking project build systems

data/Rakefile

@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
 require 'bump/tasks'
 require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 require 'rubocop/rake_task'
 require 'yard'
 
-task default: [:test, :yard]
+task default: %i[test yard]
 
 desc 'Run test suite'
-task test: [:rubocop, :spec]
+task test: %i[rubocop spec]
 
 RSpec::Core::RakeTask.new
 
@@ -16,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,6 +1,8 @@
-#!/usr/bin/env ruby
+#!/usr/bin/env ruby -W1
 # frozen_string_literal: true
+
 $LOAD_PATH.unshift File.join(__dir__, '..', 'lib')
 require 'howzit'
 
-Howzit::BuildNotes.new(ARGV)
+how = Howzit::BuildNotes.new(ARGV)
+how.process

data/howzit.gemspec

@@ -31,7 +31,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rubocop', '~> 0.28'
   spec.add_development_dependency 'rspec', '~> 3.1'
   spec.add_development_dependency 'simplecov', '~> 0.9'
-  spec.add_development_dependency 'codecov', '~> 0.1'
+  # spec.add_development_dependency 'codecov', '~> 0.1'
   spec.add_development_dependency 'fuubar', '~> 2.0'
 
   spec.add_development_dependency 'yard', '~> 0.9.5'

data/lib/howzit/buildnotes.rb

@@ -2,8 +2,9 @@ module Howzit
   # Primary Class for this module
   class BuildNotes
     include Prompt
+    include Color
 
-    attr_accessor :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?
 
@@ -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,7 +352,7 @@ 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
 
@@ -371,12 +382,12 @@ module Howzit
           unless matches.empty?
             if opt[:single]
               title = "From #{matches[0]}:"
-              color = '33;40'
-              rule = '30;40'
+              color = '{yK}'
+              rule = '{kK}'
             else
               title = "Include #{matches[0]}"
-              color = '33;40'
-              rule = '0'
+              color = '{yK}'
+              rule = '{x}'
             end
             output.push(format_header("#{'> ' * @nest_level}#{title}", { color: color, hr: '.', border: rule })) unless @included.include?(matches[0])
 
@@ -405,15 +416,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)
@@ -444,9 +455,9 @@ module Howzit
     # 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 +467,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 +497,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 +518,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 +542,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 +592,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 +617,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)
@@ -673,7 +688,8 @@ module Howzit
       matches
     end
 
-    def initialize(args)
+    def initialize(args = [])
+      Color.coloring = $stdout.isatty
       flags = {
         run: false,
         list_topics: false,
@@ -683,7 +699,8 @@ module Howzit
         title_only: false,
         choose: false,
         quiet: false,
-        verbose: false
+        verbose: false,
+        default: false
       }
 
       defaults = {
@@ -716,7 +733,8 @@ module Howzit
       OptionParser.new do |opts|
         opts.banner = "Usage: #{__FILE__} [OPTIONS] [TOPIC]"
         opts.separator ''
-        opts.separator 'Show build notes for the current project (buildnotes.md). Include a topic name to see just that topic, or no argument to display all.'
+        opts.separator 'Show build notes for the current project (buildnotes.md).
+        Include a topic name to see just that topic, or no argument to display all.'
         opts.separator ''
         opts.separator 'Options:'
 
@@ -725,7 +743,8 @@ module Howzit
           Process.exit 0
         end
 
-        opts.on('-e', '--edit', "Edit buildnotes file in current working directory using #{File.basename(ENV['EDITOR'])}") do
+        opts.on('-e', '--edit', "Edit buildnotes file in current working directory
+                using $EDITOR") do
           edit_note
           Process.exit 0
         end
@@ -743,7 +762,8 @@ module Howzit
           @options[:list_topics] = true
         end
 
-        opts.on('-m', '--matching TYPE', MATCHING_OPTIONS, 'Topics matching type', "(#{MATCHING_OPTIONS.join(', ')})") do |c|
+        opts.on('-m', '--matching TYPE', MATCHING_OPTIONS,
+                'Topics matching type', "(#{MATCHING_OPTIONS.join(', ')})") do |c|
           @options[:matching] = c
         end
 
@@ -776,8 +796,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
@@ -788,7 +808,7 @@ module Howzit
           @options[:wrap] = w.to_i
         end
 
-        opts.on('--edit-config', "Edit configuration file using #{File.basename(ENV['EDITOR'])}") do
+        opts.on('--edit-config', "Edit configuration file using default $EDITOR") do
           edit_config(defaults)
           Process.exit 0
         end
@@ -802,21 +822,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.keys.each do |topic|
-              puts " \e[1;30m│\e[1;37m-\e[0m \e[1;36;40m#{template}:#{topic.sub(/^.*?:/, '')}\e[0m"
+            topics.each_key do |topic|
+              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
@@ -843,9 +863,13 @@ 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)
 
-      process(args)
+      @cli_args = args
     end
 
     def edit_note
@@ -862,7 +886,7 @@ module Howzit
     end
 
     ##
-    ## @brief      Traverse up directory tree looking for build notes
+    ## Traverse up directory tree looking for build notes
     ##
     ## @return     topics dictionary
     ##
@@ -1031,7 +1055,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}"
@@ -1046,7 +1070,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)
@@ -1064,7 +1088,7 @@ module Howzit
       `#{ENV['EDITOR']} "#{config_file}"`
     end
 
-    def process(args)
+    def process
       output = []
 
       unless note_file
@@ -1080,13 +1104,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)
+        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
@@ -1118,14 +1142,14 @@ module Howzit
       elsif @options[:choose]
         topic_match = choose(topics.keys)
       # If there are arguments use those to search for a matching topic
-      elsif !args.empty?
+      elsif !@cli_args.empty?
 
-        search = args.join(' ').strip.downcase
+        search = @cli_args.join(' ').strip.downcase
         matches = match_topic(search)
 
         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]
+          output.push(Color.template(%({bR}ERROR:{xr} No topic match found for {bw}#{search}{x}\n)))
+          unless @options[:show_all_on_error]
             show(output.join("\n"), { color: true, highlight: false, paginate: false, wrap: 0 })
             Process.exit 1
           end

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,
+                   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

@@ -5,7 +5,7 @@ module Howzit
   module StringUtils
     # Just strip out color codes when requested
     def uncolor
-      gsub(/\e\[[\d;]+m/, '').gsub(/\e]1337;SetMark/,'')
+      gsub(/\e\[[\d;]+m/, '').gsub(/\e\]1337;SetMark/,'')
     end
 
     # Adapted from https://github.com/pazdera/word_wrap/,

data/lib/howzit/version.rb

@@ -2,5 +2,5 @@
 # Primary module for this gem.
 module Howzit
   # Current Howzit version.
-  VERSION = '1.2.10'.freeze
+  VERSION = '1.2.13'.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'

data/spec/ruby_gem_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Howzit::BuildNotes do
-  subject(:ruby_gem) { Howzit::BuildNotes.new }
+  subject(:ruby_gem) { Howzit::BuildNotes.new([]) }
 
   describe ".new" do
     it "makes a new instance" do
@@ -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 "found 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 "found 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

data/spec/spec_helper.rb

@@ -1,13 +1,13 @@
-require 'simplecov'
+# require 'simplecov'
 
-SimpleCov.start
+# SimpleCov.start
 
-if ENV['CI'] == 'true'
-  require 'codecov'
-  SimpleCov.formatter = SimpleCov::Formatter::Codecov
-else
-  SimpleCov.formatter = SimpleCov::Formatter::HTMLFormatter
-end
+# if ENV['CI'] == 'true'
+#   require 'codecov'
+#   SimpleCov.formatter = SimpleCov::Formatter::Codecov
+# else
+#   SimpleCov.formatter = SimpleCov::Formatter::HTMLFormatter
+# end
 
 require 'howzit'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: howzit
 version: !ruby/object:Gem::Version
-  version: 1.2.10
+  version: 1.2.13
 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
@@ -150,20 +150,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.9'
-- !ruby/object:Gem::Dependency
-  name: codecov
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.1'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.1'
 - !ruby/object:Gem::Dependency
   name: fuubar
   requirement: !ruby/object:Gem::Requirement
@@ -283,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