howzit 1.2.14 → 1.2.17

data/lib/howzit/config.rb

@@ -0,0 +1,128 @@
+module Howzit
+  # Config Class
+  class Config
+    attr_reader :options
+
+    DEFAULTS = {
+      color: true,
+      config_editor: ENV['EDITOR'] || nil,
+      editor: ENV['EDITOR'] || nil,
+      header_format: 'border',
+      highlight: true,
+      highlighter: 'auto',
+      include_upstream: false,
+      log_level: 1, # 0: debug, 1: info, 2: warn, 3: error
+      matching: 'partial', # exact, partial, fuzzy, beginswith
+      multiple_matches: 'choose',
+      output_title: false,
+      pager: 'auto',
+      paginate: true,
+      show_all_code: false,
+      show_all_on_error: false,
+      wrap: 0
+    }.deep_freeze
+
+    def initialize
+      load_options
+    end
+
+    def write_config(config)
+      File.open(config_file, 'w') { |f| f.puts config.to_yaml }
+    end
+
+    def should_ignore(filename)
+      return false unless File.exist?(ignore_file)
+
+      @ignore_patterns ||= YAML.safe_load(IO.read(ignore_file))
+
+      ignore = false
+
+      @ignore_patterns.each do |pat|
+        if filename =~ /#{pat}/
+          ignore = true
+          break
+        end
+      end
+
+      ignore
+    end
+
+    def template_folder
+      File.join(config_dir, 'templates')
+    end
+
+    def editor
+      edit_config(DEFAULTS)
+    end
+
+    private
+
+    def load_options
+      Color.coloring = $stdout.isatty
+      flags = {
+        choose: false,
+        default: false,
+        grep: nil,
+        list_runnable: false,
+        list_runnable_titles: false,
+        list_topic_titles: false,
+        list_topics: false,
+        quiet: false,
+        run: false,
+        title_only: false,
+        verbose: false
+      }
+
+      config = load_config
+      @options = flags.merge(config)
+    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 create_config(d)
+      unless File.directory?(config_dir)
+        warn "Creating config directory at #{config_dir}"
+        FileUtils.mkdir_p(config_dir)
+      end
+
+      unless File.exist?(config_file)
+        warn "Writing fresh config file to #{config_file}"
+        write_config(d)
+      end
+      config_file
+    end
+
+    def load_config
+      file = create_config(DEFAULTS)
+      config = YAML.load(IO.read(file))
+      newconfig = config ? DEFAULTS.merge(config) : DEFAULTS
+      write_config(newconfig)
+      newconfig.dup
+    end
+
+    def edit_config(d)
+      editor = Howzit.options.fetch(:config_editor, ENV['EDITOR'])
+
+      raise 'No config_editor defined' if editor.nil?
+
+      # raise "Invalid editor (#{editor})" unless Util.valid_command?(editor)
+
+      load_config
+      if Util.valid_command?(editor.split(/ /).first)
+        system %(#{editor} "#{config_file}")
+      else
+        `open -a "#{editor}" "#{config_file}"`
+      end
+    end
+  end
+end

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 + 2}",
+            '--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,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