howzit 1.2.13 → 1.2.16

data/lib/howzit/topic.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+module Howzit
+  # Topic Class
+  class Topic
+    attr_writer :parent
+
+    attr_reader :title, :content, :tasks, :prereqs, :postreqs
+
+    def initialize(title, content)
+      @title = title
+      @content = content
+      @parent = nil
+      @nest_level = 0
+      @tasks = gather_tasks
+    end
+
+    def grep(term)
+      @title =~ /#{term}/i || @content =~ /#{term}/i
+    end
+
+    # Handle run command, execute directives
+    def run(nested: false)
+      output = []
+      tasks = 0
+      if @tasks.count.positive?
+        unless @prereqs.empty?
+          puts @prereqs.join("\n\n")
+          res = Prompt.yn('This task has prerequisites, have they been met?', true)
+          Process.exit 1 unless res
+
+        end
+
+        @tasks.each do |task|
+          if task.type == :block
+            warn Color.template("{bg}Running block {bw}#{title}{x}") if Howzit.options[:log_level] < 2
+            block = task.action
+            script = Tempfile.new('howzit_script')
+            begin
+              script.write(block)
+              script.close
+              File.chmod(0777, script.path)
+              system(%(/bin/sh -c "#{script.path}"))
+              tasks += 1
+            ensure
+              script.close
+              script.unlink
+            end
+          else
+            case task.type
+            when :include
+              matches = Howzit.buildnote.find_topic(task.action)
+              raise "Topic not found: #{task.action}" if matches.empty?
+
+              warn Color.template("{by}Running tasks from {bw}#{matches[0].title}{x}") if Howzit.options[:log_level] < 2
+              output.push(matches[0].run(nested: true))
+              warn Color.template("{by}End include: #{matches[0].tasks.count} tasks") if Howzit.options[:log_level] < 2
+              tasks += matches[0].tasks.count
+            when :run
+              warn Color.template("{bg}Running {bw}#{task.title}{x}") if Howzit.options[:log_level] < 2
+              system(task.action)
+              tasks += 1
+            when :copy
+              warn Color.template("{bg}Copied {bw}#{task.title}{bg} to clipboard{x}") if Howzit.options[:log_level] < 2
+              `echo #{Shellwords.escape(task.action)}'\\c'|pbcopy`
+              tasks += 1
+            when :open
+              os_open(task.action)
+              tasks += 1
+            end
+          end
+        end
+      else
+        warn Color.template("{r}--run: No {br}@directive{xr} found in {bw}#{key}{x}")
+      end
+      output.push(Color.template("{bm}Ran #{tasks} #{tasks == 1 ? 'task' : 'tasks'}{x}")) if Howzit.options[:log_level] < 2 && !nested
+
+      puts postreqs.join("\n\n") unless postreqs.empty?
+
+      output
+    end
+
+    def os_open(command)
+      os = RbConfig::CONFIG['target_os']
+      out = Color.template("{bg}Opening {bw}#{command}")
+      case os
+      when /darwin.*/i
+        warn Color.template("#{out} (macOS){x}") if Howzit.options[:log_level] < 2
+        `open #{Shellwords.escape(command)}`
+      when /mingw|mswin/i
+        warn Color.template("#{out} (Windows){x}") if Howzit.options[:log_level] < 2
+        `start #{Shellwords.escape(command)}`
+      else
+        if 'xdg-open'.available?
+          warn Color.template("#{out} (Linux){x}") 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`.'
+        end
+      end
+    end
+
+    # Output a topic with fancy title and bright white text.
+    def print_out(options = {})
+      defaults = { single: false, header: true }
+      opt = defaults.merge(options)
+
+      output = []
+      if opt[:header]
+        output.push(@title.format_header)
+        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.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])
+          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 }))
+            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
+            end
+            Howzit.inclusions.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(Color.template("{bmK}#{icon} {bwK}#{obj.gsub(/\\n/, '\​n')}{x}"))
+        when /(`{3,})run *(.*?)$/i
+          m = Regexp.last_match
+          desc = m[2].length.positive? ? "Block: #{m[2]}" : 'Code Block'
+          output.push(Color.template("{bmK}\u{25B6} {bwK}#{desc}{x}\n```"))
+        when /@@@run *(.*?)$/i
+          m = Regexp.last_match
+          desc = m[1].length.positive? ? "Block: #{m[1]}" : 'Code Block'
+          output.push(Color.template("{bmK}\u{25B6} {bwK}#{desc}{x}"))
+        else
+          l.wrap!(Howzit.options[:wrap]) if (Howzit.options[:wrap]).positive?
+          output.push(l)
+        end
+      end
+      output.push('') # FIXME: Is this where the extra line is coming from?
+    end
+
+    private
+
+    def gather_tasks
+      runnable = []
+      @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)
+
+      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)
+        else
+          cmd = c[0]
+          obj = c[1]
+          title = c[3] || obj
+
+          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
+            title = c[3] || obj
+            runnable << Howzit::Task.new(:include, title, obj)
+          when /run/i
+            title = c[3] || obj
+            # warn Color.template("{bg}Running {bw}#{obj}{x}") if Howzit.options[:log_level] < 2
+            runnable << Howzit::Task.new(:run, title, obj)
+          when /copy/i
+            # warn Color.template("{bg}Copied {bw}#{obj}{bg} to clipboard{x}") if Howzit.options[:log_level] < 2
+            runnable << Howzit::Task.new(:copy, title, Shellwords.escape(obj))
+          when /open|url/i
+            runnable << Howzit::Task.new(:open, title, obj)
+          end
+        end
+      end
+
+      runnable
+    end
+  end
+end

data/lib/howzit/util.rb

@@ -0,0 +1,149 @@
+module Howzit
+  module Util
+    class << self
+      def valid_command?(command)
+        cmd = command.split(' ')[0]
+        command_exist?(cmd)
+      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
+
+      # If either mdless or mdcat are installed, use that for highlighting
+      # markdown
+      def which_highlighter
+        if Howzit.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 = Howzit.options[:highlighter].split(/ /)[0]
+          if hl.available?
+            Howzit.options[:highlighter]
+          else
+            warn Color.template("{Rw}Error:{xbw} Specified highlighter (#{Howzit.options[:highlighter]}) not found, switching to auto")
+            Howzit.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 Howzit.options[:pager] =~ /auto/i
+          pagers = [ENV['PAGER'], ENV['GIT_PAGER'],
+                    'bat', 'less', 'more', '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 Howzit.options[:highlight]
+                     '--language Markdown --style plain --pager="less -FXr"'
+                   else
+                     '--style plain --pager="less -FXr"'
+                   end
+                 else
+                   ''
+                 end
+
+          [pg, args].join(' ')
+        else
+          pg = Howzit.options[:pager].split(/ /)[0]
+          if pg.available?
+            Howzit.options[:pager]
+          else
+            warn Color.template("{Rw}Error:{xbw} Specified pager (#{Howzit.options[:pager]}) not found, switching to auto")
+            Howzit.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,
+          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}`.strip
+
+        if Howzit.options[:paginate]
+          page(output)
+        else
+          puts output
+        end
+      end
+    end
+  end
+end

data/lib/howzit/version.rb

@@ -2,5 +2,5 @@
 # Primary module for this gem.
 module Howzit
   # Current Howzit version.
-  VERSION = '1.2.13'.freeze
+  VERSION = '1.2.16'.freeze
 end

data/lib/howzit.rb

@@ -1,8 +1,17 @@
-require 'howzit/version'
-require 'howzit/prompt'
-require 'howzit/colors'
-require 'howzit/buildnotes'
-require 'howzit/stringutils'
+# frozen_string_literal: true
+
+require_relative 'howzit/version'
+require_relative 'howzit/prompt'
+require_relative 'howzit/colors'
+require_relative 'howzit/stringutils'
+
+require_relative 'howzit/util'
+require_relative 'howzit/hash'
+require_relative 'howzit/config'
+require_relative 'howzit/task'
+require_relative 'howzit/topic'
+require_relative 'howzit/buildnote'
+
 require 'optparse'
 require 'shellwords'
 require 'pathname'
@@ -16,3 +25,31 @@ CONFIG_DIR = '~/.config/howzit'
 CONFIG_FILE = 'howzit.yaml'
 IGNORE_FILE = 'ignore.yaml'
 MATCHING_OPTIONS = %w[partial exact fuzzy beginswith].freeze
+MULTIPLE_OPTIONS = %w[first best all choose].freeze
+HEADER_FORMAT_OPTIONS = %w[border block].freeze
+
+module Howzit
+  class << self
+    attr_accessor :arguments, :cli_args
+    ##
+    ## Holds a Configuration object with methods and a @settings hash
+    ##
+    ## @return     [Configuration] Configuration object
+    ##
+    def config
+      @config ||= Config.new
+    end
+
+    def inclusions
+      @inclusions ||= []
+    end
+
+    def options
+      config.options
+    end
+
+    def buildnote
+      @buildnote ||= BuildNote.new
+    end
+  end
+end

data/spec/ruby_gem_spec.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: howzit
 version: !ruby/object:Gem::Version
-  version: 1.2.13
+  version: 1.2.16
 platform: ruby
 authors:
 - Brett Terpstra
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-08-02 00:00:00.000000000 Z
+date: 2022-08-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -268,10 +268,16 @@ files:
 - howzit.gemspec
 - lib/.rubocop.yml
 - lib/howzit.rb
+- lib/howzit/buildnote.rb
 - lib/howzit/buildnotes.rb
 - lib/howzit/colors.rb
+- lib/howzit/config.rb
+- lib/howzit/hash.rb
 - lib/howzit/prompt.rb
 - lib/howzit/stringutils.rb
+- lib/howzit/task.rb
+- lib/howzit/topic.rb
+- lib/howzit/util.rb
 - lib/howzit/version.rb
 - spec/.rubocop.yml
 - spec/ruby_gem_spec.rb