howzit 1.2.5

data/lib/howzit/buildnotes.rb

@@ -0,0 +1,1146 @@
+module Howzit
+  # Primary Class for this module
+  class BuildNotes
+    attr_accessor :arguments, :metadata
+
+    def topics
+      @topics ||= read_help
+    end
+
+    # If either mdless or mdcat are installed, use that for highlighting
+    # markdown
+    def which_highlighter
+      if @options[:highlighter] =~ /auto/i
+        highlighters = %w[mdcat mdless]
+        highlighters.delete_if(&:nil?).select!(&:available?)
+        return nil if highlighters.empty?
+
+        hl = highlighters.first
+        args = case hl
+               when 'mdless'
+                 '--no-pager'
+               end
+
+        [hl, args].join(' ')
+      else
+        hl = @options[:highlighter].split(/ /)[0]
+        if hl.available?
+          @options[:highlighter]
+        else
+          warn 'Specified highlighter not found, switching to auto' if @options[:log_level] < 2
+          @options[:highlighter] = 'auto'
+          which_highlighter
+        end
+      end
+    end
+
+    # When pagination is enabled, find the best (in my opinion) option,
+    # favoring environment settings
+    def which_pager
+      if @options[:pager] =~ /auto/i
+        pagers = [ENV['GIT_PAGER'], ENV['PAGER'],
+                  'bat', 'less', 'more', 'cat', 'pager']
+        pagers.delete_if(&:nil?).select!(&:available?)
+        return nil if pagers.empty?
+
+        pg = pagers.first
+        args = case pg
+               when 'delta'
+                 '--pager="less -FXr"'
+               when /^(less|more)$/
+                 '-FXr'
+               when 'bat'
+                 if @options[:highlight]
+                   '--language Markdown --style plain --pager="less -FXr"'
+                 else
+                   '--style plain --pager="less -FXr"'
+                 end
+               else
+                 ''
+               end
+
+        [pg, args].join(' ')
+      else
+        pg = @options[:pager].split(/ /)[0]
+        if pg.available?
+          @options[:pager]
+        else
+          warn 'Specified pager not found, switching to auto' if @options[:log_level] < 2
+          @options[:pager] = 'auto'
+          which_pager
+        end
+      end
+    end
+
+    # Paginate the output
+    def page(text)
+      read_io, write_io = IO.pipe
+
+      input = $stdin
+
+      pid = Kernel.fork do
+        write_io.close
+        input.reopen(read_io)
+        read_io.close
+
+        # Wait until we have input before we start the pager
+        IO.select [input]
+
+        pager = which_pager
+        begin
+          exec(pager)
+        rescue SystemCallError => e
+          @log.error(e)
+          exit 1
+        end
+      end
+
+      read_io.close
+      write_io.write(text)
+      write_io.close
+
+      _, status = Process.waitpid2(pid)
+      status.success?
+    end
+
+    # print output to terminal
+    def show(string, opts = {})
+      options = {
+        color: true,
+        highlight: false,
+        paginate: false,
+        wrap: 0
+      }
+
+      options.merge!(opts)
+
+      string = string.uncolor unless options[:color]
+
+      pipes = ''
+      if options[:highlight]
+        hl = which_highlighter
+        pipes = "|#{hl}" if hl
+      end
+
+      output = `echo #{Shellwords.escape(string.strip)}#{pipes}`
+
+      if options[:paginate]
+        page(output)
+      else
+        output.gsub!(/^╌/, '\e]1337;SetMark\a╌') if ENV['TERM_PROGRAM'] =~ /^iTerm/ && !options[:run]
+        puts output
+      end
+    end
+
+    def color_single_options(choices = %w[y n])
+      out = []
+      choices.each do |choice|
+        case choice
+        when /[A-Z]/
+          out.push("\e[1;32m#{choice}\e[0;32m")
+        else
+          out.push(choice)
+        end
+      end
+      "\e[0;32m[#{out.join('/')}]\e[0m"
+    end
+
+    # Create a buildnotes skeleton
+    def create_note
+      trap('SIGINT') do
+        warn "\nCanceled"
+        exit!
+      end
+      # First make sure there isn't already a buildnotes file
+      if note_file
+        system 'stty cbreak'
+        fname = "\e[1;33m#{note_file}\e[1;37m"
+        yn = color_single_options(%w[y N])
+        $stdout.syswrite "#{fname} exists and appears to be a build note, continue anyway #{yn}\e[1;37m? \e[0m"
+        res = $stdin.sysread 1
+        res.chomp!
+        puts
+        system 'stty cooked'
+
+        unless res =~ /y/i
+          puts 'Canceled'
+          Process.exit 0
+        end
+      end
+
+      title = File.basename(Dir.pwd)
+      printf "\e[1;37mProject name \e[0;32m[#{title}]\e[1;37m: \e[0m"
+      input = STDIN.gets.chomp
+      title = input unless input.empty?
+
+      summary = ''
+      printf "\e[1;37mProject summary: \e[0m"
+      input = STDIN.gets.chomp
+      summary = input unless input.empty?
+
+      filename = 'buildnotes.md'
+      printf "\e[1;37mBuild notes filename (must begin with 'howzit' or 'build')\n\e[0;32m[#{filename}]\e[1;37m: \e[0m"
+      input = STDIN.gets.chomp
+      filename = input unless input.empty?
+
+      note = <<~EOBUILDNOTES
+        # #{title}
+
+        #{summary}
+
+        ## 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...
+
+      EOBUILDNOTES
+
+      if File.exist?(filename)
+        system 'stty cbreak'
+        yn = color_single_options(%w[y N])
+        file = "\e[1;33m#{filename}"
+        $stdout.syswrite "\e[1;37mAre you absolutely sure you want to overwrite #{file} #{yn}\e[1;37m? \e[0m"
+        res = $stdin.sysread 1
+        res.chomp!
+        puts
+        system 'stty cooked'
+
+        unless res =~ /y/i
+          puts 'Canceled'
+          Process.exit 0
+        end
+      end
+
+      File.open(filename, 'w') do |f|
+        f.puts note
+        puts "Build notes for #{title} written to #{filename}"
+      end
+    end
+
+    # Make a fancy title line for the topic
+    def format_header(title, opts = {})
+      options = {
+        hr: "\u{254C}",
+        color: '1;32',
+        border: '0'
+      }
+
+      options.merge!(opts)
+
+      cols = `tput cols`.strip.to_i
+      cols = @options[:wrap] if (@options[:wrap]).positive? && cols > @options[:wrap]
+      title = "\e[#{options[:border]}m#{options[:hr]}#{options[:hr]}( \e[#{options[:color]}m#{title}\e[#{options[:border]}m )"
+      tail = options[:hr] * (cols - title.uncolor.length)
+      "#{title}#{tail}\e[0m"
+    end
+
+    def os_open(command)
+      os = RbConfig::CONFIG['target_os']
+      out = "\e[1;32mOpening \e[3;37m#{command}"
+      case os
+      when /darwin.*/i
+        warn "#{out} (macOS)\e[0m" if @options[:log_level] < 2
+        `open #{Shellwords.escape(command)}`
+      when /mingw|mswin/i
+        warn "#{out} (Windows)\e[0m" if @options[:log_level] < 2
+        `start #{Shellwords.escape(command)}`
+      else
+        if 'xdg-open'.available?
+          warn "#{out} (Linux)\e[0m" if @options[:log_level] < 2
+          `xdg-open #{Shellwords.escape(command)}`
+        else
+          warn out if @options[:log_level] < 2
+          warn 'Unable to determine executable for `open`.'
+        end
+      end
+    end
+
+    def grep_topics(pat)
+      matching_topics = []
+      topics.each do |topic, content|
+        if content =~ /#{pat}/i || topic =~ /#{pat}/i
+          matching_topics.push(topic)
+        end
+      end
+      matching_topics
+    end
+
+    # Handle run command, execute directives
+    def run_topic(key)
+      output = []
+      tasks = 0
+      if topics[key] =~ /(@(include|run|copy|open|url)\((.*?)\)|`{3,}run)/i
+        directives = topics[key].scan(/(?:@(include|run|copy|open|url)\((.*?)\)|(`{3,})run(?: +([^\n]+))?(.*?)\3)/mi)
+
+        tasks += directives.length
+        directives.each do |c|
+          if c[0].nil?
+            title = c[3] ? c[3].strip : ''
+            warn "\e[1;32mRunning block \e[3;37m#{title}\e[0m" if @options[:log_level] < 2
+            block = c[4].strip
+            script = Tempfile.new('howzit_script')
+            begin
+              script.write(block)
+              script.close
+              File.chmod(0777, script.path)
+              system(%(/bin/sh -c "#{script.path}"))
+            ensure
+              script.close
+              script.unlink
+            end
+          else
+            cmd = c[0]
+            obj = c[1]
+            case cmd
+            when /include/i
+              matches = match_topic(obj)
+              if matches.empty?
+                warn "No topic match for @include(#{search})"
+              else
+                if @included.include?(matches[0])
+                  warn "\e[1;33mTasks from \e[3;37m#{matches[0]} already included, skipping\e[0m" if @options[:log_level] < 2
+                else
+                  warn "\e[1;33mIncluding tasks from \e[3;37m#{matches[0]}\e[0m" if @options[:log_level] < 2
+                  process_topic(matches[0], true)
+                  warn "\e[1;33mEnd include \e[3;37m#{matches[0]}\e[0m" if @options[:log_level] < 2
+                end
+              end
+            when /run/i
+              warn "\e[1;32mRunning \e[3;37m#{obj}\e[0m" if @options[:log_level] < 2
+              system(obj)
+            when /copy/i
+              warn "\e[1;32mCopied \e[3;37m#{obj}\e[1;32m to clipboard\e[0m" if @options[:log_level] < 2
+              `echo #{Shellwords.escape(obj)}'\\c'|pbcopy`
+            when /open|url/i
+              os_open(obj)
+            end
+          end
+        end
+      else
+        warn "\e[0;31m--run: No \e[1;31m@directive\e[0;31;40m found in \e[1;37m#{key}\e[0m"
+      end
+      output.push("Ran #{tasks} #{tasks == 1 ? 'task' : 'tasks'}") if @options[:log_level] < 2
+    end
+
+    # Output a topic with fancy title and bright white text.
+    def output_topic(key, options = {})
+      defaults = { single: false, header: true }
+      opt = defaults.merge(options)
+
+      output = []
+      if opt[:header]
+        output.push(format_header(key))
+        output.push('')
+      end
+      topic = topics[key].strip
+      topic.gsub!(/(?mi)^(`{3,})run *([^\n]*)[\s\S]*?\n\1\s*$/, '@@@run \2') unless @options[:show_all_code]
+      topic.split(/\n/).each do |l|
+        case l
+        when /@include\((.*?)\)/
+
+          m = Regexp.last_match
+          matches = match_topic(m[1])
+          unless matches.empty?
+            if opt[:single]
+              title = "From #{matches[0]}:"
+              color = '33;40'
+              rule = '30;40'
+            else
+              title = "Include #{matches[0]}"
+              color = '33;40'
+              rule = '0'
+            end
+            output.push(format_header("#{'> ' * @nest_level}#{title}", { color: color, hr: '.', border: rule })) unless @included.include?(matches[0])
+
+            if opt[:single]
+              if @included.include?(matches[0])
+                output.push(format_header("#{'> ' * @nest_level}#{title} included above", { color: color, hr: '.', border: rule }))
+              else
+                @nest_level += 1
+                output.concat(output_topic(matches[0], {single: true, header: false}))
+                @nest_level -= 1
+              end
+              output.push(format_header("#{'> ' * @nest_level}...", { color: color, hr: '.', border: rule })) unless @included.include?(matches[0])
+            end
+            @included.push(matches[0])
+          end
+
+        when /@(run|copy|open|url|include)\((.*?)\)/
+          m = Regexp.last_match
+          cmd = m[1]
+          obj = m[2]
+          icon = case cmd
+                 when 'run'
+                   "\u{25B6}"
+                 when 'copy'
+                   "\u{271A}"
+                 when /open|url/
+                   "\u{279A}"
+                 end
+          output.push("\e[1;35;40m#{icon} \e[3;37;40m#{obj}\e[0m")
+        when /(`{3,})run *(.*?)$/i
+          m = Regexp.last_match
+          desc = m[2].length.positive? ? "Block: #{m[2]}" : 'Code Block'
+          output.push("\e[1;35;40m\u{25B6} \e[3;37;40m#{desc}\e[0m\n```")
+        when /@@@run *(.*?)$/i
+          m = Regexp.last_match
+          desc = m[1].length.positive? ? "Block: #{m[1]}" : 'Code Block'
+          output.push("\e[1;35;40m\u{25B6} \e[3;37;40m#{desc}\e[0m")
+        else
+          l.wrap!(@options[:wrap]) if (@options[:wrap]).positive?
+          output.push(l)
+        end
+      end
+      output.push('')
+    end
+
+    def process_topic(key, run, single = false)
+      # Handle variable replacement
+      content = topics[key]
+      unless @arguments.empty?
+        content.gsub!(/\$(\d+)/) do |m|
+          idx = m[1].to_i - 1
+          @arguments.length > idx ? @arguments[idx] : m
+        end
+        content.gsub!(/\$[@*]/, Shellwords.join(@arguments))
+      end
+
+      output = if run
+                 run_topic(key)
+               else
+                 output_topic(key, {single: single})
+               end
+      output.nil? ? '' : output.join("\n")
+    end
+
+    # Output a list of topic titles
+    def list_topics
+      output = []
+      output.push("\e[1;32mTopics:\e[0m\n")
+      topics.each_key do |title|
+        output.push("- \e[1;37m#{title}\e[0m")
+      end
+      output.join("\n")
+    end
+
+    # Output a list of topic titles for shell completion
+    def list_topic_titles
+      topics.keys.join("\n")
+    end
+
+    def get_note_title(filename, truncate = 0)
+      title = nil
+      help = IO.read(filename).strip
+      title = help.match(/(?:^(\S.*?)(?=\n==)|^# ?(.*?)$)/)
+      title = if title
+                title[1].nil? ? title[2] : title[1]
+              else
+               filename.sub(/(\.\w+)?$/, '')
+             end
+
+      title && truncate.positive? ? title.trunc(truncate) : title
+    end
+
+    def list_runnable_titles
+      output = []
+      topics.each do |title, sect|
+        runnable = false
+        sect.split(/\n/).each do |l|
+          if l =~ /(@(run|copy|open|url)\((.*?)\)|`{3,}run)/
+            runnable = true
+            break
+          end
+        end
+        output.push(title) if runnable
+      end
+      output.join("\n")
+    end
+
+    def list_runnable
+      output = []
+      output.push(%(\e[1;32m"Runnable" Topics:\e[0m\n))
+      topics.each do |title, sect|
+        s_out = []
+        lines = sect.split(/\n/)
+        lines.each do |l|
+          case l
+          when /@run\((.*?)\)(.*)?/
+            m = Regexp.last_match
+            run = m[2].strip.length.positive? ? m[2].strip : m[1]
+            s_out.push("    * run: #{run.gsub(/\\n/, '\​n')}")
+          when /@(copy|open|url)\((.*?)\)/
+            m = Regexp.last_match
+            s_out.push("    * #{m[1]}: #{m[2]}")
+          when /`{3,}run(.*)?/m
+            run = '    * run code block'
+            title = Regexp.last_match(1).strip
+            run += " (#{title})" if title.length.positive?
+            s_out.push(run)
+          end
+        end
+        unless s_out.empty?
+          output.push("- \e[1;37m#{title}\e[0m")
+          output.push(s_out.join("\n"))
+        end
+      end
+      output.join("\n")
+    end
+
+    def read_upstream
+      buildnotes = glob_upstream
+      topics_dict = {}
+      buildnotes.each do |path|
+        topics_dict = topics_dict.merge(read_help_file(path))
+      end
+      topics_dict
+    end
+
+    def ensure_requirements(template)
+      t_leader = IO.read(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)
+              warn %(\e[0;31mERROR: Missing required metadata key from template '\e[1;37m#{File.basename(template, '.md')}\e[0;31m'\e[0m)
+              warn %(\e[0;31mPlease define \e[1;33m#{req.downcase}\e[0;31m in build notes\e[0m)
+              Process.exit 1
+            end
+          end
+        end
+      end
+    end
+
+    def get_template_topics(content)
+      leader = content.split(/^#/)[0].strip
+
+      template_topics = {}
+      if leader.length > 0
+        data = leader.get_metadata
+        @metadata = @metadata.merge(data)
+
+        if data.key?('template')
+          templates = data['template'].strip.split(/\s*,\s*/)
+          templates.each do |t|
+            tasks = nil
+            if t =~ /\[(.*?)\]$/
+              tasks = Regexp.last_match[1].split(/\s*,\s*/).map {|t| t.gsub(/\*/, '.*?')}
+              t = t.sub(/\[.*?\]$/, '').strip
+            end
+
+            t_file = t.sub(/(\.md)?$/, '.md')
+            template = File.join(template_folder, t_file)
+            if File.exist?(template)
+              ensure_requirements(template)
+
+              t_topics = read_help_file(template)
+              if tasks
+                tasks.each do |task|
+                  t_topics.keys.each do |topic|
+                    if topic =~ /^(.*?:)?#{task}$/i
+                      template_topics[topic] = t_topics[topic]
+                    end
+                  end
+                end
+              else
+                template_topics = template_topics.merge(t_topics)
+              end
+            end
+          end
+        end
+      end
+      template_topics
+    end
+
+    # Read in the build notes file and output a hash of "Title" => contents
+    def read_help_file(path = nil)
+      filename = path.nil? ? note_file : path
+      topics_dict = {}
+      help = IO.read(filename)
+
+      help.gsub!(/@include\((.*?)\)/) do
+        m = Regexp.last_match
+        file = File.expand_path(m[1])
+        if File.exist?(file)
+          content = IO.read(file)
+          home = ENV['HOME']
+          short_path = File.dirname(file.sub(/^#{home}/, '~'))
+          prefix = "#{short_path}:"
+          parts = content.split(/^##+/)
+          parts.shift
+          content = '## ' + parts.join('## ')
+          content.gsub!(/^(##+ *)(?=\S)/, "\\1#{prefix}")
+          content
+        else
+          m[0]
+        end
+      end
+
+      template_topics = get_template_topics(help)
+
+      split = help.split(/^##+/)
+      split.slice!(0)
+      split.each do |sect|
+        next if sect.strip.empty?
+
+        lines = sect.split(/\n/)
+        title = lines.slice!(0).strip
+        prefix = ''
+        if path
+          if path =~ /#{template_folder}/
+            short_path = File.basename(path, '.md')
+          else
+            home = ENV['HOME']
+            short_path = File.dirname(path.sub(/^#{home}/, '~'))
+            prefix = "_from #{short_path}_\n\n"
+          end
+          title = "#{short_path}:#{title}"
+        end
+        topics_dict[title] = prefix + lines.join("\n").strip.render_template(@metadata)
+      end
+
+      template_topics.each do |title, content|
+        unless topics_dict.key?(title.sub(/^.+:/, ''))
+          topics_dict[title] = content
+        end
+      end
+
+      topics_dict
+    end
+
+    def read_help
+      topics = read_help_file
+      if @options[:include_upstream]
+        upstream_topics = read_upstream
+        upstream_topics.each do |topic, content|
+          unless topics.key?(topic.sub(/^.*?:/, ''))
+            topics[topic] = content
+          end
+        end
+        # topics = upstream_topics.merge(topics)
+      end
+      topics
+    end
+
+
+    def match_topic(search)
+      matches = []
+
+      rx = case @options[:matching]
+           when 'exact'
+             /^#{search}$/i
+           when 'beginswith'
+             /^#{search}/i
+           when 'fuzzy'
+             search = search.split(//).join('.*?') if @options[:matching] == 'fuzzy'
+             /#{search}/i
+           else
+             /#{search}/i
+           end
+
+      topics.each_key do |k|
+        matches.push(k) if k.downcase =~ rx
+      end
+      matches
+    end
+
+    def initialize(args)
+      flags = {
+        run: false,
+        list_topics: false,
+        list_topic_titles: false,
+        list_runnable: false,
+        list_runnable_titles: false,
+        title_only: false,
+        choose: false,
+        quiet: false,
+        verbose: false
+      }
+
+      defaults = {
+        color: true,
+        highlight: true,
+        paginate: true,
+        wrap: 0,
+        output_title: false,
+        highlighter: 'auto',
+        pager: 'auto',
+        matching: 'partial', # exact, partial, fuzzy, beginswith
+        show_all_on_error: false,
+        include_upstream: false,
+        show_all_code: false,
+        grep: nil,
+        log_level: 1 # 0: debug, 1: info, 2: warn, 3: error
+      }
+
+      @metadata = {}
+      @included = []
+      @nest_level = 0
+
+      parts = Shellwords.shelljoin(args).split(/ -- /)
+      args = parts[0] ? Shellwords.shellsplit(parts[0]) : []
+      @arguments = parts[1] ? Shellwords.shellsplit(parts[1]) : []
+
+      config = load_config(defaults)
+      @options = flags.merge(config)
+
+      OptionParser.new do |opts|
+        opts.banner = "Usage: #{__FILE__} [OPTIONS] [TOPIC]"
+        opts.separator ''
+        opts.separator 'Show build notes for the current project (buildnotes.md). Include a topic name to see just that topic, or no argument to display all.'
+        opts.separator ''
+        opts.separator 'Options:'
+
+        opts.on('-c', '--create', 'Create a skeleton build note in the current working directory') do
+          create_note
+          Process.exit 0
+        end
+
+        opts.on('-e', '--edit', "Edit buildnotes file in current working directory using #{File.basename(ENV['EDITOR'])}") do
+          edit_note
+          Process.exit 0
+        end
+
+        opts.on('--grep PATTERN', 'Display sections matching a search pattern') do |pat|
+          @options[:grep] = pat
+        end
+
+        opts.on('-L', '--list-completions', 'List topics for completion') do
+          @options[:list_topics] = true
+          @options[:list_topic_titles] = true
+        end
+
+        opts.on('-l', '--list', 'List available topics') do
+          @options[:list_topics] = true
+        end
+
+        opts.on('-m', '--matching TYPE', MATCHING_OPTIONS, 'Topics matching type', "(#{MATCHING_OPTIONS.join(', ')})") do |c|
+          @options[:matching] = c
+        end
+
+        opts.on('-R', '--list-runnable', 'List topics containing @ directives (verbose)') do
+          @options[:list_runnable] = true
+        end
+
+        opts.on('-r', '--run', 'Execute @run, @open, and/or @copy commands for given topic') do
+          @options[:run] = true
+        end
+
+        opts.on('-s', '--select', 'Select topic from menu') do
+          @options[:choose] = true
+        end
+
+        opts.on('-T', '--task-list', 'List topics containing @ directives (completion-compatible)') do
+          @options[:list_runnable] = true
+          @options[:list_runnable_titles] = true
+        end
+
+        opts.on('-t', '--title', 'Output title with build notes') do
+          @options[:output_title] = true
+        end
+
+        opts.on('-q', '--quiet', 'Silence info message') do
+          @options[:log_level] = 3
+        end
+
+        opts.on('-v', '--verbose', 'Show all messages') do
+          @options[:log_level] = 0
+        end
+
+        opts.on('-u', '--upstream', 'Traverse up parent directories for additional build notes') do
+          @options[:include_upstream] = true
+        end
+
+        opts.on('--show-code', 'Display the content of fenced run blocks') do
+          @options[:show_all_code] = true
+        end
+
+        opts.on('-w', '--wrap COLUMNS', 'Wrap to specified width (default 80, 0 to disable)') do |w|
+          @options[:wrap] = w.to_i
+        end
+
+        opts.on('--edit-config', "Edit configuration file using #{File.basename(ENV['EDITOR'])}") do
+          edit_config(defaults)
+          Process.exit 0
+        end
+
+        opts.on('--title-only', 'Output title only') do
+          @options[:output_title] = true
+          @options[:title_only] = true
+        end
+
+        opts.on('--templates', 'List available templates') do
+          Dir.chdir(template_folder)
+          Dir.glob('*.md').each do |file|
+            template = File.basename(file, '.md')
+            puts "\e[7;30;45mtemplate: \e[7;33;40m#{template}\e[0m"
+            puts "\e[1;30m[\e[1;37mtasks\e[1;30m]──────────────────────────────────────┐\e[0m"
+            metadata = file.extract_metadata
+            topics = read_help_file(file)
+            topics.keys.each do |topic|
+              puts " \e[1;30m│\e[1;37m-\e[0m \e[1;36;40m#{template}:#{topic.sub(/^.*?:/, '')}\e[0m"
+            end
+            if metadata.size > 0
+              meta = []
+              meta << metadata['required'].split(/\s*,\s*/).map {|m| "*\e[1;37m#{m}\e[0;37m" } if metadata.key?('required')
+              meta << metadata['optional'].split(/\s*,\s*/).map {|m| "#{m}" } if metadata.key?('optional')
+              puts "\e[1;30m[\e[1;34mmeta\e[1;30m]───────────────────────────────────────┤\e[0m"
+              puts " \e[1;30m│\e[1;37m \e[0;37m#{meta.join(", ")}\e[0m"
+            end
+            puts " \e[1;30m└───────────────────────────────────────────┘\e[0m"
+          end
+          Process.exit 0
+        end
+
+        opts.on('--[no-]color', 'Colorize output (default on)') do |c|
+          @options[:color] = c
+          @options[:highlight] = false unless c
+        end
+
+        opts.on('--[no-]md-highlight', 'Highlight Markdown syntax (default on), requires mdless or mdcat') do |m|
+          @options[:highlight] = @options[:color] ? m : false
+        end
+
+        opts.on('--[no-]pager', 'Paginate output (default on)') do |p|
+          @options[:paginate] = p
+        end
+
+        opts.on('-h', '--help', 'Display this screen') do
+          puts opts
+          Process.exit 0
+        end
+
+        opts.on('-v', '--version', 'Display version number') do
+          puts "Howzit v#{VERSION}"
+          Process.exit 0
+        end
+      end.parse!(args)
+
+      process(args)
+    end
+
+    def edit_note
+      raise 'No EDITOR variable defined in environment' if ENV['EDITOR'].nil?
+
+      if note_file.nil?
+        system 'stty cbreak'
+        yn = color_single_options(%w[Y n])
+        $stdout.syswrite "No build notes file found, create one #{yn}? "
+        res = $stdin.sysread 1
+        puts
+        system 'stty cooked'
+
+        create_note if res.chomp =~ /^y?$/i
+        edit_note
+      else
+        `#{ENV['EDITOR']} "#{note_file}"`
+      end
+    end
+
+    ##
+    ## @brief      Traverse up directory tree looking for build notes
+    ##
+    ## @return     topics dictionary
+    ##
+    def glob_upstream
+      home = Dir.pwd
+      dir = File.dirname(home)
+      buildnotes = []
+      filename = nil
+
+      while dir != '/' && (dir =~ %r{[A-Z]:/}).nil?
+        Dir.chdir(dir)
+        filename = glob_note
+        unless filename.nil?
+          note = File.join(dir, filename)
+          buildnotes.push(note) unless note == note_file
+        end
+        dir = File.dirname(dir)
+      end
+
+      Dir.chdir(home)
+
+      buildnotes.reverse
+    end
+
+    def is_build_notes(filename)
+      return false if filename.downcase !~ /(^howzit[^.]*|build[^.]+)/
+      return false if should_ignore(filename)
+      true
+    end
+
+    def should_ignore(filename)
+      return false unless File.exist?(ignore_file)
+
+      unless @ignore_patterns
+        @ignore_patterns = YAML.load(IO.read(ignore_file))
+      end
+
+      ignore = false
+
+      @ignore_patterns.each do |pat|
+        if filename =~ /#{pat}/
+          ignore = true
+          break
+        end
+      end
+
+      ignore
+    end
+
+    def glob_note
+      filename = nil
+      # Check for a build note file in the current folder. Filename must start
+      # with "build" and have an extension of txt, md, or markdown.
+
+      Dir.glob('*.{txt,md,markdown}').each do |f|
+        if is_build_notes(f)
+          filename = f
+          break
+        end
+      end
+      filename
+    end
+
+    def note_file
+      @note_file ||= find_note_file
+    end
+
+    def find_note_file
+      filename = glob_note
+
+      if filename.nil? && 'git'.available?
+        proj_dir = `git rev-parse --show-toplevel 2>/dev/null`.strip
+        unless proj_dir == ''
+          Dir.chdir(proj_dir)
+          filename = glob_note
+        end
+      end
+
+      if filename.nil? && @options[:include_upstream]
+        upstream_notes = glob_upstream
+        filename = upstream_notes[-1] unless upstream_notes.empty?
+      end
+
+      return nil if filename.nil?
+
+      File.expand_path(filename)
+    end
+
+    def options_list(matches)
+      counter = 1
+      puts
+      matches.each do |match|
+        printf("%<counter>2d ) %<option>s\n", counter: counter, option: match)
+        counter += 1
+      end
+      puts
+    end
+
+    def command_exist?(command)
+      exts = ENV.fetch('PATHEXT', '').split(::File::PATH_SEPARATOR)
+      if Pathname.new(command).absolute?
+        ::File.exist?(command) ||
+          exts.any? { |ext| ::File.exist?("#{command}#{ext}") }
+      else
+        ENV.fetch('PATH', '').split(::File::PATH_SEPARATOR).any? do |dir|
+          file = ::File.join(dir, command)
+          ::File.exist?(file) ||
+            exts.any? { |ext| ::File.exist?("#{file}#{ext}") }
+        end
+      end
+    end
+
+    def choose(matches)
+      if command_exist?('fzf')
+        res = `echo #{Shellwords.escape(matches.join("\n"))} | fzf -0 -1 --height #{matches.count + 2} --prompt 'Select a section > '`.strip
+        if res.nil? || res.empty?
+          warn 'Cancelled'
+          Process.exit 0
+        end
+        return res
+      end
+
+      res = matches[0..9]
+      stty_save = `stty -g`.chomp
+
+      trap('INT') do
+        system('stty', stty_save)
+        exit
+      end
+
+      options_list(matches)
+
+      begin
+        printf("Type 'q' to cancel, enter for first item", res.length)
+        while (line = Readline.readline(': ', true))
+          if line =~ /^[a-z]/i
+            system('stty', stty_save) # Restore
+            exit
+          end
+          line = line == '' ? 1 : line.to_i
+
+          return matches[line - 1] if line.positive? && line <= matches.length
+
+          puts 'Out of range'
+          options_list(matches)
+        end
+      rescue Interrupt
+        system('stty', stty_save)
+        exit
+      end
+    end
+
+    def config_dir
+      File.expand_path(CONFIG_DIR)
+    end
+
+    def config_file
+      File.join(config_dir, CONFIG_FILE)
+    end
+
+    def ignore_file
+      File.join(config_dir, IGNORE_FILE)
+    end
+
+    def template_folder
+      File.join(config_dir, 'templates')
+    end
+
+    def create_config
+      dir, file = [config_dir, config_file]
+      unless File.directory?(dir)
+        warn "Creating config directory at #{dir}"
+        FileUtils.mkdir_p(dir)
+      end
+
+      unless File.exist?(file)
+        warn "Writing fresh config file to #{file}"
+        write_config(defaults)
+      end
+      file
+    end
+
+    def load_config(defaults)
+      file = create_config
+      config = YAML.load(IO.read(file))
+      newconfig = config ? defaults.merge(config) : defaults
+      write_config(newconfig)
+      newconfig
+    end
+
+    def write_config(config)
+      File.open(config_file, 'w') { |f| f.puts config.to_yaml }
+    end
+
+    def edit_config(defaults)
+      raise 'No EDITOR variable defined in environment' if ENV['EDITOR'].nil?
+
+      load_config(defaults)
+      `#{ENV['EDITOR']} "#{config_file}"`
+    end
+
+    def process(args)
+      output = []
+
+      unless note_file
+        Process.exit 0 if @options[:list_runnable_titles] || @options[:list_topic_titles]
+
+        # clear the buffer
+        ARGV.length.times do
+          ARGV.shift
+        end
+        system 'stty cbreak'
+        yn = color_single_options(%w[Y n])
+        $stdout.syswrite "No build notes file found, create one #{yn}? "
+        res = $stdin.sysread 1
+        puts
+        system 'stty cooked'
+
+        create_note if res.chomp =~ /^y?$/i
+        Process.exit 1
+      end
+
+      if @options[:title_only]
+        out = get_note_title(note_file, 20)
+        $stdout.print(out.strip)
+        Process.exit(0)
+      elsif @options[:output_title]
+        title = get_note_title(note_file)
+        if title && !title.empty?
+          header = format_header(title, { hr: "\u{2550}", color: '1;37;40' })
+          output.push("#{header}\n")
+        end
+      end
+
+      if @options[:list_runnable]
+        if @options[:list_runnable_titles]
+          out = list_runnable_titles
+          $stdout.print(out.strip)
+        else
+          out = list_runnable
+          show(out, { color: @options[:color], paginate: false, highlight: false })
+        end
+        Process.exit(0)
+      end
+
+      if @options[:list_topics]
+        if @options[:list_topic_titles]
+          $stdout.print(list_topic_titles)
+        else
+          out = list_topics
+          show(out, { color: @options[:color], paginate: false, highlight: false })
+        end
+        Process.exit(0)
+      end
+
+      topic_match = nil
+      if @options[:grep]
+        topic_match = choose(grep_topics(@options[:grep]))
+      elsif @options[:choose]
+        topic_match = choose(topics.keys)
+      # If there are arguments use those to search for a matching topic
+      elsif !args.empty?
+
+        search = args.join(' ').strip.downcase
+        matches = match_topic(search)
+
+        if matches.empty?
+          output.push(%(\e[0;31mERROR: No topic match found for \e[1;33m#{search}\e[0m\n))
+          if !@options[:show_all_on_error]
+            show(output.join("\n"), { color: true, highlight: false, paginate: false, wrap: 0 })
+            Process.exit 1
+          end
+        elsif matches.length == 1
+          topic_match = matches[0]
+        else
+          topic_match = choose(matches)
+        end
+      end
+
+      if topic_match
+        # If we found a match
+        output.push(process_topic(topic_match, @options[:run], true))
+      else
+        # If there's no argument or no match found, output all
+        topics.each_key { |k| output.push(process_topic(k, false, false)) }
+      end
+      @options[:paginate] = false if @options[:run]
+      show(output.join("\n").strip, @options)
+    end
+  end
+end