howzit 2.1.10 → 2.1.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 67377505c45973e38c5cc2430f2d9428ace8a5680a2bce0cfc26af369a1a98b2
-  data.tar.gz: bd6e00ccaf0484f486c965b0136fbd7a0cbb4af6cd7cf21c777b029c316ff13b
+  metadata.gz: f0fc931036b21c7bb13c805751a146432d14c40a9a910fd9999aa42fb34658cb
+  data.tar.gz: 31b927c85e4c7ba6938eff929e7670c1a997d79f21053ce230da3a1a5ca4b246
 SHA512:
-  metadata.gz: 9fc93201a2080344c7ea080697ccd6a38a0c6a4a7473d98c9bbe2b18f4685ada0799cc9013358d01b7e29696e3a63d074c0e6421dbbf9db55fe69e0586efeae8
-  data.tar.gz: 1a627938a04104298a13ee667876f7c7559707e08a1fdecc136837af26e1c9e0130ab34fd4be1f5b1a3b79172c3d7844cec4c43d147aa1308ce8d21c2c4251ad
+  metadata.gz: 6382fd78151da4a021d605276121fc48f0b1cb7692ee3a4657fd4dee820577f0f5357aa98be565dd120e440619906b1881da2269fe0e53c2321160a34dee26ac
+  data.tar.gz: d402a1dcf7715f04ed32fc282450c4132bf13cd3a43830eb464c298f79dc86fa4c47f30a6bd8d3698e588468f107b0b4eae6ad90c89195d878ef1f610846ab78

data/.rubocop.yml

@@ -1,15 +1,51 @@
+require:
+  - rubocop-rspec
+  - rubocop-rake
+
 AllCops:
   Include:
     - Gemfile
     - Guardfile
     - Rakefile
+    - bin/howzit
+    - lib/**/*.rb
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: single_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: single_quotes
+
+Layout/LineLength:
+  Max: 120
+
+Metrics/MethodLength:
+  Max: 40
 
 Metrics/BlockLength:
+  Max: 40
   Exclude:
     - Rakefile
     - bin/howzit
     - lib/*.rb
 
+Metrics/ClassLength:
+  Max: 300
+
+Metrics/CyclomaticComplexity:
+  Max: 10
+
+Metrics/PerceivedComplexity:
+  Max: 30
+
+Metrics/AbcSize:
+  Max: 45
+
+Metrics/CyclomaticComplexity:
+  Max: 15
+
 Style/RegexpLiteral:
   Exclude:
     - Guardfile

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+### 2.1.13
+
+2024-08-05 12:04
+
+### 2.1.12
+
+2024-08-05 12:01
+
+### 2.1.11
+
+2024-08-05 12:01
+
 ### 2.1.10
 
 2024-04-09 14:59

data/Gemfile

@@ -2,5 +2,8 @@
 
 source 'https://rubygems.org'
 
+gem 'rubocop-rake', require: false
+gem 'rubocop-rspec', require: false
+
 # Specify your gem's dependencies in howzit.gemspec.
 gemspec

data/README.md

@@ -1,3 +1,4 @@
+
 # Howzit
 
 [![Gem](https://img.shields.io/gem/v/howzit.svg)](https://rubygems.org/gems/howzit)
@@ -8,8 +9,6 @@ A command-line reference tool for tracking project build systems
 
 Howzit is a tool that allows you to keep Markdown-formatted notes about a project's tools and procedures. It functions as an easy lookup for notes about a particular task, as well as a task runner to automatically execute appropriate commands.
 
-<!--README-->
-
 ## Features
 
 - Match topic titles with any portion of title
@@ -55,8 +54,6 @@ If you run into permission errors using the above command, you'll need to use `g
 
 This project is licensed under the MIT License - see the [LICENSE.txt](LICENSE.txt) file for details.
 
-<!--END README-->
-
 ## Warranty
 
 This software is provided "as is" and without any express or
@@ -74,6 +71,7 @@ purpose.
 [RubyDoc]: http://www.rubydoc.info/gems/howzit
 [Omniref]: https://www.omniref.com/ruby/gems/howzit
 
+
 ## Development and Testing
 
 ### Source Code
@@ -143,3 +141,4 @@ To submit a patch:
 5. Push to the branch (`git push origin my-new-feature`).
 6. Create a new Pull Request.
 
+

data/Rakefile

@@ -76,4 +76,35 @@ task :dockertest, :version, :login do |_, args|
   # puts commit&.empty? ? "Error commiting Docker tag #{img}" : "Committed Docker tag #{img}"
 end
 
+desc 'Alias for build'
 task package: :build
+
+desc 'Bump incremental version number'
+task :bump, :type do |_, args|
+  args.with_defaults(type: 'inc')
+  version_file = 'lib/howzit/version.rb'
+  content = IO.read(version_file)
+  content.sub!(/VERSION = '(?<major>\d+)\.(?<minor>\d+)\.(?<inc>\d+)(?<pre>\S+)?'/) do
+    m = Regexp.last_match
+    major = m['major'].to_i
+    minor = m['minor'].to_i
+    inc = m['inc'].to_i
+    pre = m['pre']
+
+    case args[:type]
+    when /^maj/
+      major += 1
+      minor = 0
+      inc = 0
+    when /^min/
+      minor += 1
+      inc = 0
+    else
+      inc += 1
+    end
+
+    $stdout.puts "At version #{major}.#{minor}.#{inc}#{pre}"
+    "VERSION = '#{major}.#{minor}.#{inc}#{pre}'"
+  end
+  File.open(version_file, 'w+') { |f| f.puts content }
+end

data/lib/howzit/buildnote.rb

@@ -69,6 +69,7 @@ module Howzit
     ##
     def find_topic(term = nil)
       return @topics if term.nil?
+
       @topics.filter do |topic|
         rx = term.to_rx
         topic.title.downcase.sub(/ *\(.*?\) *$/, '') =~ rx
@@ -114,7 +115,7 @@ module Howzit
     ## @return     [Array] array of topic titles
     ##
     def list_topics
-      @topics.map { |topic| topic.title }
+      @topics.map(&:title)
     end
 
     ##
@@ -360,19 +361,21 @@ module Howzit
     ##
     def ensure_requirements(template)
       t_leader = Util.read_file(template).split(/^#/)[0].strip
-      if t_leader.length > 0
-        t_meta = t_leader.get_metadata
-
-        if t_meta.key?('required')
-          required = t_meta['required'].strip.split(/\s*,\s*/)
-          required.each do |req|
-            unless @metadata.keys.include?(req.downcase)
-              Howzit.console.error %({bRw}ERROR:{xbr} Missing required metadata key from template '{bw}#{File.basename(template, '.md')}{xr}'{x}).c
-              Howzit.console.error %({br}Please define {by}#{req.downcase}{xr} in build notes{x}).c
-              Process.exit 1
-            end
-          end
-        end
+      return unless t_leader.length.positive?
+
+      t_meta = t_leader.get_metadata
+
+      return unless t_meta.key?('required')
+
+      required = t_meta['required'].strip.split(/\s*,\s*/)
+      required.each do |req|
+        next if @metadata.keys.include?(req.downcase)
+
+        Howzit.console.error %({bRw}ERROR:{xbr} Missing required metadata key from template '{bw}#{File.basename(
+          template, '.md'
+        )}{xr}'{x}).c
+        Howzit.console.error %({br}Please define {by}#{req.downcase}{xr} in build notes{x}).c
+        Process.exit 1
       end
     end
 
@@ -388,7 +391,7 @@ module Howzit
       subtopics = nil
 
       if template =~ /\[(.*?)\]$/
-        subtopics = Regexp.last_match[1].split(/\s*\|\s*/).map { |t| t.gsub(/\*/, '.*?')}
+        subtopics = Regexp.last_match[1].split(/\s*\|\s*/).map { |t| t.gsub(/\*/, '.*?') }
         template.sub!(/\[.*?\]$/, '').strip
       end
 
@@ -640,11 +643,10 @@ module Howzit
         Howzit.has_read_upstream = true
       end
 
-      if note_file && @topics.empty?
-        Howzit.console.error("{br}Note file found but no topics detected in #{note_file}{x}".c)
-        Process.exit 1
-      end
+      return unless note_file && @topics.empty?
 
+      Howzit.console.error("{br}Note file found but no topics detected in #{note_file}{x}".c)
+      Process.exit 1
     end
 
     ##
@@ -704,7 +706,7 @@ module Howzit
                  new_topic.print_out({ single: single })
                end
 
-      output.nil? ? '' : output.join("\n")
+      output.nil? ? '' : output.join("\n\n")
     end
 
     ##
@@ -782,7 +784,7 @@ module Howzit
             when :all
               topic_matches.concat(matches)
             else
-              titles = matches.map { |topic| topic.title }
+              titles = matches.map(&:title)
               res = Prompt.choose(titles)
               old_matching = Howzit.options[:matching]
               Howzit.options[:matching] = 'exact'

data/lib/howzit/colors.rb

@@ -5,7 +5,7 @@ module Howzit
   # Terminal output color functions.
   module Color
     # Regexp to match excape sequences
-    ESCAPE_REGEX = /(?<=\[)(?:(?:(?:[349]|10)[0-9]|[0-9])?;?)+(?=m)/.freeze
+    ESCAPE_REGEX = /(?<=\[)(?:(?:(?:[349]|10)[0-9]|[0-9])?;?)+(?=m)/
 
     # All available color names. Available as methods and string extensions.
     #
@@ -113,7 +113,9 @@ module Howzit
         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
+          if Color.attributes.include?(compiled.to_sym) || compiled =~ /^([fb]g?)?#([a-f0-9]{6})$/i
+            valid_color = compiled
+          end
         end
 
         valid_color
@@ -271,7 +273,12 @@ module Howzit
         input = input.join(' ') if input.is_a? Array
         fmt = input.gsub(/%/, '%%')
         fmt = fmt.gsub(/(?<!\\u|\$)\{(\w+)\}/i) do
-          Regexp.last_match(1).split('').map { |c| "%<#{c}>s" }.join('')
+          m = Regexp.last_match(1)
+          if m =~ /^[wkglycmrWKGLYCMRdbuix]+$/
+            m.split('').map { |c| "%<#{c}>s" }.join('')
+          else
+            Regexp.last_match(0)
+          end
         end
 
         colors = { w: white, k: black, g: green, l: blue,
@@ -333,9 +340,28 @@ module Howzit
       module_eval(new_method)
     end
 
+    ##
+    ## Generate escape codes for hex colors
+    ##
+    ## @param      hex   [String] The hexadecimal color code
+    ##
+    ## @return     [String] ANSI escape string
+    ##
+    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
+      "\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
+    COLORED_REGEXP = /\e\[(?:(?:[349]|10)[0-7]|[0-9])?m/
 
     # Returns an uncolored version of the string, that is all
     # ANSI-sequences are stripped from the string.

data/lib/howzit/config.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Howzit
   # Config Class
   class Config
@@ -95,7 +97,7 @@ module Howzit
     def should_ignore(filename)
       return false unless File.exist?(ignore_file)
 
-      @ignore_patterns ||= YAML.safe_load(Util.read_file(ignore_file))
+      @ignore_patterns ||= YAML.load(Util.read_file(ignore_file))
 
       ignore = false
 

data/lib/howzit/prompt.rb

@@ -105,7 +105,7 @@ module Howzit
           Howzit.console.info 'Cancelled'
           Process.exit 0
         end
-        return res.split(/\n/)
+        res.split(/\n/)
       end
 
       def fzf_options(height)

data/lib/howzit/stringutils.rb

@@ -103,7 +103,7 @@ module Howzit
 
     # Just strip out color codes when requested
     def uncolor
-      gsub(/\e\[[\d;]+m/, '').gsub(/\e\]1337;SetMark/,'')
+      gsub(/\e\[[\d;]+m/, '').gsub(/\e\]1337;SetMark/, '')
     end
 
     # Wrap text at a specified width.
@@ -277,7 +277,7 @@ module Howzit
     def extract_metadata
       if File.exist?(self)
         leader = Util.read_file(self).split(/^#/)[0].strip
-        leader.length > 0 ? leader.get_metadata : {}
+        leader.length.positive? ? leader.get_metadata : {}
       else
         {}
       end
@@ -361,11 +361,11 @@ module Howzit
 
       case Howzit.options[:header_format]
       when :block
-        Color.template("#{options[:color]}\u{258C}#{title}#{should_mark_iterm? && options[:mark] ? iterm_marker : ''}{x}")
+        Color.template("\n\n#{options[:color]}\u{258C}#{title}#{should_mark_iterm? && options[:mark] ? iterm_marker : ''}{x}")
       else
         cols = TTY::Screen.columns
 
-        cols = Howzit.options[:wrap] if (Howzit.options[:wrap]).positive? && cols > Howzit.options[:wrap]
+        cols = Howzit.options[:wrap] if Howzit.options[:wrap].positive? && cols > Howzit.options[:wrap]
         title = Color.template("#{options[:border]}#{options[:hr] * 2}( #{options[:color]}#{title}#{options[:border]} )")
 
         tail = if should_mark_iterm?
@@ -373,7 +373,7 @@ module Howzit
                else
                  options[:hr] * (cols - title.uncolor.length)
                end
-        Color.template("#{title}#{tail}{x}")
+        Color.template("\n\n#{title}#{tail}{x}")
       end
     end
   end

data/lib/howzit/task.rb

@@ -39,7 +39,7 @@ module Howzit
     ## @return     [String] description
     ##
     def inspect
-      %(<#Howzit::Task @type=:#{@type} @title="#{@title}" @arguments=#{@arguments} @block?=#{@action.split(/\n/).count > 1}>)
+      %(<#Howzit::Task @type=:#{@type} @title="#{@title}" @action="#{@action}" @arguments=#{@arguments} @block?=#{@action.split(/\n/).count > 1}>)
     end
 
     ##
@@ -95,7 +95,8 @@ module Howzit
     def run_run
       title = Howzit.options[:show_all_code] ? @action : @title
       Howzit.console.info("#{@prefix}{bg}Running {bw}#{title}{x}".c)
-      return system(@action)
+      ENV['HOWZIT_SCRIPTS'] = File.expand_path('~/.config/howzit/scripts')
+      system(@action)
     end
 
     ##
@@ -105,7 +106,7 @@ module Howzit
       title = Howzit.options[:show_all_code] ? @action : @title
       Howzit.console.info("#{@prefix}{bg}Copied {bw}#{title}{bg} to clipboard{x}".c)
       Util.os_copy(@action)
-      return true
+      true
     end
 
     ##

data/lib/howzit/topic.rb

@@ -56,15 +56,28 @@ module Howzit
       @title =~ /#{term}/i || @content =~ /#{term}/i
     end
 
+    def ask_task(task)
+      note = if task.type == :include
+               task_count = Howzit.buildnote.find_topic(task.action)[0].tasks.count
+               " (#{task_count} tasks)"
+             else
+               ''
+             end
+      q = %({bg}#{task.type.to_s.capitalize} {xw}"{bw}#{task.title}{xw}"#{note}{x}).c
+      Prompt.yn(q, default: task.default)
+    end
+
+    def check_cols
+      TTY::Screen.columns > 60 ? 60 : TTY::Screen.columns
+    rescue StandardError
+      60
+    end
+
     # Handle run command, execute directives in topic
     def run(nested: false)
       output = []
 
-      cols = begin
-        TTY::Screen.columns > 60 ? 60 : TTY::Screen.columns
-      rescue StandardError
-        60
-      end
+      cols = check_cols
 
       if @tasks.count.positive?
         unless @prereqs.empty?
@@ -75,18 +88,8 @@ module Howzit
         end
 
         @tasks.each do |task|
-          if task.optional || Howzit.options[:ask]
-            note = if task.type == :include
-                     task_count = Howzit.buildnote.find_topic(task.action)[0].tasks.count
-                     " (#{task_count} tasks)"
-                   else
-                     ''
-                   end
-            q = %({bg}#{task.type.to_s.capitalize} {xw}"{bw}#{task.title}{xw}"#{note}{x}).c
-            res = Prompt.yn(q, default: task.default)
-            next unless res
+          next if (task.optional || Howzit.options[:ask]) && !ask_task(task)
 
-          end
           run_output, total, success = task.run
 
           output.concat(run_output)
@@ -123,6 +126,116 @@ module Howzit
       output
     end
 
+    def title_option(color, topic, keys, opt)
+      option = colored_option(color, topic, keys)
+      "#{opt[:single] ? 'From' : 'Include'} #{topic.title}#{option}:"
+    end
+
+    def colored_option(color, topic, keys)
+      if topic.tasks.empty?
+        ''
+      else
+        optional = keys[:optional] =~ /[?!]+/ ? true : false
+        default = keys[:optional] =~ /!/ ? false : true
+        if optional
+          colored_yn(color, default)
+        else
+          ''
+        end
+      end
+    end
+
+    def colored_yn(color, default)
+      if default
+        " {xKk}[{gbK}Y{xKk}/{dbwK}n{xKk}]{x}#{color}".c
+      else
+        " {xKk}[{dbwK}y{xKk}/{bgK}N{xKk}]{x}#{color}".c
+      end
+    end
+
+    ##
+    ## Handle an include statement
+    ##
+    ## @param      keys  [Hash] The symbolized keys and values from the regex
+    ##                   that found the statement
+    ## @param      opt   [Hash] Options
+    ##
+    def process_include(keys, opt)
+      output = []
+
+      if keys[:action] =~ / *\[(.*?)\] *$/
+        Howzit.named_arguments = @named_args
+        Howzit.arguments = Regexp.last_match(1).split(/ *, */).map!(&:render_arguments)
+      end
+
+      matches = Howzit.buildnote.find_topic(keys[:action].sub(/ *\[.*?\] *$/, ''))
+
+      return [] if matches.empty?
+
+      topic = matches[0]
+
+      rule = '{kKd}'
+      color = '{Kyd}'
+      title = title_option(color, topic, keys, opt)
+      options = { color: color, hr: '.', border: rule }
+
+      output.push("#{'> ' * @nest_level}#{title}".format_header(options)) unless Howzit.inclusions.include?(topic)
+
+      if opt[:single] && Howzit.inclusions.include?(topic)
+        output.push("#{'> ' * @nest_level}#{title} included above".format_header(options))
+      elsif opt[:single]
+        @nest_level += 1
+
+        output.concat(topic.print_out({ single: true, header: false }))
+        output.push("#{'> ' * @nest_level}...".format_header(options))
+        @nest_level -= 1
+      end
+      Howzit.inclusions.push(topic)
+
+      output
+    end
+
+    def color_directive_yn(keys)
+      optional, default = define_optional(keys[:optional])
+      if optional
+        default ? ' {xk}[{g}Y{xk}/{dbw}n{xk}]{x}'.c : ' {xk}[{dbw}y{xk}/{g}N{xk}]{x}'.c
+      else
+        ''
+      end
+    end
+
+    def process_directive(keys)
+      cmd = keys[:cmd]
+      obj = keys[:action]
+      title = keys[:title].empty? ? obj : keys[:title].strip
+      title = Howzit.options[:show_all_code] ? obj : title
+      option = color_directive_yn(keys)
+      icon = case cmd
+             when 'run'
+               "\u{25B6}"
+             when 'copy'
+               "\u{271A}"
+             when /open|url/
+               "\u{279A}"
+             end
+
+      "{bmK}#{icon} {bwK}#{title.preserve_escapes}{x}#{option}".c
+    end
+
+    def define_optional(optional)
+      is_optional = optional =~ /[?!]+/ ? true : false
+      default = optional =~ /!/ ? false : true
+      [is_optional, default]
+    end
+
+    def title_code_block(keys)
+      if keys[:title].length.positive?
+        "Block: #{keys[:title]}#{color_directive_yn(keys)}"
+      else
+        "Code Block#{color_directive_yn(keys)}"
+      end
+    end
+
     # Output a topic with fancy title and bright white text.
     #
     # @param      options  [Hash] The options
@@ -139,99 +252,23 @@ module Howzit
         output.push('')
       end
       topic = @content.dup
-      topic.gsub!(/(?mi)^(`{3,})run([?!]*) *([^\n]*)[\s\S]*?\n\1\s*$/, '@@@run\2 \3') unless Howzit.options[:show_all_code]
+      unless Howzit.options[:show_all_code]
+        topic.gsub!(/(?mix)^(`{3,})run([?!]*)\s*
+                    ([^\n]*)[\s\S]*?\n\1\s*$/, '@@@run\2 \3')
+      end
       topic.split(/\n/).each do |l|
         case l
         when /@(before|after|prereq|end)/
           next
-        when /@include(?<optional>[!?]{1,2})?\((?<action>[^\)]+)\)/
-          m = Regexp.last_match.named_captures.symbolize_keys
-
-          if m[:action] =~ / *\[(.*?)\] *$/
-            Howzit.named_arguments = @named_args
-            Howzit.arguments = Regexp.last_match(1).split(/ *, */).map!(&:render_arguments)
-          end
-
-          matches = Howzit.buildnote.find_topic(m[:action].sub(/ *\[.*?\] *$/, ''))
-
-          unless matches.empty?
-            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] && 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(i_topic)
-          end
+        when /@include(?<optional>[!?]{1,2})?\((?<action>[^)]+)\)/
+          output.concat(process_include(Regexp.last_match.named_captures.symbolize_keys, opt))
         when /@(?<cmd>run|copy|open|url)(?<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
-          title = Howzit.options[:show_all_code] ? obj : title
-          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}"
-                 when 'copy'
-                   "\u{271A}"
-                 when /open|url/
-                   "\u{279A}"
-                 end
-
-          output.push("{bmK}#{icon} {bwK}#{title.preserve_escapes}{x}#{option}".c)
+          output.push(process_directive(Regexp.last_match.named_captures.symbolize_keys))
         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}"
+          desc = title_code_block(Regexp.last_match.named_captures.symbolize_keys)
           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)
+          output.push("{bmK}\u{25B6} {bwK}#{title_code_block(Regexp.last_match.named_captures.symbolize_keys)}{x}".c)
         else
           l.wrap!(Howzit.options[:wrap]) if Howzit.options[:wrap].positive?
           output.push(l)
@@ -241,6 +278,45 @@ module Howzit
       output.push('').map(&:render_arguments)
     end
 
+    include Comparable
+    def <=>(other)
+      @title <=> other.title
+    end
+
+    def define_task_args(keys)
+      cmd = keys[:cmd]
+      obj = keys[:action]
+      title = keys[:title].nil? ? obj : keys[:title].strip
+      title = Howzit.options[:show_all_code] ? obj : title
+      task_args = { type: :include,
+                    arguments: nil,
+                    title: title,
+                    action: obj,
+                    parent: self }
+      case cmd
+      when /include/i
+        if title =~ /\[(.*?)\] *$/
+          Howzit.named_arguments = @named_args
+          args = Regexp.last_match(1).split(/ *, */).map(&:render_arguments)
+          Howzit.arguments = args
+          arguments
+          title.sub!(/ *\[.*?\] *$/, '')
+        end
+
+        task_args[:type] = :include
+        task_args[:arguments] = Howzit.named_arguments
+      when /run/i
+        task_args[:type] = :run
+      when /copy/i
+        task_args[:type] = :copy
+        task_args[:action] = Shellwords.escape(obj)
+      when /open|url/i
+        task_args[:type] = :open
+      end
+
+      task_args
+    end
+
     private
 
     ##
@@ -264,8 +340,7 @@ module Howzit
         Howzit.named_arguments = @named_args
 
         if c[:cmd].nil?
-          optional = c[:optional2] =~ /[?!]{1,2}/ ? true : false
-          default = c[:optional2] =~ /!/ ? false : true
+          optional, default = define_optional(c[:optional2])
           title = c[:title2].nil? ? '' : c[:title2].strip
           block = c[:block]&.strip
           runnable << Howzit::Task.new({ type: :block,
@@ -275,63 +350,10 @@ module Howzit
                                        optional: optional,
                                        default: default)
         else
-          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
-          title = Howzit.options[:show_all_code] ? obj : title
-          case cmd
-          when /include/i
-            # matches = Howzit.buildnote.find_topic(obj)
-            # unless matches.empty? || Howzit.inclusions.include?(matches[0].title)
-            #   tasks = matches[0].tasks.map do |inc|
-            #     Howzit.inclusions.push(matches[0].title)
-            #     inc.parent = matches[0]
-            #     inc
-            #   end
-            #   runnable.concat(tasks)
-            # end
-            args = []
-            if title =~ /\[(.*?)\] *$/
-              Howzit.named_arguments = @named_args
-              args = Regexp.last_match(1).split(/ *, */).map(&:render_arguments)
-              Howzit.arguments = args
-              arguments
-              title.sub!(/ *\[.*?\] *$/, '')
-            end
-
-            runnable << Howzit::Task.new({ type: :include,
-                                           arguments: Howzit.named_arguments,
-                                           title: title,
-                                           action: obj,
-                                           parent: self },
-                                         optional: optional,
-                                         default: default)
-          when /run/i
-            # warn "{bg}Running {bw}#{obj}{x}".c if Howzit.options[:log_level] < 2
-            runnable << Howzit::Task.new({ type: :run,
-                                           title: title,
-                                           action: obj,
-                                           parent: self },
-                                         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({ type: :copy,
-                                           title: title,
-                                           action: Shellwords.escape(obj),
-                                           parent: self },
-                                         optional: optional,
-                                         default: default)
-          when /open|url/i
-            runnable << Howzit::Task.new({ type: :open,
-                                           title: title,
-                                           action: obj,
-                                           parent: self },
-                                         optional: optional,
-                                         default: default)
-          end
+          optional, default = define_optional(c[:optional])
+          runnable << Howzit::Task.new(define_task_args(c),
+                                       optional: optional,
+                                       default: default)
         end
       end
 

data/lib/howzit/util.rb

@@ -210,6 +210,33 @@ module Howzit
         end
       end
 
+      ##
+      ## Platform-agnostic paste-from-clipboard
+      ##
+      def os_paste
+        os = RbConfig::CONFIG['target_os']
+        out = "{bg}Pasting from clipboard".c
+        case os
+        when /darwin.*/i
+          Howzit.console.debug("#{out} (macOS){x}".c)
+          `pbpaste`
+        when /mingw|mswin/i
+          Howzit.console.debug("#{out} (Windows){x}".c)
+          `cat /dev/clipboard`
+        else
+          if 'xsel'.available?
+            Howzit.console.debug("#{out} (Linux, xsel){x}".c)
+            `xsel --clipboard --output`
+          elsif 'xclip'.available?
+            Howzit.console.debug("#{out} (Linux, xclip){x}".c)
+            `xclip -selection clipboard -o`
+          else
+            Howzit.console.debug(out)
+            Howzit.console.warn('Unable to determine executable for clipboard.')
+          end
+        end
+      end
+
       ##
       ## Platform-agnostic open command
       ##

data/lib/howzit/version.rb

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

data/lib/howzit.rb

@@ -50,6 +50,7 @@ require 'tty/box'
 module Howzit
   class << self
     attr_accessor :arguments, :named_arguments, :cli_args
+
     ##
     ## Holds a Configuration object with methods and a @settings hash
     ##
@@ -91,8 +92,6 @@ module Howzit
       @has_read_upstream ||= false
     end
 
-    def has_read_upstream=(has_read)
-      @has_read_upstream = has_read
-    end
+    attr_writer :has_read_upstream
   end
 end

data/spec/topic_spec.rb

@@ -9,7 +9,7 @@ describe Howzit::Topic do
 
   describe '.new' do
     it 'makes a new topic instance' do
-      expect(topic).to be_a Howzit::Topic
+      expect(topic).to be_a described_class
     end
     it 'has the correct title' do
       expect(topic.title).to eq title
@@ -51,9 +51,11 @@ describe Howzit::Topic do
     it 'returns true for matching pattern in content' do
       expect(topic.grep('prereq.*?ite')).to be_truthy
     end
+
     it 'returns true for matching pattern in title' do
       expect(topic.grep('bal.*?na')).to be_truthy
     end
+
     it 'fails on bad pattern' do
       expect(topic.grep('xxx+')).to_not be_truthy
     end
@@ -61,10 +63,12 @@ describe Howzit::Topic do
 
   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'
@@ -77,15 +81,18 @@ describe Howzit::Topic do
   describe '.print_out' do
     Howzit.options[:header_format] = :block
     Howzit.options[:color] = false
+
     it 'prints the topic title' do
-      expect(topic.print_out({single: true, header: true}).join("\n").uncolor).to match(/▌Topic Balogna/)
+      expect(topic.print_out({ single: true, header: true }).join("\n").uncolor).to match(/▌Topic Balogna/)
     end
+
     it 'prints a task title' do
-      expect(topic.print_out({single: true, header: true}).join("\n").uncolor).to match(/▶ Null Output/)
+      expect(topic.print_out({ single: true, header: true }).join("\n").uncolor).to match(/▶ Null Output/)
     end
+
     it 'prints task action with --show-code' do
       Howzit.options[:show_all_code] = true
-      expect(topic.print_out({single: true, header: true}).join("\n").uncolor).to match(/▶ ls -1/)
+      expect(topic.print_out({ single: true, header: true }).join("\n").uncolor).to match(/▶ ls -1/)
     end
   end
 end

data/src/_README.md

@@ -0,0 +1,145 @@
+<!--README--><!--GITHUB-->
+# Howzit
+
+[![Gem](https://img.shields.io/gem/v/howzit.svg)](https://rubygems.org/gems/howzit)
+[![Travis](https://api.travis-ci.com/ttscoff/howzit.svg?branch=main)](https://travis-ci.org/makenew/ruby-gem)
+[![GitHub license](https://img.shields.io/github/license/ttscoff/howzit.svg)](./LICENSE.txt)
+<!--END GITHUB-->
+A command-line reference tool for tracking project build systems
+
+Howzit is a tool that allows you to keep Markdown-formatted notes about a project's tools and procedures. It functions as an easy lookup for notes about a particular task, as well as a task runner to automatically execute appropriate commands.
+
+## Features
+
+- Match topic titles with any portion of title
+- Automatic pagination of output, with optional Markdown highlighting
+- Use `@run()`, `@copy()`, and `@open()` to perform actions within a build notes file
+- Use `@include()` to import another topic's tasks
+- Use fenced code blocks to include/run embedded scripts
+- Sets iTerm 2 marks on topic titles for navigation when paging is disabled
+- Inside of git repositories, howzit will work from subdirectories, assuming build notes are in top level of repo
+- Templates for easily including repeat tasks
+- Grep topics for pattern and choose from matches
+- Use positional and named variables when executing tasks
+
+## Getting Started
+
+### Prerequisites
+
+- Ruby 2.4+ (It probably works on older Rubys, but is untested prior to 2.4.1.)
+- Optional: if [`fzf`](https://github.com/junegunn/fzf) is available, it will be used for handling multiple choice selections
+- Optional: if [`bat`](https://github.com/sharkdp/bat) is available it will page with that
+- Optional: [`mdless`](https://github.com/ttscoff/mdless) or [`mdcat`](https://github.com/lunaryorn/mdcat) for formatting output
+
+### Installing
+
+You can install `howzit` by running:
+
+    gem install howzit
+
+If you run into permission errors using the above command, you'll need to use `gem install --user-install howzit`. If that fails, either use `sudo` (`sudo gem install howzit`) or if you're using Homebrew, you have the option to install via [brew-gem](https://github.com/sportngin/brew-gem):
+
+    brew install brew-gem
+    brew gem install howzit
+
+### Usage
+
+[See the wiki](https://github.com/ttscoff/howzit/wiki) for documentation.
+
+## Author
+
+**Brett Terpstra** - [brettterpstra.com](https://brettterpstra.com)
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE.txt](LICENSE.txt) file for details.
+
+## Warranty
+
+This software is provided "as is" and without any express or
+implied warranties, including, without limitation, the implied
+warranties of merchantibility and fitness for a particular
+purpose.
+
+## Documentation
+
+- [Howzit Wiki][Wiki].
+- [YARD documentation][RubyDoc] is hosted by RubyDoc.info.
+- [Interactive documentation][Omniref] is hosted by Omniref.
+
+[Wiki]: https://github.com/ttscoff/howzit/wiki
+[RubyDoc]: http://www.rubydoc.info/gems/howzit
+[Omniref]: https://www.omniref.com/ruby/gems/howzit
+
+<!--GITHUB-->
+## Development and Testing
+
+### Source Code
+
+The [howzit source] is hosted on GitHub.
+Clone the project with
+
+```
+$ git clone https://github.com/ttscoff/howzit.git
+```
+
+[howzit source]: https://github.com/ttscoff/howzit
+
+### Requirements
+
+You will need [Ruby] with [Bundler].
+
+Install the development dependencies with
+
+```
+$ bundle
+```
+
+[Bundler]: http://bundler.io/
+[Ruby]: https://www.ruby-lang.org/
+
+### Rake
+
+Run `$ rake -T` to see all Rake tasks.
+
+```
+rake build                 # Build howzit-2.0.1.gem into the pkg directory
+rake bump:current[tag]     # Show current gem version
+rake bump:major[tag]       # Bump major part of gem version
+rake bump:minor[tag]       # Bump minor part of gem version
+rake bump:patch[tag]       # Bump patch part of gem version
+rake bump:pre[tag]         # Bump pre part of gem version
+rake bump:set              # Sets the version number using the VERSION environment variable
+rake clean                 # Remove any temporary products
+rake clobber               # Remove any generated files
+rake install               # Build and install howzit-2.0.1.gem into system gems
+rake install:local         # Build and install howzit-2.0.1.gem into system gems without network access
+rake release[remote]       # Create tag v2.0.1 and build and push howzit-2.0.1.gem to Rubygems
+rake rubocop               # Run RuboCop
+rake rubocop:auto_correct  # Auto-correct RuboCop offenses
+rake spec                  # Run RSpec code examples
+rake test                  # Run test suite
+rake yard                  # Generate YARD Documentation
+```
+
+### Guard
+
+Guard tasks have been separated into the following groups:
+`doc`, `lint`, and `unit`.
+By default, `$ guard` will generate documentation, lint, and run unit tests.
+
+## Contributing
+
+Please submit and comment on bug reports and feature requests.
+
+To submit a patch:
+
+1. Fork it (https://github.com/ttscoff/howzit/fork).
+2. Create your feature branch (`git checkout -b my-new-feature`).
+3. Make changes. Write and run tests.
+4. Commit your changes (`git commit -am 'Add some feature'`).
+5. Push to the branch (`git push origin my-new-feature`).
+6. Create a new Pull Request.
+
+<!--END GITHUB-->
+<!--END README-->

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: howzit
 version: !ruby/object:Gem::Version
-  version: 2.1.10
+  version: 2.1.13
 platform: ruby
 authors:
 - Brett Terpstra
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-04-09 00:00:00.000000000 Z
+date: 2024-08-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -339,6 +339,7 @@ files:
 - spec/task_spec.rb
 - spec/topic_spec.rb
 - spec/util_spec.rb
+- src/_README.md
 - update_readmes.rb
 homepage: https://github.com/ttscoff/howzit
 licenses:
@@ -359,7 +360,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.16
+rubygems_version: 3.2.15
 signing_key:
 specification_version: 4
 summary: Provides a way to access Markdown project notes by topic with query capabilities