howzit 1.2.11 → 1.2.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 24b630c81dbd81b43b8572bbc91baabe96063a17c3cb6295a8026e6a3176dd39
-  data.tar.gz: 04c98ab9c7a9c57e8c7536e7709b57d51b965a76cc315c846c46dca3a0a2105e
+  metadata.gz: 875d039552876588bf298e4297ffec3955a6a73da6c2f89f608f7d11ed9d4e93
+  data.tar.gz: ecd7f0dd8f67999de4e223745f79096cc06ebd84e867400bc729f2323e8f8360
 SHA512:
-  metadata.gz: 3ce4d9a3cd8cd8970cd37e5b90c7154c0b66de06827780c4e38bb4f358d517b8c81d720383cbaa8fa84ff74f56a9f1f60e554f92614cf12e4f1f563092d9d651
-  data.tar.gz: 5187fbd097d9171ddd3756f9df92e62b0df5309d7e1d2e0aef26551f6641340d65ade5f49f1c9b0a47852e6913c64d5914d334732e15a1ac71f2277edde38fe7
+  metadata.gz: bfcad0fc1a4fbf0140dc91ae5cf03e52c3d42aed4a404c91fab642db05d9849b92c0c73d4f87d79ca0b58d1583a6a0ab5ef0ef9936812913567aeb3f24508a93
+  data.tar.gz: db44b03b2f2c25c84187692a9d46a328a22d4a7dce0adc20304ab31fe58e91b6ca4bef6848ab69efcce5e0c60e9c8955501f4232d5643f664d35cb81da9bcbdf

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,12 @@
+### 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/Rakefile

@@ -18,3 +18,14 @@ 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

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?
 
@@ -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
@@ -161,7 +162,7 @@ module Howzit
       end
       # First make sure there isn't already a buildnotes file
       if note_file
-        fname = "\e[1;33m#{note_file}\e[1;37m"
+        fname = Color.template("{by}#{note_file}{bw}")
         res = yn("#{fname} exists and appears to be a build note, continue anyway?", false)
         unless res
           puts 'Canceled'
@@ -170,19 +171,19 @@ module Howzit
       end
 
       title = File.basename(Dir.pwd)
-      printf "\e[1;37mProject name \e[0;32m[#{title}]\e[1;37m: \e[0m"
-      input = STDIN.gets.chomp
+      printf Color.template("{bw}Project name {xg}[#{title}]{bw}: {x}")
+      input = $stdin.gets.chomp
       title = input unless input.empty?
 
       summary = ''
-      printf "\e[1;37mProject summary: \e[0m"
-      input = STDIN.gets.chomp
+      printf Color.template('{bw}Project summary: {x}')
+      input = $stdin.gets.chomp
       summary = input unless input.empty?
 
-      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'
+      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?
 
       note = <<~EOBUILDNOTES
         # #{title}
@@ -209,8 +210,8 @@ module Howzit
 
       EOBUILDNOTES
 
-      if File.exist?(filename)
-        file = "\e[1;33m#{filename}"
+      if File.exist?(fname)
+        file = Color.template("{by}#{fname}")
         res = yn("Are you absolutely sure you want to overwrite #{file}", false)
 
         unless res
@@ -219,9 +220,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 +230,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 +240,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 +301,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 +323,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 +342,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 +372,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 +406,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 +445,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 +457,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 +487,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 +508,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 +532,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 +582,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 +607,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 +679,7 @@ module Howzit
     end
 
     def initialize(args = [])
+      Color.coloring = $stdout.isatty
       flags = {
         run: false,
         list_topics: false,
@@ -779,8 +785,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
@@ -805,21 +811,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
@@ -1083,13 +1089,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
@@ -1127,8 +1133,8 @@ module Howzit
         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/version.rb

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

@@ -9,3 +9,36 @@ describe Howzit::BuildNotes do
     end
   end
 end
+
+describe Howzit::BuildNotes do
+  Dir.chdir('spec')
+  subject { Howzit::BuildNotes.new(['--no-upstream']) }
+
+  describe ".note_file" do
+    it "locates a build note file" do
+      expect(subject.note_file).not_to be_empty
+    end
+  end
+
+  describe ".get_note_title" do
+    it "is named howzit test" do
+      expect(subject.get_note_title).to match(/howzit test/)
+    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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: howzit
 version: !ruby/object:Gem::Version
-  version: 1.2.11
+  version: 1.2.12
 platform: ruby
 authors:
 - Brett Terpstra
@@ -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