howzit 2.0.4 → 2.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fba7a6b730f2aabb0e92a26b772cc06fa4182ad07edf7f8620733be70debf766
-  data.tar.gz: 60900d73ffee99002daa4e32b5970c81986756c117fec172c824d59e87e72995
+  metadata.gz: 8ad8cdc085654826428d432429473e7b12375288058f3c0ce993f94937441485
+  data.tar.gz: 8dfda4d862d35559b0cd9a1e89c4a69597aa16ef9dba5dac29eff1ee61ed295a
 SHA512:
-  metadata.gz: 819083c882f7f330d050d23486e390179beb95c4f220458c4a66c496a0fe99eb69746e762d90ce4c033983764693e5dc77499779e1138ae41e64c346b3930d45
-  data.tar.gz: 38d58943e9f8a8d32794ecc638257eb64f67cf09f0a22bc9811ca367627bafb48d22ceed7091551453700fd392fa857b94e37551208735433f0cf4a39ef27f6e
+  metadata.gz: 9ec8eea72d9177717e0ed6dcd07c35d9eb12f998dabea1347efae1dca1fc145a8c5e4b8317f1cf4805606a86209e389643c959aa60deb240ebd2808ddbe456f4
+  data.tar.gz: a9f3e5472866af519bc053ab50ef3f6a5089ddc4334e9687cb64dd9a8e026d00a0b2bb12d1246631f209892de9bb03168cb05cbaa852d97c44734395b00b122b

data/CHANGELOG.md

@@ -1,3 +1,32 @@
+### 2.0.7
+
+2022-08-04 13:04
+
+#### NEW
+
+- --debug flag (shortcut for :log_level: 0)
+
+#### IMPROVED
+
+- Console output now gets log levels, so :log_level: config option and --quiet/verbose have more utility
+
+### 2.0.6
+
+2022-08-04 11:08
+
+### 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

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.
@@ -255,17 +273,21 @@ Some of the command line options can be set as defaults. The first time you run
 
     ---
     :color: true
+    :config_editor: subl
+    :editor: subl
+    :header_format: block
     :highlight: true
-    :paginate: true
-    :wrap: 80
+    :highlighter: mdcat
+    :include_upstream: true
+    :log_level: 0
+    :matching: fuzzy
+    :multiple_matches: choose
     :output_title: false
-    :highlighter: auto
     :pager: auto
-    :matching: partial
-    :include_upstream: false
-    :log_level: 1
-    :multiple_matches: choose
-    :header_format: border
+    :paginate: true
+    :show_all_code: false
+    :show_all_on_error: false
+    :wrap: 0
 
 If `:color:` is false, output will not be colored, and markdown highlighting will be bypassed.
 
@@ -336,6 +358,12 @@ If set to `auto` howzit will look for markdown highlighters in this order, using
 
 If you're combining a highlighter with howzit's pagination, include any flags needed to disable the highlighter's pagination (e.g. `mdless --no-pager`).
 
+### Configuring from the Command Line
+
+You can get and set config options from the command line using `--config-get` and `--config-set`. If you run `--config-get` with no argument, it will display all config options. If you add a key (exact match required) you can get just the value for that key.
+
+Using `--config-set` requires an argument in the format `key=value`. The type of the value (boolean, integer, string, symbol) will be automatically determined and converted. To change your highlighter, for example, use `howzit --config-set highlighter=mdcat`.
+
 ## Shell Integration
 
 I personally like to alias `bld` to `howzit -r`. If you define a function in your shell, you can have it default to "build" but accept an alternate argument. There's an example for Fish included, and in Bash it would be as simple as `howzit -r ${1:build}`.

data/bin/howzit

@@ -74,11 +74,18 @@ OptionParser.new do |opts|
   end
 
   opts.on('-q', '--quiet', 'Silence info message') do
-    Howzit.options[:log_level] = 3
+    Howzit.options[:log_level] = 4
+    Howzit.console.reset_level
   end
 
   opts.on('-v', '--verbose', 'Show all messages') do
+    Howzit.options[:log_level] = 1
+    Howzit.console.reset_level
+  end
+
+  opts.on('-d', '--debug', 'Show debug messages (and all messages)') do
     Howzit.options[:log_level] = 0
+    Howzit.console.reset_level
   end
 
   opts.on('-u', '--[no-]upstream', 'Traverse up parent directories for additional build notes') do |p|
@@ -114,8 +121,8 @@ OptionParser.new do |opts|
     raise 'Argument must be KEY=VALUE' unless key =~ /\S=\S/
 
     parts = key.split(/=/)
-    k = parts[0].sub(/^:/, '')
-    v = parts[1..-1].join(' ')
+    k = parts.shift.sub(/^:/, '')
+    v = parts.join(' ')
 
     if Howzit.options.key?(k.to_sym)
       Howzit.options[k.to_sym] = v.to_config_value(Howzit.options[k.to_sym])

data/lib/howzit/buildnote.rb

@@ -89,7 +89,7 @@ module Howzit
     # Create a buildnotes skeleton
     def create_note
       trap('SIGINT') do
-        warn "\nCanceled"
+        Howzit.console.info "\nCanceled"
         exit!
       end
       default = !$stdout.isatty || Howzit.options[:default]
@@ -269,8 +269,8 @@ module Howzit
           required = t_meta['required'].strip.split(/\s*,\s*/)
           required.each do |req|
             unless @metadata.keys.include?(req.downcase)
-              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
+              Howzit.console.error %({xr}ERROR: Missing required metadata key from template '{bw}#{File.basename(template, '.md')}{xr}'{x}).c
+              Howzit.console.error %({xr}Please define {by}#{req.downcase}{xr} in build notes{x}).c
               Process.exit 1
             end
           end

data/lib/howzit/config.rb

@@ -91,12 +91,12 @@ module Howzit
 
     def create_config(d)
       unless File.directory?(config_dir)
-        warn "Creating config directory at #{config_dir}"
+        Howzit.console.info "Creating config directory at #{config_dir}"
         FileUtils.mkdir_p(config_dir)
       end
 
       unless File.exist?(config_file)
-        warn "Writing fresh config file to #{config_file}"
+        Howzit.console.info "Writing fresh config file to #{config_file}"
         write_config(d)
       end
       config_file

data/lib/howzit/console_logger.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+}.deep_freeze
+
+module Howzit
+  # Console logging
+  class ConsoleLogger
+    attr_accessor :log_level
+
+    def initialize(level = nil)
+      @log_level = level || Howzit.options[:log_level]
+    end
+
+    def reset_level
+      @log_level = Howzit.options[:log_level]
+    end
+
+    def write(msg, level = :info)
+      $stderr.puts msg if LOG_LEVELS[level] >= @log_level
+    end
+
+    def debug(msg)
+      write msg, :debug
+    end
+
+    def info(msg)
+      write msg, :info
+    end
+
+    def warn(msg)
+      write msg, :warn
+    end
+
+    def error(msg)
+      write msg, :error
+    end
+  end
+end

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

@@ -54,7 +54,7 @@ module Howzit
           ]
           res = `echo #{Shellwords.escape(matches.join("\n"))} | fzf #{settings.join(' ')}`.strip
           if res.nil? || res.empty?
-            warn 'Cancelled'
+            Howzit.console.info 'Cancelled'
             Process.exit 0
           end
           return res.split(/\n/)

data/lib/howzit/task.rb

@@ -2,13 +2,19 @@
 
 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 inspect
+      %(<#Howzit::Task @type=:#{@type} @title="#{@title}" @block?=#{@action.split(/\n/).count > 1}>)
     end
 
     def to_s
@@ -16,7 +22,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?', default: 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 "{bg}Running block {bw}#{title}{x}".c if Howzit.options[:log_level] < 2
+            Howzit.console.info "{bg}Running block {bw}#{title}{x}".c if Howzit.options[:log_level] < 2
             block = task.action
             script = Tempfile.new('howzit_script')
             begin
@@ -74,7 +81,7 @@ module Howzit
           end
         end
       else
-        warn "{r}--run: No {br}@directive{xr} found in {bw}#{key}{x}".c
+        Howzit.console.warn "{r}--run: No {br}@directive{xr} found in {bw}#{@title}{x}".c
       end
       output.push("{bm}Ran #{tasks} #{tasks == 1 ? 'task' : 'tasks'}{x}".c) if Howzit.options[:log_level] < 2 && !nested
 
@@ -88,21 +95,21 @@ module Howzit
       out = "{bg}Copying {bw}#{string}".c
       case os
       when /darwin.*/i
-        warn "#{out} (macOS){x}".c if Howzit.options[:log_level] < 2
+        $stderr.puts "#{out} (macOS){x}".c if Howzit.options[:log_level].zero?
         `echo #{Shellwords.escape(string)}'\\c'|pbcopy`
       when /mingw|mswin/i
-        warn "#{out} (Windows){x}".c if Howzit.options[:log_level] < 2
+        $stderr.puts "#{out} (Windows){x}".c if Howzit.options[:log_level].zero?
         `echo #{Shellwords.escape(string)} | clip`
       else
         if 'xsel'.available?
-          warn "#{out} (Linux, xsel){x}".c if Howzit.options[:log_level] < 2
+          $stderr.puts "#{out} (Linux, xsel){x}".c if Howzit.options[:log_level].zero?
           `echo #{Shellwords.escape(string)}'\\c'|xsel -i`
         elsif 'xclip'.available?
-          warn "#{out} (Linux, xclip){x}".c if Howzit.options[:log_level] < 2
+          $stderr.puts "#{out} (Linux, xclip){x}".c if Howzit.options[:log_level].zero?
           `echo #{Shellwords.escape(string)}'\\c'|xclip -i`
         else
-          warn out if Howzit.options[:log_level] < 2
-          warn 'Unable to determine executable for clipboard.'
+          $stderr.puts out if Howzit.options[:log_level].zero?
+          $stderr.puts 'Unable to determine executable for clipboard.'
         end
       end
     end
@@ -112,18 +119,18 @@ module Howzit
       out = "{bg}Opening {bw}#{command}".c
       case os
       when /darwin.*/i
-        warn "#{out} (macOS){x}".c if Howzit.options[:log_level] < 2
+        Howzit.console.debug "#{out} (macOS){x}".c if Howzit.options[:log_level] < 2
         `open #{Shellwords.escape(command)}`
       when /mingw|mswin/i
-        warn "#{out} (Windows){x}".c if Howzit.options[:log_level] < 2
+        Howzit.console.debug "#{out} (Windows){x}".c if Howzit.options[:log_level] < 2
         `start #{Shellwords.escape(command)}`
       else
         if 'xdg-open'.available?
-          warn "#{out} (Linux){x}".c if Howzit.options[:log_level] < 2
+          Howzit.console.debug "#{out} (Linux){x}".c if Howzit.options[:log_level] < 2
           `xdg-open #{Shellwords.escape(command)}`
         else
-          warn out if Howzit.options[:log_level] < 2
-          warn 'Unable to determine executable for `open`.'
+          Howzit.console.debug out if Howzit.options[:log_level] < 2
+          Howzit.console.debug 'Unable to determine executable for `open`.'
         end
       end
     end
@@ -139,49 +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].empty? ? 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}"
@@ -191,14 +206,28 @@ module Howzit
                    "\u{279A}"
                  end
 
-          output.push("{bmK}#{icon} {bwK}#{title.gsub(/\\n/, '\​n')}{x}".c)
-        when /(`{3,})run *(.*?)$/i
-          m = Regexp.last_match
-          desc = m[2].length.positive? ? "Block: #{m[2]}" : 'Code Block'
+          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 *(.*?)$/i
-          m = Regexp.last_match
-          desc = m[1].length.positive? ? "Block: #{m[1]}" : 'Code Block'
+        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?
@@ -215,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
@@ -239,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 "{bg}Running {bw}#{obj}{x}".c if Howzit.options[:log_level] < 2
-            runnable << Howzit::Task.new(:run, title, obj)
+            runnable << Howzit::Task.new(:run, title, obj, optional: optional, default: default)
           when /copy/i
             # 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))
+            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/util.rb

@@ -40,7 +40,7 @@ module Howzit
           if hl.available?
             Howzit.options[:highlighter]
           else
-            warn Color.template("{Rw}Error:{xbw} Specified highlighter (#{Howzit.options[:highlighter]}) not found, switching to auto")
+            Howzit.console.error Color.template("{Rw}Error:{xbw} Specified highlighter (#{Howzit.options[:highlighter]}) not found, switching to auto")
             Howzit.options[:highlighter] = 'auto'
             which_highlighter
           end
@@ -78,7 +78,7 @@ module Howzit
           if pg.available?
             Howzit.options[:pager]
           else
-            warn Color.template("{Rw}Error:{xbw} Specified pager (#{Howzit.options[:pager]}) not found, switching to auto")
+            Howzit.console.error Color.template("{Rw}Error:{xbw} Specified pager (#{Howzit.options[:pager]}) not found, switching to auto")
             Howzit.options[:pager] = 'auto'
             which_pager
           end
@@ -104,7 +104,7 @@ module Howzit
           begin
             exec(pager)
           rescue SystemCallError => e
-            @log.error(e)
+            Howzit.console.error(e)
             exit 1
           end
         end

data/lib/howzit/version.rb

@@ -3,5 +3,5 @@
 # Primary module for this gem.
 module Howzit
   # Current Howzit version.
-  VERSION = '2.0.4'
+  VERSION = '2.0.7'
 end

data/lib/howzit.rb

@@ -5,8 +5,9 @@ require_relative 'howzit/prompt'
 require_relative 'howzit/colors'
 require_relative 'howzit/stringutils'
 
-require_relative 'howzit/util'
 require_relative 'howzit/hash'
+require_relative 'howzit/console_logger'
+require_relative 'howzit/util'
 require_relative 'howzit/config'
 require_relative 'howzit/task'
 require_relative 'howzit/topic'
@@ -52,5 +53,9 @@ module Howzit
     def buildnote
       @buildnote ||= BuildNote.new
     end
+
+    def console
+      @console ||= Howzit::ConsoleLogger.new(options[:log_level])
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: howzit
 version: !ruby/object:Gem::Version
-  version: 2.0.4
+  version: 2.0.7
 platform: ruby
 authors:
 - Brett Terpstra
@@ -272,6 +272,7 @@ files:
 - lib/howzit/buildnotes.rb
 - lib/howzit/colors.rb
 - lib/howzit/config.rb
+- lib/howzit/console_logger.rb
 - lib/howzit/hash.rb
 - lib/howzit/prompt.rb
 - lib/howzit/stringutils.rb