howzit 2.0.13 → 2.0.16

data/lib/howzit/prompt.rb

@@ -75,18 +75,32 @@ module Howzit
       ## options and accepts a numeric response
       ##
       ## @param      matches  [Array] The options list
+      ## @param      height   [Symbol] height of fzf menu
+      ##                      (:auto adjusts height to
+      ##                      number of options, anything
+      ##                      else gets max height for
+      ##                      terminal)
       ##
       ## @return     [Array] the selected results
       ##
-      def choose(matches)
+      def choose(matches, height: :auto)
+        return [] if !$stdout.isatty || matches.count.zero?
+
         if Util.command_exist?('fzf')
+          height = if height == :auto
+                     matches.count + 3
+                   else
+                     TTY::Screen.rows
+                   end
+
           settings = [
             '-0',
             '-1',
             '-m',
-            "--height=#{matches.count + 3}",
+            "--height=#{height}",
             '--header="Use tab to mark multiple selections, enter to display/run"',
-            '--prompt="Select a section > "'
+            '--prompt="Select a section > "',
+            '--preview="howzit {}"'
           ]
           res = `echo #{Shellwords.escape(matches.join("\n"))} | fzf #{settings.join(' ')}`.strip
           if res.nil? || res.empty?
@@ -96,6 +110,8 @@ module Howzit
           return res.split(/\n/)
         end
 
+        return matches if matches.count == 1
+
         res = matches[0..9]
         stty_save = `stty -g`.chomp
 
@@ -120,7 +136,7 @@ module Howzit
             puts 'Out of range'
             options_list(matches)
           end
-        rescue Interrupt
+        ensure
           system('stty', stty_save)
           exit
         end

data/lib/howzit/stringutils.rb

@@ -16,6 +16,22 @@ module Howzit
       true
     end
 
+    ##
+    ## Get the title of the build note (top level header)
+    ##
+    ## @param      truncate  [Integer] Truncate to width
+    ##
+    def note_title(file, truncate = 0)
+      title = match(/(?:^(\S.*?)(?=\n==)|^# ?(.*?)$)/)
+      title = if title
+                title[1].nil? ? title[2] : title[1]
+              else
+                file.sub(/(\.\w+)?$/, '')
+              end
+
+      title && truncate.positive? ? title.trunc(truncate) : title
+    end
+
     ##
     ## Replace slash escaped characters in a string with a
     ## zero-width space that will prevent a shell from
@@ -275,9 +291,9 @@ module Howzit
       data = {}
       meta.each do |k, v|
         case k
-        when /^templ\w+$/
+        when /^te?m?pl(ate)?s?$/
           data['template'] = v
-        when /^req\w+$/
+        when /^req\w*$/
           data['required'] = v
         else
           data[k] = v

data/lib/howzit/task.rb

@@ -8,23 +8,179 @@ module Howzit
     ##
     ## Initialize a Task object
     ##
-    def initialize(params, optional: false, default: true)
-      @type = params[:type]
-      @title = params[:title]
-      @action = params[:action].render_arguments
-      @parent = params[:parent] || nil
+    ## @param      attributes  [Hash] the task attributes
+    ## @param      optional    [Boolean] Task requires
+    ##                         confirmation
+    ## @param      default     [Boolean] Default response
+    ##                         for confirmation dialog
+    ##
+    ## @option attributes :type [Symbol] task type (:block, :run, :include, :copy)
+    ## @option attributes :title [String] task title
+    ## @option attributes :action [String] task action
+    ## @option attributes :parent [String] title of nested (included) topic origin
+    def initialize(attributes, optional: false, default: true)
+      @type = attributes[:type] || :run
+      @title = attributes[:title] || nil
+      @action = attributes[:action].render_arguments || nil
+      @parent = attributes[:parent] || nil
       @optional = optional
       @default = default
     end
 
+    ##
+    ## Inspect
+    ##
+    ## @return     [String] description
+    ##
     def inspect
       %(<#Howzit::Task @type=:#{@type} @title="#{@title}" @block?=#{@action.split(/\n/).count > 1}>)
     end
 
+    ##
+    ## Output string representation
+    ##
+    ## @return     [String] string representation of the object.
+    ##
     def to_s
       @title
     end
 
+    ##
+    ## Execute a block type
+    ##
+    def run_block
+      Howzit.console.info "{bg}Running block {bw}#{@title}{x}".c if Howzit.options[:log_level] < 2
+      block = @action
+      script = Tempfile.new('howzit_script')
+      begin
+        script.write(block)
+        script.close
+        File.chmod(0o777, script.path)
+        system(%(/bin/sh -c "#{script.path}"))
+      ensure
+        script.close
+        script.unlink
+      end
+    end
+
+    ##
+    ## Execute an include task
+    ##
+    ## @return     [Array] [[Array] output, [Integer] number of tasks executed]
+    ##
+    def run_include
+      output = []
+      matches = Howzit.buildnote.find_topic(@action)
+      raise "Topic not found: #{@action}" if matches.empty?
+
+      $stderr.puts "{by}Running tasks from {bw}#{matches[0].title}{x}".c if Howzit.options[:log_level] < 2
+      output.concat(matches[0].run(nested: true))
+      $stderr.puts "{by}End include: #{matches[0].tasks.count} tasks{x}".c if Howzit.options[:log_level] < 2
+      [output, matches[0].tasks.count]
+    end
+
+    ##
+    ## Execute a run task
+    ##
+    def run_run
+      title = Howzit.options[:show_all_code] ? @action : @title
+      $stderr.puts "{bg}Running {bw}#{title}{x}".c if Howzit.options[:log_level] < 2
+      system(@action)
+    end
+
+    ##
+    ## Execute a copy task
+    ##
+    def run_copy
+      title = Howzit.options[:show_all_code] ? @action : @title
+      $stderr.puts "{bg}Copied {bw}#{title}{bg} to clipboard{x}".c if Howzit.options[:log_level] < 2
+      os_copy(@action)
+    end
+
+    ##
+    ## Platform-agnostic copy-to-clipboard
+    ##
+    ## @param      string  [String] The string to copy
+    ##
+    def os_copy(string)
+      os = RbConfig::CONFIG['target_os']
+      out = "{bg}Copying {bw}#{string}".c
+      case os
+      when /darwin.*/i
+        $stderr.puts "#{out} (macOS){x}".c if Howzit.options[:log_level].zero?
+        `echo #{Shellwords.escape(string)}'\\c'|pbcopy`
+      when /mingw|mswin/i
+        $stderr.puts "#{out} (Windows){x}".c if Howzit.options[:log_level].zero?
+        `echo #{Shellwords.escape(string)} | clip`
+      else
+        if 'xsel'.available?
+          $stderr.puts "#{out} (Linux, xsel){x}".c if Howzit.options[:log_level].zero?
+          `echo #{Shellwords.escape(string)}'\\c'|xsel -i`
+        elsif 'xclip'.available?
+          $stderr.puts "#{out} (Linux, xclip){x}".c if Howzit.options[:log_level].zero?
+          `echo #{Shellwords.escape(string)}'\\c'|xclip -i`
+        else
+          $stderr.puts out if Howzit.options[:log_level].zero?
+          $stderr.puts 'Unable to determine executable for clipboard.'
+        end
+      end
+    end
+
+    ##
+    ## Platform-agnostic open command
+    ##
+    ## @param      command  [String] The command
+    ##
+    def os_open(command)
+      os = RbConfig::CONFIG['target_os']
+      out = "{bg}Opening {bw}#{command}".c
+      case os
+      when /darwin.*/i
+        Howzit.console.debug "#{out} (macOS){x}".c if Howzit.options[:log_level] < 2
+        `open #{Shellwords.escape(command)}`
+      when /mingw|mswin/i
+        Howzit.console.debug "#{out} (Windows){x}".c if Howzit.options[:log_level] < 2
+        `start #{Shellwords.escape(command)}`
+      else
+        if 'xdg-open'.available?
+          Howzit.console.debug "#{out} (Linux){x}".c if Howzit.options[:log_level] < 2
+          `xdg-open #{Shellwords.escape(command)}`
+        else
+          Howzit.console.debug out if Howzit.options[:log_level] < 2
+          Howzit.console.debug 'Unable to determine executable for `open`.'
+        end
+      end
+    end
+
+    ##
+    ## Execute the task
+    ##
+    def run
+      output = []
+      tasks = 1
+      if @type == :block
+        run_block
+      else
+        case @type
+        when :include
+          output, tasks = run_include
+        when :run
+          run_run
+        when :copy
+          run_copy
+        when :open
+          os_open(@action)
+        end
+      end
+
+      [output, tasks]
+    end
+
+    ##
+    ## Output terminal-formatted list item
+    ##
+    ## @return     [String] List representation of the object.
+    ##
     def to_list
       "    * #{@type}: #{@title.preserve_escapes}"
     end

data/lib/howzit/topic.rb

@@ -56,52 +56,16 @@ module Howzit
                      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
 
           end
-
-          if task.type == :block
-            Howzit.console.info "{bg}Running block {bw}#{title}{x}".c if Howzit.options[:log_level] < 2
-            block = task.action
-            script = Tempfile.new('howzit_script')
-            begin
-              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
-            title = Howzit.options[:show_all_code] ? task.action : task.title
-            case task.type
-            when :include
-              matches = Howzit.buildnote.find_topic(task.action)
-              raise "Topic not found: #{task.action}" if matches.empty?
-
-              $stderr.puts "{by}Running tasks from {bw}#{matches[0].title}{x}".c if Howzit.options[:log_level] < 2
-              output.push(matches[0].run(nested: true))
-              $stderr.puts "{by}End include: #{matches[0].tasks.count} tasks{x}".c if Howzit.options[:log_level] < 2
-              tasks += matches[0].tasks.count
-            when :run
-              $stderr.puts "{bg}Running {bw}#{title}{x}".c if Howzit.options[:log_level] < 2
-              system(task.action)
-              tasks += 1
-            when :copy
-              $stderr.puts "{bg}Copied {bw}#{title}{bg} to clipboard{x}".c if Howzit.options[:log_level] < 2
-              os_copy(task.action)
-              tasks += 1
-            when :open
-              os_open(task.action)
-              tasks += 1
-            end
-          end
+          run_output, total = task.run
+          output.concat(run_output)
+          tasks += total
         end
       else
         Howzit.console.warn "{r}--run: No {br}@directive{xr} found in {bw}#{@title}{x}".c
@@ -113,61 +77,6 @@ module Howzit
       output
     end
 
-    ##
-    ## Platform-agnostic copy-to-clipboard
-    ##
-    ## @param      string  [String] The string to copy
-    ##
-    def os_copy(string)
-      os = RbConfig::CONFIG['target_os']
-      out = "{bg}Copying {bw}#{string}".c
-      case os
-      when /darwin.*/i
-        $stderr.puts "#{out} (macOS){x}".c if Howzit.options[:log_level].zero?
-        `echo #{Shellwords.escape(string)}'\\c'|pbcopy`
-      when /mingw|mswin/i
-        $stderr.puts "#{out} (Windows){x}".c if Howzit.options[:log_level].zero?
-        `echo #{Shellwords.escape(string)} | clip`
-      else
-        if 'xsel'.available?
-          $stderr.puts "#{out} (Linux, xsel){x}".c if Howzit.options[:log_level].zero?
-          `echo #{Shellwords.escape(string)}'\\c'|xsel -i`
-        elsif 'xclip'.available?
-          $stderr.puts "#{out} (Linux, xclip){x}".c if Howzit.options[:log_level].zero?
-          `echo #{Shellwords.escape(string)}'\\c'|xclip -i`
-        else
-          $stderr.puts out if Howzit.options[:log_level].zero?
-          $stderr.puts 'Unable to determine executable for clipboard.'
-        end
-      end
-    end
-
-    ##
-    ## Platform-agnostic open command
-    ##
-    ## @param      command  [String] The command
-    ##
-    def os_open(command)
-      os = RbConfig::CONFIG['target_os']
-      out = "{bg}Opening {bw}#{command}".c
-      case os
-      when /darwin.*/i
-        Howzit.console.debug "#{out} (macOS){x}".c if Howzit.options[:log_level] < 2
-        `open #{Shellwords.escape(command)}`
-      when /mingw|mswin/i
-        Howzit.console.debug "#{out} (Windows){x}".c if Howzit.options[:log_level] < 2
-        `start #{Shellwords.escape(command)}`
-      else
-        if 'xdg-open'.available?
-          Howzit.console.debug "#{out} (Linux){x}".c if Howzit.options[:log_level] < 2
-          `xdg-open #{Shellwords.escape(command)}`
-        else
-          Howzit.console.debug out if Howzit.options[:log_level] < 2
-          Howzit.console.debug 'Unable to determine executable for `open`.'
-        end
-      end
-    end
-
     # Output a topic with fancy title and bright white text.
     #
     # @param      options  [Hash] The options
@@ -228,6 +137,7 @@ module Howzit
           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
@@ -313,7 +223,7 @@ module Howzit
           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)

data/lib/howzit/util.rb

@@ -4,7 +4,6 @@ module Howzit
   # Util class
   module Util
     class << self
-
       ##
       ## Read a file with UTF-8 encoding and
       ## leading/trailing whitespace removed
@@ -90,7 +89,7 @@ module Howzit
           args = case pg
                  when 'delta'
                    '--pager="less -FXr"'
-                 when /^(less|more)$/
+                 when 'less'
                    '-FXr'
                  when 'bat'
                    if Howzit.options[:highlight]
@@ -117,6 +116,11 @@ module Howzit
 
       # Paginate the output
       def page(text)
+        unless $stdout.isatty
+          puts text
+          return
+        end
+
         read_io, write_io = IO.pipe
 
         input = $stdin
@@ -153,6 +157,7 @@ module Howzit
         options = {
           color: true,
           highlight: false,
+          paginate: true,
           wrap: 0
         }
 
@@ -168,7 +173,7 @@ module Howzit
 
         output = `echo #{Shellwords.escape(string.strip)}#{pipes}`.strip
 
-        if Howzit.options[:paginate]
+        if options[:paginate] && Howzit.options[:paginate]
           page(output)
         else
           puts output

data/lib/howzit/version.rb

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

data/lib/howzit.rb

@@ -55,18 +55,30 @@ module Howzit
       @config ||= Config.new
     end
 
+    ##
+    ## Array for tracking inclusions and avoiding duplicates in output
+    ##
     def inclusions
       @inclusions ||= []
     end
 
+    ##
+    ## Module storage for Howzit::Config.options
+    ##
     def options
       config.options
     end
 
+    ##
+    ## Module storage for buildnote
+    ##
     def buildnote
       @buildnote ||= BuildNote.new
     end
 
+    ##
+    ## Convenience method for logging with Howzit.console.warn, etc.
+    ##
     def console
       @console ||= Howzit::ConsoleLogger.new(options[:log_level])
     end

data/spec/prompt_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Howzit::Prompt do
+  subject(:prompt) { Howzit::Prompt }
+
+  describe '.yn' do
+    it 'returns default response' do
+      Howzit.options[:default] = true
+      expect(prompt.yn('Test prompt', default: true)).to be_truthy
+      expect(prompt.yn('Test prompt', default: false)).not_to be_truthy
+    end
+  end
+
+  describe '.color_single_options' do
+    it 'returns uncolored string' do
+      Howzit::Color.coloring = false
+      expect(prompt.color_single_options(%w[y n])).to eq "[y/n]"
+    end
+  end
+
+  describe '.options_list' do
+    it 'creates a formatted list of options' do
+      options = %w[one two three four five].each_with_object([]) do |x, arr|
+        arr << "Option item #{x}"
+      end
+      expect { prompt.options_list(options) }.to output(/ 2 \) Option item two/).to_stdout
+    end
+  end
+
+  describe '.choose' do
+    it 'returns a single match' do
+      expect(prompt.choose(['option 1']).count).to eq 1
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,13 +1,11 @@
-# require 'simplecov'
+# frozen_string_literal: true
 
-# SimpleCov.start
-
-# if ENV['CI'] == 'true'
-#   require 'codecov'
-#   SimpleCov.formatter = SimpleCov::Formatter::Codecov
-# else
-#   SimpleCov.formatter = SimpleCov::Formatter::HTMLFormatter
-# end
+unless ENV['CI'] == 'true'
+  # SimpleCov::Formatter::Codecov # For CI
+  require 'simplecov'
+  SimpleCov.formatter = SimpleCov::Formatter::HTMLFormatter
+  SimpleCov.start
+end
 
 require 'howzit'
 require 'cli-test'

data/spec/task_spec.rb

@@ -6,8 +6,7 @@ describe Howzit::Task do
   subject(:task) do
     Howzit::Task.new({ type: :run,
                        title: 'List Directory',
-                       action: 'ls',
-                       parent: nil })
+                       action: 'ls &> /dev/null' })
   end
 
   describe ".new" do
@@ -15,4 +14,10 @@ describe Howzit::Task do
       expect(task).to be_a Howzit::Task
     end
   end
+
+  describe ".to_s" do
+    it "outputs title string" do
+      expect(task.to_s).to match(/List Directory/)
+    end
+  end
 end

data/spec/topic_spec.rb

@@ -7,14 +7,14 @@ describe Howzit::Topic do
   content = 'Test Content'
   subject(:topic) { Howzit::Topic.new(title, content) }
 
-  describe ".new" do
-    it "makes a new topic instance" do
+  describe '.new' do
+    it 'makes a new topic instance' do
       expect(topic).to be_a Howzit::Topic
     end
-    it "has the correct title" do
+    it 'has the correct title' do
       expect(topic.title).to eq title
     end
-    it "has the correct content" do
+    it 'has the correct content' do
       expect(topic.content).to eq content
     end
   end
@@ -23,34 +23,49 @@ end
 describe Howzit::Topic do
   subject(:topic) { @hz.find_topic('Topic Balogna')[0] }
 
-  describe ".title" do
-    it "has the correct title" do
-      expect(topic.title).to match /Topic Balogna/
+  describe '.title' do
+    it 'has the correct title' do
+      expect(topic.title).to match(/Topic Balogna/)
     end
   end
 
-  describe ".tasks" do
-    it "has 2 tasks" do
+  describe '.tasks' do
+    it 'has 2 tasks' do
       expect(topic.tasks.count).to eq 2
     end
   end
 
-  describe ".prereqs" do
-    it "has prereq" do
+  describe '.prereqs' do
+    it 'has prereq' do
       expect(topic.prereqs.count).to eq 1
     end
-    it "has postreq" do
+  end
+
+  describe '.postreqs' do
+    it 'has postreq' do
       expect(topic.postreqs.count).to eq 1
     end
   end
 
-  describe ".run" do
+  describe '.grep' 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
+  end
+
+  describe '.run' do
     Howzit.options[:default] = true
-    it "shows prereq and postreq" do
+    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
+    it 'Copies to clipboard' do
       expect {
         ENV['RUBYOPT'] = '-W1'
         Howzit.options[:log_level] = 0
@@ -58,4 +73,19 @@ describe Howzit::Topic do
       }.to output(/Copied/).to_stderr
     end
   end
+
+  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/)
+    end
+    it 'prints a task title' do
+      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/)
+    end
+  end
 end