howzit 2.0.2 → 2.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5758dea871a182fc419de237ba35828396000307710b1680841bb774ea6994a2
-  data.tar.gz: bdf200a5a60c0acd268e37adcfae6b187807a14766e8199970fbd1d3ac1e4e3d
+  metadata.gz: 95a5f6c56ebff1fb944ca8ea23cba45ca5b71647654a315fd2cf7e486d522309
+  data.tar.gz: f9ac61f6fad2aff412d4302d0c586e9b287f284659255215a9565c8632bdfc8c
 SHA512:
-  metadata.gz: c6ec5058df211c32bdf02a33f99626822221317ee95eb16161d17e4ede96ae31b744a16aee328cead7c4e3bab5ca393f0911227234709622fea27f4026a6504f
-  data.tar.gz: 7ce5c34e121fa6a3fa6fea662d21b3ccc60beba0e0fee8f0b87b0f8653e3d0e64c66f61cfdc978e0a4b1d425cb757fcf191ba4026262c1ce26225dad8b87897d
+  metadata.gz: be7ac525fc55a0e199b5762830bd0c6ef41b0b099627a45f1ca2aacd4508df3574f06e803513a22d870985631520c58b7f75c9e8519b5b02cf274eaeec577d56
+  data.tar.gz: e60252f5081ae563fc7eb8c207bb6ba0674b316455247cbc886e1b386dd33ecef234cfa493c6453bc02403daa11f79afb5f514c95a2f4e080302010466a7d4a6

data/CHANGELOG.md

@@ -1,3 +1,41 @@
+### 2.0.5
+
+2022-08-04 10:50
+
+#### NEW
+
+- Make any task optional when running by adding a ? (@open?(...))
+- Optional tasks default to yes when you hit enter, invert by using a ! (@open?!(...)) to make default "no"
+
+#### FIXED
+
+- Replace escaped newlines in task list output so that they don't trigger a newline in the shell
+
+### 2.0.4
+
+2022-08-04 06:25
+
+#### IMPROVED
+
+- Ask to open new buildnote for editing after creation
+
+#### FIXED
+
+- Loop when creating new buildnote
+
+### 2.0.3
+
+2022-08-04 05:31
+
+#### IMPROVED
+
+- General code cleanup
+- Attempt at os agnostic @copy command, hopefully works on Windows and Linux systems
+
+#### FIXED
+
+- Not displaying action if title is missing
+
 ### 2.0.2
 
 2022-08-03 18:26

data/README.md

@@ -94,6 +94,18 @@ You can include commands that can be executed by howzit. Commands start at the b
 
     A block defined between @after and @end markers will be displayed after a topic is run. Use it to remind yourself of additional tasks after automated ones have been executed. The content between these markers is still included when viewing the topic, but the tags themselves do not show up in output.
 
+### Adding Titles
+
+When displaying a topic, howzit can display a title instead of the contents of a directive. Any text after the closing parenthesis will be considered the task title.
+
+```
+@run(~/scripts/deploy.sh) Deploy script
+```
+
+When the topic is displayed, it will now show "Run Deploy script" instead of the path to the script. This can be overridden with the `--show-code` flag, which will instead show the contents of the directive.
+
+For adding titles to run blocks (fenced code), see below.
+
 ### Run blocks (embedded scripts)
 
 For longer scripts you can write shell scripts and then call them with `@run(myscript.sh)`. For those in-between cases where you need a few commands but aren't motivated to create a separate file, you can use fenced code blocks with `run` as the language.
@@ -117,6 +129,12 @@ Example:
 
 Multiple blocks can be included in a topic. @commands take priority over code blocks and will be run first if they exist in the same topic.
 
+### Requiring Confirmation
+
+You can have howzit confirm whether to execute an @command at runtime by including a question mark to the directive, e.g. `@run?(...)`. This will present a yes/no dialog before running the directive, with a default response of "yes" if you just hit return. To make the default response "no," add an exclamation point, e.g. `@run?!(...)`. 
+
+This works for any directive, including `@include`, and run blocks, which can use `run?` as the language specifier.
+
 ### Variables
 
 When running commands in a topic, you can use a double dash (`--`) in the command line (surrounded by spaces) and anything after it will be interpreted as shell arguments. These can be used in commands with `$` placeholders. `$1` represents the first argument, counting up from there. Use `$@` to pass all arguments as a shell-escaped string.

data/bin/howzit

@@ -115,7 +115,7 @@ OptionParser.new do |opts|
 
     parts = key.split(/=/)
     k = parts[0].sub(/^:/, '')
-    v = parts[1..-1].join(' ')
+    v = parts[1..].join(' ')
 
     if Howzit.options.key?(k.to_sym)
       Howzit.options[k.to_sym] = v.to_config_value(Howzit.options[k.to_sym])

data/howzit.gemspec

@@ -40,4 +40,5 @@ Gem::Specification.new do |spec|
 
   spec.add_runtime_dependency 'mdless', '~> 1.0', '>= 1.0.28'
   spec.add_runtime_dependency 'tty-screen', '~> 0.8'
+  # spec.add_runtime_dependency 'tty-prompt', '~> 0.23'
 end

data/lib/howzit/buildnote.rb

@@ -41,9 +41,9 @@ module Howzit
     # Output a list of topic titles
     def list
       output = []
-      output.push(Color.template("{bg}Topics:{x}\n"))
+      output.push("{bg}Topics:{x}\n".c)
       @topics.each do |topic|
-        output.push(Color.template("- {bw}#{topic.title}{x}"))
+        output.push("- {bw}#{topic.title}{x}".c)
       end
       output.join("\n")
     end
@@ -66,7 +66,7 @@ module Howzit
 
     def list_runnable
       output = []
-      output.push(Color.template(%({bg}"Runnable" Topics:{x}\n)))
+      output.push(%({bg}"Runnable" Topics:{x}\n).c)
       @topics.each do |topic|
         s_out = []
 
@@ -75,7 +75,7 @@ module Howzit
         end
 
         unless s_out.empty?
-          output.push(Color.template("- {bw}#{topic.title}{x}"))
+          output.push("- {bw}#{topic.title}{x}".c)
           output.push(s_out.join("\n"))
         end
       end
@@ -95,9 +95,9 @@ module Howzit
       default = !$stdout.isatty || Howzit.options[:default]
       # First make sure there isn't already a buildnotes file
       if note_file
-        fname = Color.template("{by}#{note_file}{bw}")
+        fname = "{by}#{note_file}{bw}".c
         unless default
-          res = Prompt.yn("#{fname} exists and appears to be a build note, continue anyway?", false)
+          res = Prompt.yn("#{fname} exists and appears to be a build note, continue anyway?", default: false)
           unless res
             puts 'Canceled'
             Process.exit 0
@@ -106,23 +106,25 @@ module Howzit
       end
 
       title = File.basename(Dir.pwd)
+      # prompt = TTY::Prompt.new
       if default
         input = title
       else
-        printf Color.template("{bw}Project name {xg}[#{title}]{bw}: {x}")
+        # title = prompt.ask("{bw}Project name:{x}".c, default: title)
+        printf "{bw}Project name {xg}[#{title}]{bw}: {x}".c
         input = $stdin.gets.chomp
         title = input unless input.empty?
       end
       summary = ''
       unless default
-        printf Color.template('{bw}Project summary: {x}')
+        printf '{bw}Project summary: {x}'.c
         input = $stdin.gets.chomp
         summary = input unless input.empty?
       end
 
       fname = 'buildnotes.md'
       unless default
-        printf Color.template("{bw}Build notes filename (must begin with 'howzit' or 'build')\n{xg}[#{fname}]{bw}: {x}")
+        printf "{bw}Build notes filename (must begin with 'howzit' or 'build')\n{xg}[#{fname}]{bw}: {x}".c
         input = $stdin.gets.chomp
         fname = input unless input.empty?
       end
@@ -153,8 +155,8 @@ module Howzit
       EOBUILDNOTES
 
       if File.exist?(fname) && !default
-        file = Color.template("{by}#{fname}")
-        res = Prompt.yn("Are you absolutely sure you want to overwrite #{file}", false)
+        file = "{by}#{fname}".c
+        res = Prompt.yn("Are you absolutely sure you want to overwrite #{file}", default: false)
 
         unless res
           puts 'Canceled'
@@ -164,8 +166,16 @@ module Howzit
 
       File.open(fname, 'w') do |f|
         f.puts note
-        puts Color.template("{by}Build notes for #{title} written to #{fname}")
+        puts "{by}Build notes for #{title} written to #{fname}".c
       end
+
+      if File.exist?(fname) && !default
+        res = Prompt.yn("{bg}Do you want to open {bw}#{file} {bg}for editing?{x}".c, default: false)
+
+        edit_note if res
+      end
+
+      Process.exit 0
     end
 
     def note_file
@@ -259,8 +269,8 @@ module Howzit
           required = t_meta['required'].strip.split(/\s*,\s*/)
           required.each do |req|
             unless @metadata.keys.include?(req.downcase)
-              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}))
+              warn %({xr}ERROR: Missing required metadata key from template '{bw}#{File.basename(template, '.md')}{xr}'{x}).c
+              warn %({xr}Please define {by}#{req.downcase}{xr} in build notes{x}).c
               Process.exit 1
             end
           end
@@ -410,7 +420,7 @@ module Howzit
       raise "Invalid editor (#{editor})" unless Util.valid_command?(editor)
 
       if note_file.nil?
-        res = Prompt.yn('No build notes file found, create one?', true)
+        res = Prompt.yn('No build notes file found, create one?', default: true)
 
         create_note if res
         edit_note
@@ -500,7 +510,7 @@ module Howzit
           matches = find_topic(s)
 
           if matches.empty?
-            output.push(Color.template(%({bR}ERROR:{xr} No topic match found for {bw}#{s}{x}\n)))
+            output.push(%({bR}ERROR:{xr} No topic match found for {bw}#{s}{x}\n).c)
           else
             case Howzit.options[:multiple_matches]
             when :first

data/lib/howzit/hash.rb

@@ -32,4 +32,24 @@ class ::Hash
   def deep_thaw!
     replace deep_thaw
   end
+
+  # Turn all keys into string
+  #
+  # Return a copy of the hash where all its keys are strings
+  def stringify_keys
+    each_with_object({}) { |(k, v), hsh| hsh[k.to_s] = v.is_a?(Hash) ? v.stringify_keys : v }
+  end
+
+  def stringify_keys!
+  	replace stringify_keys
+  end
+
+  # Turn all keys into symbols
+  def symbolize_keys
+    each_with_object({}) { |(k, v), hsh| hsh[k.to_sym] = v.is_a?(Hash) ? v.symbolize_keys : v }
+  end
+
+  def symbolize_keys!
+  	replace symbolize_keys
+  end
 end

data/lib/howzit/prompt.rb

@@ -4,16 +4,18 @@ module Howzit
   # Command line prompt utils
   module Prompt
     class << self
-    	def yn(prompt, default = true)
-        return default if !$stdout.isatty
+    	def yn(prompt, default: true)
+        return default unless $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"
-      	res = $stdin.sysread 1
-      	res.chomp!
-      	puts
-      	system 'stty cooked'
+        return default if Howzit.options[:default]
+
+        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"
+        res = $stdin.sysread 1
+        res.chomp!
+        puts
+        system 'stty cooked'
         res.empty? ? default : res =~ /y/i
       end
 

data/lib/howzit/stringutils.rb

@@ -28,6 +28,10 @@ module Howzit
       end
     end
 
+    def c
+      Color.template(self)
+    end
+
     def to_rx
       case Howzit.options[:matching]
       when 'exact'

data/lib/howzit/task.rb

@@ -2,13 +2,15 @@
 
 module Howzit
   class Task
-    attr_reader :type, :title, :action, :parent
+    attr_reader :type, :title, :action, :parent, :optional, :default
 
-    def initialize(type, title, action, parent = nil)
+    def initialize(type, title, action, parent = nil, optional: false, default: true)
       @type = type
       @title = title
       @action = action.render_arguments
       @parent = parent
+      @optional = optional
+      @default = default
     end
 
     def to_s
@@ -16,7 +18,7 @@ module Howzit
     end
 
     def to_list
-      "    * #{@type}: #{@title}"
+      "    * #{@type}: #{@title.gsub(/\\n/, '\​n')}"
     end
   end
 end

data/lib/howzit/topic.rb

@@ -28,14 +28,21 @@ module Howzit
       if @tasks.count.positive?
         unless @prereqs.empty?
           puts @prereqs.join("\n\n")
-          res = Prompt.yn('This task has prerequisites, have they been met?', true)
+          res = Prompt.yn('This topic has prerequisites, have they been met?', default: true)
           Process.exit 1 unless res
 
         end
 
         @tasks.each do |task|
+          if task.optional
+            q = %({bg}#{task.type.to_s.capitalize} {xw}"{bw}#{task.title}{xw}"{x}).c
+            res = Prompt.yn(q, default: task.default)
+            next unless res
+
+          end
+
           if task.type == :block
-            warn Color.template("{bg}Running block {bw}#{title}{x}") if Howzit.options[:log_level] < 2
+            warn "{bg}Running block {bw}#{title}{x}".c if Howzit.options[:log_level] < 2
             block = task.action
             script = Tempfile.new('howzit_script')
             begin
@@ -49,22 +56,23 @@ module Howzit
               script.unlink
             end
           else
+            title = Howzit.options[:show_all_code] ? task.action : task.title
             case task.type
             when :include
               matches = Howzit.buildnote.find_topic(task.action)
               raise "Topic not found: #{task.action}" if matches.empty?
 
-              warn Color.template("{by}Running tasks from {bw}#{matches[0].title}{x}") if Howzit.options[:log_level] < 2
+              $stderr.puts "{by}Running tasks from {bw}#{matches[0].title}{x}".c if Howzit.options[:log_level] < 2
               output.push(matches[0].run(nested: true))
-              warn Color.template("{by}End include: #{matches[0].tasks.count} tasks") if Howzit.options[:log_level] < 2
+              $stderr.puts "{by}End include: #{matches[0].tasks.count} tasks".c if Howzit.options[:log_level] < 2
               tasks += matches[0].tasks.count
             when :run
-              warn Color.template("{bg}Running {bw}#{task.title}{x}") if Howzit.options[:log_level] < 2
+              $stderr.puts "{bg}Running {bw}#{title}{x}".c if Howzit.options[:log_level] < 2
               system(task.action)
               tasks += 1
             when :copy
-              warn Color.template("{bg}Copied {bw}#{task.title}{bg} to clipboard{x}") if Howzit.options[:log_level] < 2
-              `echo #{Shellwords.escape(task.action)}'\\c'|pbcopy`
+              $stderr.puts "{bg}Copied {bw}#{title}{bg} to clipboard{x}".c if Howzit.options[:log_level] < 2
+              os_copy(task.action)
               tasks += 1
             when :open
               os_open(task.action)
@@ -73,28 +81,52 @@ module Howzit
           end
         end
       else
-        warn Color.template("{r}--run: No {br}@directive{xr} found in {bw}#{key}{x}")
+        warn "{r}--run: No {br}@directive{xr} found in {bw}#{@title}{x}".c
       end
-      output.push(Color.template("{bm}Ran #{tasks} #{tasks == 1 ? 'task' : 'tasks'}{x}")) if Howzit.options[:log_level] < 2 && !nested
+      output.push("{bm}Ran #{tasks} #{tasks == 1 ? 'task' : 'tasks'}{x}".c) if Howzit.options[:log_level] < 2 && !nested
 
       puts postreqs.join("\n\n") unless postreqs.empty?
 
       output
     end
 
+    def os_copy(string)
+      os = RbConfig::CONFIG['target_os']
+      out = "{bg}Copying {bw}#{string}".c
+      case os
+      when /darwin.*/i
+        warn "#{out} (macOS){x}".c if Howzit.options[:log_level] < 2
+        `echo #{Shellwords.escape(string)}'\\c'|pbcopy`
+      when /mingw|mswin/i
+        warn "#{out} (Windows){x}".c if Howzit.options[:log_level] < 2
+        `echo #{Shellwords.escape(string)} | clip`
+      else
+        if 'xsel'.available?
+          warn "#{out} (Linux, xsel){x}".c if Howzit.options[:log_level] < 2
+          `echo #{Shellwords.escape(string)}'\\c'|xsel -i`
+        elsif 'xclip'.available?
+          warn "#{out} (Linux, xclip){x}".c if Howzit.options[:log_level] < 2
+          `echo #{Shellwords.escape(string)}'\\c'|xclip -i`
+        else
+          warn out if Howzit.options[:log_level] < 2
+          warn 'Unable to determine executable for clipboard.'
+        end
+      end
+    end
+
     def os_open(command)
       os = RbConfig::CONFIG['target_os']
-      out = Color.template("{bg}Opening {bw}#{command}")
+      out = "{bg}Opening {bw}#{command}".c
       case os
       when /darwin.*/i
-        warn Color.template("#{out} (macOS){x}") if Howzit.options[:log_level] < 2
+        warn "#{out} (macOS){x}".c if Howzit.options[:log_level] < 2
         `open #{Shellwords.escape(command)}`
       when /mingw|mswin/i
-        warn Color.template("#{out} (Windows){x}") if Howzit.options[:log_level] < 2
+        warn "#{out} (Windows){x}".c if Howzit.options[:log_level] < 2
         `start #{Shellwords.escape(command)}`
       else
         if 'xdg-open'.available?
-          warn Color.template("#{out} (Linux){x}") if Howzit.options[:log_level] < 2
+          warn "#{out} (Linux){x}".c if Howzit.options[:log_level] < 2
           `xdg-open #{Shellwords.escape(command)}`
         else
           warn out if Howzit.options[:log_level] < 2
@@ -114,50 +146,57 @@ module Howzit
         output.push('')
       end
       topic = @content.dup
-      topic.gsub!(/(?mi)^(`{3,})run *([^\n]*)[\s\S]*?\n\1\s*$/, '@@@run \2') unless Howzit.options[:show_all_code]
+      topic.gsub!(/(?mi)^(`{3,})run([?!]*) *([^\n]*)[\s\S]*?\n\1\s*$/, '@@@run\2 \3') unless Howzit.options[:show_all_code]
       topic.split(/\n/).each do |l|
         case l
         when /@(before|after|prereq|end)/
           next
-        when /@include\((.*?)\)/
-
-          m = Regexp.last_match
-          matches = Howzit.buildnote.find_topic(m[1])
+        when /@include(?<optional>[!?]{1,2})?\((?<action>.*?)\)/
+          m = Regexp.last_match.named_captures.symbolize_keys
+          matches = Howzit.buildnote.find_topic(m[:action])
           unless matches.empty?
-            if opt[:single]
-              title = "From #{matches[0].title}:"
-              color = '{Kyd}'
-              rule = '{kKd}'
-            else
-              title = "Include #{matches[0].title}"
-              color = '{Kyd}'
-              rule = '{kKd}'
-            end
-            unless Howzit.inclusions.include?(matches[0])
-              output.push("#{'> ' * @nest_level}#{title}".format_header({ color: color, hr: '.', border: rule }))
+            i_topic = matches[0]
+            rule = '{kKd}'
+            color = '{Kyd}'
+            option = if i_topic.tasks.empty?
+                       ''
+                     else
+                       optional = m[:optional] =~ /[?!]+/ ? true : false
+                       default = m[:optional] =~ /!/ ? false : true
+                       if optional
+                         default ? " {xKk}[{gbK}Y{xKk}/{dbwK}n{xKk}]{x}#{color}".c : " {xKk}[{dbwK}y{xKk}/{bgK}N{xKk}]{x}#{color}".c
+                       else
+                         ''
+                       end
+                     end
+            title = "#{opt[:single] ? 'From' : 'Include'} #{i_topic.title}#{option}:"
+            options = { color: color, hr: '.', border: rule }
+            unless Howzit.inclusions.include?(i_topic)
+              output.push("#{'> ' * @nest_level}#{title}".format_header(options))
             end
 
-            if opt[:single]
-              if Howzit.inclusions.include?(matches[0])
-                output.push("#{'> ' * @nest_level}#{title} included above".format_header({
-                  color: color, hr: '.', border: rule }))
-              else
-                @nest_level += 1
-                output.concat(matches[0].print_out({ single: true, header: false }))
-                @nest_level -= 1
-              end
-              unless Howzit.inclusions.include?(matches[0])
-                output.push("#{'> ' * @nest_level}...".format_header({ color: color, hr: '.', border: rule }))
-              end
+            if opt[:single] && Howzit.inclusions.include?(i_topic)
+              output.push("#{'> ' * @nest_level}#{title} included above".format_header(options))
+            elsif opt[:single]
+              @nest_level += 1
+              output.concat(i_topic.print_out({ single: true, header: false }))
+              output.push("#{'> ' * @nest_level}...".format_header(options))
+              @nest_level -= 1
             end
-            Howzit.inclusions.push(matches[0])
+            Howzit.inclusions.push(i_topic)
           end
-
-        when /@(run|copy|open|url|include)\((.*?)\)(.*?)$/
-          m = Regexp.last_match
-          cmd = m[1]
-          obj = m[2]
-          title = m[3].nil? ? obj : m[3]
+        when /@(?<cmd>run|copy|open|url|include)(?<optional>[?!]{1,2})?\((?<action>.*?)\) *(?<title>.*?)$/
+          m = Regexp.last_match.named_captures.symbolize_keys
+          cmd = m[:cmd]
+          obj = m[:action]
+          title = m[:title].empty? ? obj : m[:title].strip
+          optional = m[:optional] =~ /[?!]+/ ? true : false
+          default = m[:optional] =~ /!/ ? false : true
+          option = if optional
+                     default ? ' {xk}[{g}Y{xk}/{dbw}n{xk}]{x}'.c : ' {xk}[{dbw}y{xk}/{g}N{xk}]{x}'.c
+                   else
+                     ''
+                   end
           icon = case cmd
                  when 'run'
                    "\u{25B6}"
@@ -167,21 +206,35 @@ module Howzit
                    "\u{279A}"
                  end
 
-          output.push(Color.template("{bmK}#{icon} {bwK}#{title.gsub(/\\n/, '\​n')}{x}"))
-        when /(`{3,})run *(.*?)$/i
-          m = Regexp.last_match
-          desc = m[2].length.positive? ? "Block: #{m[2]}" : 'Code Block'
-          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(Color.template("{bmK}\u{25B6} {bwK}#{desc}{x}"))
+          output.push("{bmK}#{icon} {bwK}#{title.gsub(/\\n/, '\​n')}{x}#{option}".c)
+        when /(?<fence>`{3,})run(?<optional>[!?]{1,2})? *(?<title>.*?)$/i
+          m = Regexp.last_match.named_captures.symbolize_keys
+          optional = m[:optional] =~ /[?!]+/ ? true : false
+          default = m[:optional] =~ /!/ ? false : true
+          option = if optional
+                     default ? ' {xk}[{g}Y{xk}/{dbw}n{xk}]{x}'.c : ' {xk}[{dbw}y{xk}/{g}N{xk}]{x}'.c
+                   else
+                     ''
+                   end
+          desc = m[:title].length.positive? ? "Block: #{m[:title]}#{option}" : "Code Block#{option}"
+          output.push("{bmK}\u{25B6} {bwK}#{desc}{x}\n```".c)
+        when /@@@run(?<optional>[!?]{1,2})? *(?<title>.*?)$/i
+          m = Regexp.last_match.named_captures.symbolize_keys
+          optional = m[:optional] =~ /[?!]+/ ? true : false
+          default = m[:optional] =~ /!/ ? false : true
+          option = if optional
+                     default ? ' {xk}[{g}Y{xk}/{dbw}n{xk}]{x}'.c : ' {xk}[{dbw}y{xk}/{g}N{xk}]{x}'.c
+                   else
+                     ''
+                   end
+          desc = m[:title].length.positive? ? "Block: #{m[:title]}#{option}" : "Code Block#{option}"
+          output.push("{bmK}\u{25B6} {bwK}#{desc}{x}".c)
         else
-          l.wrap!(Howzit.options[:wrap]) if (Howzit.options[:wrap]).positive?
+          l.wrap!(Howzit.options[:wrap]) if Howzit.options[:wrap].positive?
           output.push(l)
         end
       end
-      output.push('') # FIXME: Is this where the extra line is coming from?
+      output.push('')
     end
 
     private
@@ -191,18 +244,27 @@ module Howzit
       @prereqs = @content.scan(/(?<=@before\n).*?(?=\n@end)/im).map(&:strip)
       @postreqs = @content.scan(/(?<=@after\n).*?(?=\n@end)/im).map(&:strip)
 
-      rx = /(?:@(include|run|copy|open|url)\((.*?)\) *(.*?)(?=$)|(`{3,})run(?: +([^\n]+))?(.*?)\4)/mi
-      directives = @content.scan(rx)
+      rx = /(?mix)(?:
+            @(?<cmd>include|run|copy|open|url)(?<optional>[!?]{1,2})?\((?<action>[^)]*?)\)(?<title>[^\n]+)?
+            |(?<fence>`{3,})run(?<optional2>[!?]{1,2})?(?<title2>[^\n]+)?(?<block>.*?)\k<fence>
+            )/
+      matches = []
+      @content.scan(rx) { matches << Regexp.last_match }
+      matches.each do |m|
+        c = m.named_captures.symbolize_keys
 
-      directives.each do |c|
-        if c[0].nil?
-          title = c[4] ? c[4].strip : ''
-          block = c[5].strip
-          runnable << Howzit::Task.new(:block, title, block)
+        if c[:cmd].nil?
+          optional = c[:optional2] =~ /[?!]{1,2}/ ? true : false
+          default = c[:optional2] =~ /!/ ? false : true
+          title = c[:title2].nil? ? '' : c[:title2].strip
+          block = c[:block]&.strip
+          runnable << Howzit::Task.new(:block, title, block, optional: optional, default: default)
         else
-          cmd = c[0]
-          obj = c[1]
-          title = c[3] || obj
+          cmd = c[:cmd]
+          optional = c[:optional] =~ /[?!]{1,2}/ ? true : false
+          default = c[:optional] =~ /!/ ? false : true
+          obj = c[:action]
+          title = c[:title].nil? ? obj : c[:title].strip
 
           case cmd
           when /include/i
@@ -215,17 +277,15 @@ module Howzit
             #   end
             #   runnable.concat(tasks)
             # end
-            title = c[3] || obj
-            runnable << Howzit::Task.new(:include, title, obj)
+            runnable << Howzit::Task.new(:include, title, obj, optional: optional, default: default)
           when /run/i
-            title = c[3] || obj
-            # warn Color.template("{bg}Running {bw}#{obj}{x}") if Howzit.options[:log_level] < 2
-            runnable << Howzit::Task.new(:run, title, obj)
+            # warn "{bg}Running {bw}#{obj}{x}".c if Howzit.options[:log_level] < 2
+            runnable << Howzit::Task.new(:run, title, obj, optional: optional, default: default)
           when /copy/i
-            # warn Color.template("{bg}Copied {bw}#{obj}{bg} to clipboard{x}") if Howzit.options[:log_level] < 2
-            runnable << Howzit::Task.new(:copy, title, Shellwords.escape(obj))
+            # warn "{bg}Copied {bw}#{obj}{bg} to clipboard{x}".c if Howzit.options[:log_level] < 2
+            runnable << Howzit::Task.new(:copy, title, Shellwords.escape(obj), optional: optional, default: default)
           when /open|url/i
-            runnable << Howzit::Task.new(:open, title, obj)
+            runnable << Howzit::Task.new(:open, title, obj, optional: optional, default: default)
           end
         end
       end

data/lib/howzit/version.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
+
 # Primary module for this gem.
 module Howzit
   # Current Howzit version.
-  VERSION = '2.0.2'.freeze
+  VERSION = '2.0.5'
 end

data/lib/howzit.rb

@@ -20,6 +20,7 @@ require 'tempfile'
 require 'yaml'
 
 require 'tty/screen'
+# require 'tty/prompt'
 
 CONFIG_DIR = '~/.config/howzit'
 CONFIG_FILE = 'howzit.yaml'

data/spec/buildnote_spec.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Howzit::BuildNote do
+  subject(:how) { @hz }
+
+  describe ".note_file" do
+    it "locates a build note file" do
+      expect(how.note_file).not_to be_empty
+      expect(how.note_file).to match /builda.md$/
+    end
+  end
+
+  describe ".grep" do
+    it "finds topic containing 'bermuda'" do
+      expect(how.grep('bermuda').map { |topic| topic.title }).to include('Topic Tropic')
+    end
+    it "does not return non-matching topic" do
+      expect(how.grep('bermuda').map { |topic| topic.title }).not_to include('Topic Balogna')
+    end
+  end
+
+  describe ".find_topic" do
+    it "finds the Topic Tropic topic" do
+      matches = how.find_topic('tropic')
+      expect(matches.count).to eq 1
+      expect(matches[0].title).to eq 'Topic Tropic'
+    end
+    it "fuzzy matches" do
+      Howzit.options[:matching] = 'fuzzy'
+      matches = how.find_topic('trpc')
+      expect(matches.count).to eq 1
+      expect(matches[0].title).to eq 'Topic Tropic'
+    end
+    it "succeeds with partial match" do
+      Howzit.options[:matching] = 'partial'
+      matches = how.find_topic('trop')
+      expect(matches.count).to eq 1
+      expect(matches[0].title).to eq 'Topic Tropic'
+    end
+    it "succeeds with beginswith match" do
+      Howzit.options[:matching] = 'beginswith'
+      matches = how.find_topic('topic')
+      expect(matches.count).to eq 3
+      expect(matches[0].title).to eq 'Topic Balogna'
+    end
+    it "succeeds with exact match" do
+      Howzit.options[:matching] = 'exact'
+      matches = how.find_topic('topic tropic')
+      expect(matches.count).to eq 1
+      expect(matches[0].title).to eq 'Topic Tropic'
+    end
+    it "fails with incomplete exact match" do
+      Howzit.options[:matching] = 'exact'
+      matches = how.find_topic('topic trop')
+      expect(matches.count).to eq 0
+    end
+  end
+
+  describe ".topics" do
+    it "contains 4 topics" do
+      expect(how.list_topics.count).to eq 3
+    end
+    it "outputs a newline-separated string for completion" do
+      expect(how.list_completions.scan(/\n/).count).to eq 2
+    end
+  end
+end

data/spec/buildnotes.md.bak

@@ -0,0 +1,22 @@
+# spec
+
+
+
+## File Structure
+
+Where are the main editable files? Is there a dist/build folder that should be ignored?
+
+## Build
+
+What build system/parameters does this use?
+
+@run(./build command)
+
+## Deploy
+
+What are the procedures/commands to deploy this project?
+
+## Other
+
+Version control notes, additional gulp/rake/make/etc tasks...
+

data/spec/ruby_gem_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Howzit::BuildNote do
@@ -9,102 +11,3 @@ describe Howzit::BuildNote do
     end
   end
 end
-
-describe Howzit::Task do
-  subject(:task) { Howzit::Task.new(:run, 'List Directory', 'ls') }
-
-  describe ".new" do
-    it "makes a new task instance" do
-      expect(task).to be_a Howzit::Task
-    end
-  end
-end
-
-describe Howzit::Topic do
-  title = 'Test Title'
-  content = 'Test Content'
-  subject(:topic) { Howzit::Topic.new(title, content) }
-
-  describe ".new" do
-    it "makes a new topic instance" do
-      expect(topic).to be_a Howzit::Topic
-    end
-    it "has the correct title" do
-      expect(topic.title).to eq title
-    end
-    it "has the correct content" do
-      expect(topic.content).to eq content
-    end
-  end
-end
-
-describe Howzit::BuildNote do
-  Dir.chdir('spec')
-  Howzit.options[:include_upstream] = false
-  Howzit.options[:default] = true
-  hz = Howzit.buildnote
-  hz.create_note
-
-  subject(:how) { hz }
-
-  describe ".note_file" do
-    it "locates a build note file" do
-      expect(how.note_file).not_to be_empty
-    end
-  end
-
-  describe ".grep" do
-    it "finds topic containing 'editable'" do
-      expect(how.grep('editable').map { |topic| topic.title }).to include('File Structure')
-    end
-    it "does not return non-matching topic" do
-      expect(how.grep('editable').map { |topic| topic.title }).not_to include('Build')
-    end
-  end
-
-  describe ".find_topic" do
-    it "finds the File Structure topic" do
-      matches = how.find_topic('file struct')
-      expect(matches.count).to eq 1
-      expect(matches[0].title).to eq 'File Structure'
-    end
-    it "fuzzy matches" do
-      Howzit.options[:matching] = 'fuzzy'
-      matches = how.find_topic('flestct')
-      expect(matches.count).to eq 1
-      expect(matches[0].title).to eq 'File Structure'
-    end
-    it "succeeds with partial match" do
-      Howzit.options[:matching] = 'partial'
-      matches = how.find_topic('structure')
-      expect(matches.count).to eq 1
-      expect(matches[0].title).to eq 'File Structure'
-    end
-    it "succeeds with beginswith match" do
-      Howzit.options[:matching] = 'beginswith'
-      matches = how.find_topic('file')
-      expect(matches.count).to eq 1
-      expect(matches[0].title).to eq 'File Structure'
-    end
-    it "succeeds with exact match" do
-      Howzit.options[:matching] = 'exact'
-      matches = how.find_topic('file structure')
-      expect(matches.count).to eq 1
-      expect(matches[0].title).to eq 'File Structure'
-    end
-    it "fails with incomplete exact match" do
-      Howzit.options[:matching] = 'exact'
-      matches = how.find_topic('file struct')
-      expect(matches.count).to eq 0
-    end
-  end
-
-  describe ".topics" do
-    it "contains 4 topics" do
-      expect(how.list_topics.count).to eq 4
-    end
-    it "outputs a newline-separated string for completion" do
-      expect(how.list_completions.scan(/\n/).count).to eq 3
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -13,7 +13,52 @@ require 'howzit'
 
 RSpec.configure do |c|
   c.expect_with(:rspec) { |e| e.syntax = :expect }
+
   c.before(:each) do
     allow(FileUtils).to receive(:remove_entry_secure).with(anything)
+    save_buildnote
+    Howzit.options[:include_upstream] = false
+    Howzit.options[:default] = true
+    @hz = Howzit.buildnote
+  end
+
+  c.after(:each) do
+    delete_buildnote
   end
 end
+
+def save_buildnote
+  note = <<~EONOTE
+    # Howzit Test
+
+    ## Topic Balogna
+
+    @before
+    This should be a prerequisite.
+    @end
+
+    @run(ls -1 &> /dev/null) Null Output
+    @include(Topic Tropic)
+
+    @after
+    This should be a postrequisite.
+    @end
+
+    ## Topic Banana
+
+    This is just another topic.
+
+    - It has a list in it
+    - That's pretty fun, right?
+
+    ## Topic Tropic
+
+    Bermuda, Bahama, something something wanna.
+    @copy(Balogna) Just some balogna
+  EONOTE
+  File.open('builda.md', 'w') { |f| f.puts note }
+end
+
+def delete_buildnote
+  FileUtils.rm('builda.md')
+end

data/spec/task_spec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Howzit::Task do
+  subject(:task) { Howzit::Task.new(:run, 'List Directory', 'ls') }
+
+  describe ".new" do
+    it "makes a new task instance" do
+      expect(task).to be_a Howzit::Task
+    end
+  end
+end

data/spec/topic_spec.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Howzit::Topic do
+  title = 'Test Title'
+  content = 'Test Content'
+  subject(:topic) { Howzit::Topic.new(title, content) }
+
+  describe ".new" do
+    it "makes a new topic instance" do
+      expect(topic).to be_a Howzit::Topic
+    end
+    it "has the correct title" do
+      expect(topic.title).to eq title
+    end
+    it "has the correct content" do
+      expect(topic.content).to eq content
+    end
+  end
+end
+
+describe Howzit::Topic do
+  subject(:topic) { @hz.find_topic('Topic Balogna')[0] }
+
+  describe ".title" do
+    it "has the correct title" do
+      expect(topic.title).to match /Topic Balogna/
+    end
+  end
+
+  describe ".tasks" do
+    it "has 2 tasks" do
+      expect(topic.tasks.count).to eq 2
+    end
+  end
+
+  describe ".prereqs" do
+    it "has prereq" do
+      expect(topic.prereqs.count).to eq 1
+    end
+    it "has postreq" do
+      expect(topic.postreqs.count).to eq 1
+    end
+  end
+
+  describe ".run" do
+    Howzit.options[:default] = true
+    it "shows prereq and postreq" do
+      expect { topic.run }.to output(/prerequisite/).to_stdout
+      expect { topic.run }.to output(/postrequisite/).to_stdout
+    end
+    it "Copies to clipboard" do
+      expect {
+        ENV['RUBYOPT'] = '-W1'
+        Howzit.options[:log_level] = 0
+        topic.run
+      }.to output(/Copied/).to_stderr
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: howzit
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 2.0.5
 platform: ruby
 authors:
 - Brett Terpstra
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-08-03 00:00:00.000000000 Z
+date: 2022-08-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -280,8 +280,12 @@ files:
 - lib/howzit/util.rb
 - lib/howzit/version.rb
 - spec/.rubocop.yml
+- spec/buildnote_spec.rb
+- spec/buildnotes.md.bak
 - spec/ruby_gem_spec.rb
 - spec/spec_helper.rb
+- spec/task_spec.rb
+- spec/topic_spec.rb
 - update_readmes.rb
 homepage: https://github.com/ttscoff/howzit
 licenses:
@@ -309,5 +313,9 @@ summary: Provides a way to access Markdown project notes by topic with query cap
   and the ability to execute the tasks it describes.
 test_files:
 - spec/.rubocop.yml
+- spec/buildnote_spec.rb
+- spec/buildnotes.md.bak
 - spec/ruby_gem_spec.rb
 - spec/spec_helper.rb
+- spec/task_spec.rb
+- spec/topic_spec.rb