howzit 1.2.15 → 1.2.18

data/lib/howzit/hash.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# Hash helpers
+class ::Hash
+  ##
+  ## Freeze all values in a hash
+  ##
+  ## @return     Hash with all values frozen
+  ##
+  def deep_freeze
+    chilled = {}
+    each do |k, v|
+      chilled[k] = v.is_a?(Hash) ? v.deep_freeze : v.freeze
+    end
+
+    chilled.freeze
+  end
+
+  def deep_freeze!
+    replace deep_thaw.deep_freeze
+  end
+
+  def deep_thaw
+    chilled = {}
+    each do |k, v|
+      chilled[k] = v.is_a?(Hash) ? v.deep_thaw : v.dup
+    end
+
+    chilled.dup
+  end
+
+  def deep_thaw!
+    replace deep_thaw
+  end
+end

data/lib/howzit/prompt.rb

@@ -3,17 +3,90 @@
 module Howzit
   # Command line prompt utils
   module Prompt
-  	def yn(prompt, default = true)
-      return default if !$stdout.isatty
-
-    	system 'stty cbreak'
-    	yn = color_single_options(default ? %w[Y n] : %w[y N])
-    	$stdout.syswrite "\e[1;37m#{prompt} #{yn}\e[1;37m? \e[0m"
-    	res = $stdin.sysread 1
-    	res.chomp!
-    	puts
-    	system 'stty cooked'
-    	res =~ /y/i
+    class << self
+    	def yn(prompt, default = true)
+        return default if !$stdout.isatty
+
+      	system 'stty cbreak'
+      	yn = color_single_options(default ? %w[Y n] : %w[y N])
+      	$stdout.syswrite "\e[1;37m#{prompt} #{yn}\e[1;37m? \e[0m"
+      	res = $stdin.sysread 1
+      	res.chomp!
+      	puts
+      	system 'stty cooked'
+        res.empty? ? default : res =~ /y/i
+      end
+
+      def color_single_options(choices = %w[y n])
+        out = []
+        choices.each do |choice|
+          case choice
+          when /[A-Z]/
+            out.push(Color.template("{bg}#{choice}{xg}"))
+          else
+            out.push(Color.template("{w}#{choice}"))
+          end
+        end
+        Color.template("{g}[#{out.join('/')}{g}]{x}")
+      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 choose(matches)
+        if Util.command_exist?('fzf')
+          settings = [
+            '-0',
+            '-1',
+            '-m',
+            "--height=#{matches.count + 3}",
+            '--header="Use tab to mark multiple selections, enter to display/run"',
+            '--prompt="Select a section > "'
+          ]
+          res = `echo #{Shellwords.escape(matches.join("\n"))} | fzf #{settings.join(' ')}`.strip
+          if res.nil? || res.empty?
+            warn 'Cancelled'
+            Process.exit 0
+          end
+          return res.split(/\n/)
+        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
     end
   end
 end

data/lib/howzit/stringutils.rb

@@ -28,6 +28,19 @@ module Howzit
       end
     end
 
+    def to_rx
+      case Howzit.options[:matching]
+      when 'exact'
+        /^#{self}$/i
+      when 'beginswith'
+        /^#{self}/i
+      when 'fuzzy'
+        /#{split(//).join('.*?')}/i
+      else
+        /#{self}/i
+      end
+    end
+
     # Just strip out color codes when requested
     def uncolor
       gsub(/\e\[[\d;]+m/, '').gsub(/\e\]1337;SetMark/,'')
@@ -103,20 +116,15 @@ module Howzit
     end
 
     def available?
-      if File.exist?(File.expand_path(self))
-        File.executable?(File.expand_path(self))
-      else
-        system "which #{self}", out: File::NULL
-      end
+      Util.valid_command?(self)
     end
 
     def render_template(vars)
-      content = dup
       vars.each do |k, v|
-        content.gsub!(/\[%#{k}(:.*?)?\]/, v)
+        gsub!(/\[%#{k}(:.*?)?\]/, v)
       end
 
-      content.gsub(/\[%(.*?):(.*?)\]/, '\2')
+      gsub(/\[%(.*?):(.*?)\]/, '\2')
     end
 
     def render_template!(vars)
@@ -154,6 +162,44 @@ module Howzit
       end
       data
     end
+
+    def should_mark_iterm?
+      ENV['TERM_PROGRAM'] =~ /^iTerm/ && !Howzit.options[:run] && !Howzit.options[:paginate]
+    end
+
+    def iterm_marker
+      "\e]1337;SetMark\a" if should_mark_iterm?
+    end
+
+    # Make a fancy title line for the topic
+    def format_header(opts = {})
+      title = dup
+      options = {
+        hr: "\u{254C}",
+        color: '{bg}',
+        border: '{x}',
+        mark: should_mark_iterm?
+      }
+
+      options.merge!(opts)
+
+      case Howzit.options[:header_format]
+      when :block
+        Color.template("#{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]
+        title = Color.template("#{options[:border]}#{options[:hr] * 2}( #{options[:color]}#{title}#{options[:border]} )")
+
+        tail = if should_mark_iterm?
+                 "#{options[:hr] * (cols - title.uncolor.length - 15)}#{options[:mark] ? iterm_marker : ''}"
+               else
+                 options[:hr] * (cols - title.uncolor.length)
+               end
+        Color.template("#{title}#{tail}{x}")
+      end
+    end
   end
 end
 

data/lib/howzit/task.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Howzit
+  class Task
+    attr_reader :type, :title, :action, :parent
+
+    def initialize(type, title, action, parent = nil)
+      @type = type
+      @title = title
+      @action = action
+      @parent = parent
+    end
+
+    def to_s
+      @title
+    end
+
+    def to_list
+      "    * #{@type}: #{@title}"
+    end
+  end
+end

data/lib/howzit/topic.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+module Howzit
+  # Topic Class
+  class Topic
+    attr_writer :parent
+
+    attr_accessor :content
+
+    attr_reader :title, :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.15'.freeze
+  VERSION = '1.2.18'.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'
@@ -18,3 +27,29 @@ 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