doing 1.0.92 → 2.0.5.pre

data/lib/doing/log_adapter.rb

@@ -0,0 +1,342 @@
+# frozen_string_literal: true
+
+module Doing
+  ##
+  ## @brief      Log adapter
+  ##
+  class LogAdapter
+    attr_writer :logdev, :max_length
+
+    attr_reader :messages, :level, :results
+
+    TOPIC_WIDTH = 12
+
+    LOG_LEVELS = {
+      debug: ::Logger::DEBUG,
+      info: ::Logger::INFO,
+      warn: ::Logger::WARN,
+      error: ::Logger::ERROR
+    }.freeze
+
+    COUNT_KEYS = [
+      :added_tags,
+      :removed_tags,
+      :added,
+      :updated,
+      :deleted,
+      :completed,
+      :archived,
+      :moved,
+      :completed_archived,
+      :skipped
+    ].freeze
+
+    #
+    # @brief      Create a new instance of a log writer
+    #
+    # @param      level   (optional, symbol) the log level
+    #
+    def initialize(level = :info)
+      @messages = []
+      @counters = {}
+      COUNT_KEYS.each { |key| @counters[key] = { tag: [], count: 0 } }
+      @results = []
+      @logdev = $stderr
+      @max_length = `tput cols`.strip.to_i - 5 || 85
+      self.log_level = level
+    end
+
+    #
+    # @brief      Set the log level on the writer
+    #
+    # @param      level  (symbol) the log level
+    #
+    # @return     nothing
+    #
+    def log_level=(level)
+      level ||= 'info'
+      level = level.to_s
+      if level.is_a?(String) && level =~ /^([ewid]\w+|[0123])$/
+        level = case level
+                when /^[e0]/
+                  :error
+                when /^[w1]/
+                  :warn
+                when /^[i2]/
+                  :info
+                when /^[d3]/
+                  :debug
+                end
+      else
+        level = level.downcase.to_sym
+      end
+
+      @level = level
+    end
+
+    def adjust_verbosity(options = {})
+      if options[:quiet]
+        self.log_level = :error
+      elsif options[:verbose] || options[:debug]
+        self.log_level = :debug
+      end
+      log_now :debug, 'Logging at level:', @level.to_s
+      # log_now :debug, 'Doing Version:', Doing::VERSION
+    end
+
+    def format_counter(key, data)
+      case key
+      when :added_tags
+        ['Tagged:', data[:message] || 'added %tags to %count %items']
+      when :removed_tags
+        ['Untagged:', data[:message] || 'removed %tags from %count %items']
+      when :added
+        ['Added:', data[:message] || 'added %count new %items']
+      when :updated
+        ['Updated:', data[:message] || 'updated %count %items']
+      when :deleted
+        ['Deleted:', data[:message] || 'deleted %count %items']
+      when :moved
+        ['Moved:', data[:message] || 'moved %count %items']
+      when :completed
+        ['Completed:', data[:message] || 'completed %count %items']
+      when :archived
+        ['Archived:',  data[:message] || 'archived %count %items']
+      when :completed_archived
+        ['Archived:',  data[:message] || 'completed and archived %count %items']
+      when :skipped
+        ['Skipped:', data[:message] || '%count %items were unchanged']
+      end
+    end
+
+    def total_counters
+      @counters.each do |key, data|
+        next if data[:count].zero?
+
+        count = data[:count]
+        tags = data[:tag] ? data[:tag].uniq.map { |t| "@#{t}".cyan }.join(', ') : 'tags'
+        topic, m = format_counter(key, data)
+        message = m.dup
+        message.sub!(/%count/, count.to_s)
+        message.sub!(/%items/, count == 1 ? 'item' : 'items')
+        message.sub!(/%tags/, tags)
+        write(data[:level], topic, message)
+      end
+    end
+
+    def count(key, level: :info, count: 1, tag: nil, message: nil)
+      raise ArgumentError, 'invalid counter key' unless COUNT_KEYS.include?(key)
+
+      @counters[key][:count] += count
+      @counters[key][:tag].concat(tag).sort.uniq unless tag.nil?
+      @counters[key][:level] ||= level
+      @counters[key][:message] ||= message
+    end
+
+    #
+    # @brief      Print a debug message
+    #
+    # @param      topic    the topic of the message
+    # @param      message  the message detail
+    #
+    # @return     nothing
+    #
+    def debug(topic, message = nil, &block)
+      write(:debug, topic, message, &block)
+    end
+
+    #
+    # @brief      Print a message
+    #
+    # @param      topic    the topic of the message, e.g.
+    #                      "Configuration file",
+    #                      "Deprecation", etc.
+    # @param      message  the message detail
+    #
+    # @return     nothing
+    #
+    def info(topic, message = nil, &block)
+      write(:info, topic, message, &block)
+    end
+
+    #
+    # @brief      Print a message
+    #
+    # @param      topic    the topic of the message, e.g.
+    #                      "Configuration file",
+    #                      "Deprecation", etc.
+    # @param      message  the message detail
+    #
+    # @return     nothing
+    #
+    def warn(topic, message = nil, &block)
+      write(:warn, topic, message, &block)
+    end
+
+    #
+    # @brief      Print an error message
+    #
+    # @param      topic    the topic of the message, e.g.
+    #                      "Configuration file",
+    #                      "Deprecation", etc.
+    # @param      message  the message detail
+    #
+    # @return     nothing
+    #
+    def error(topic, message = nil, &block)
+      write(:error, topic, message, &block)
+    end
+
+    #
+    # @brief      Print an error message and immediately
+    #             abort the process
+    #
+    # @param      topic    the topic of the message, e.g.
+    #                      "Configuration file",
+    #                      "Deprecation", etc.
+    # @param      message  the message detail (can be
+    #                      omitted)
+    #
+    # @return     nothing
+    #
+    def abort_with(topic, message = nil, &block)
+      error(topic, message, &block)
+      abort
+    end
+
+    # Internal: Build a topic method
+    #
+    # @param      topic    the topic of the message, e.g.
+    #                      "Configuration file",
+    #                      "Deprecation", etc.
+    # @param      message  the message detail
+    #
+    # @return     the formatted message
+    #
+    def message(topic, message = nil)
+      raise ArgumentError, 'block or message, not both' if block_given? && message
+
+      message = yield if block_given?
+      message = message.to_s.gsub(/\s+/, ' ')
+
+      return topic.ljust(TOPIC_WIDTH) if topic && message.strip.empty?
+
+      topic = formatted_topic(topic, colon: block_given?)
+      message.truncmiddle!(@max_length - TOPIC_WIDTH - 5)
+      out = topic + message
+      out.truncate!(@max_length) if @max_length.positive?
+      messages << out
+      out
+    end
+
+    #
+    # @brief      Format the topic
+    #
+    # @param      topic  the topic of the message, e.g.
+    #                    "Configuration file",
+    #                    "Deprecation", etc.
+    # @param      colon  Separate with a colon?
+    #
+    # @return     the formatted topic statement
+    #
+    def formatted_topic(topic, colon: false)
+      if colon
+        "#{topic}: ".rjust(TOPIC_WIDTH)
+      elsif topic =~ /:$/
+        "#{topic} ".rjust(TOPIC_WIDTH)
+      else
+        "#{topic} "
+      end
+    end
+
+    #
+    # @brief      Check if the message should be written
+    #             given the log level.
+    #
+    # @param      level_of_message  the Symbol level of
+    #                               message, one of :debug,
+    #                               :info, :warn, :error
+    #
+    # @return     whether the message should be written.
+    #
+    def write_message?(level_of_message)
+      LOG_LEVELS.fetch(@level) <= LOG_LEVELS.fetch(level_of_message)
+    end
+
+    #
+    # @brief      Log a message.
+    #
+    # @param      level_of_message  the Symbol level of
+    #                               message, one of :debug,
+    #                               :info, :warn, :error
+    # @param      topic             the String topic or full
+    #                               message
+    # @param      message           the String message
+    #                               (optional)
+    # @param      block             a block containing the
+    #                               message (optional)
+    #
+    # @return     false if the message was not written
+    #
+    def write(level_of_message, topic, message = nil, &block)
+      @results << { level: level_of_message, message: message(topic, message, &block) }
+      true
+    end
+
+    def log_now(level, topic, message = nil, &block)
+      return false unless write_message?(level)
+
+      if @logdev == $stdout
+        @logdev.puts message(topic, message, &block)
+      else
+        @logdev.puts color_message(level, topic, message, &block)
+      end
+    end
+
+    def color_message(level, topic, message = nil, &block)
+      colors = Doing::Color
+      message = message(topic, message, &block)
+      prefix = '  '
+      topic_fg = colors.boldcyan
+      message_fg = colors.boldwhite
+
+      case level
+      when :debug
+        prefix = '> '.softpurple
+        topic_fg = colors.softpurple
+        message_fg = colors.white
+      when :warn
+        prefix = '> '.boldyellow
+        topic_fg = colors.boldyellow
+        message_fg = colors.yellow
+      when :error
+        prefix = '!!'.boldred
+        topic_fg = colors.flamingo
+        message_fg = colors.red
+      end
+
+      message.sub!(/^(\s*\S.*?): (.*?)$/) do
+        m = Regexp.last_match
+        msg = m[2] =~ /(\e\[[\d;]+m)/ ? msg : "#{message_fg}#{m[2]}"
+
+        "#{topic_fg}#{m[1]}#{colors.reset}: #{message_fg}#{m[2]}"
+      end
+
+      "#{prefix} #{message.highlight_tags}#{colors.reset}"
+    end
+
+    def output_results
+      total_counters
+
+      results = @results.select { |msg| write_message?(msg[:level]) }.uniq
+
+      if @logdev == $stdout
+        $stdout.print results.map {|res| res[:message].uncolor }.join("\n")
+      else
+        results.each do |msg|
+          @logdev.puts color_message(msg[:level], msg[:message])
+        end
+      end
+    end
+  end
+end

data/lib/doing/markdown_document_listener.rb

@@ -0,0 +1,174 @@
+require 'stringio'
+require 'time'
+require 'fileutils'
+
+module GLI
+  module Commands
+    # DocumentListener class for GLI documentation generator
+    class MarkdownDocumentListener
+      def initialize(_global_options, _options, _arguments, app)
+        @exe = app.exe_name
+        if File.exist?('COMMANDS.md') # Back up existing README
+          FileUtils.mv('COMMANDS.md', 'COMMANDS.bak')
+          $stderr.puts "Backing up existing COMMANDS.md"
+        end
+        @io = File.new('COMMANDS.md', 'w')
+        @nest = '#'
+        @arg_name_formatter = GLI::Commands::HelpModules::ArgNameFormatter.new
+        @parent_command = []
+      end
+
+      def beginning
+      end
+
+      # Called when processing has completed
+      def ending
+        if File.exist?('CREDITS.md')
+          @io.puts IO.read('CREDITS.md')
+          @io.puts
+        end
+
+        if File.exist?('AUTHORS.md')
+          @io.puts IO.read('AUTHORS.md')
+          @io.puts
+        end
+
+        if File.exist?('LICENSE.md')
+          @io.puts IO.read('LICENSE.md')
+          @io.puts
+        end
+        @io.puts
+        @io.puts "Documentation generated #{Time.now.strftime('%Y-%m-%d %H:%M')}"
+        @io.puts
+        @io.close
+      end
+
+      # Gives you the program description
+      def program_desc(desc)
+        @io.puts "# #{@exe} CLI"
+        @io.puts
+        @io.puts desc
+        @io.puts
+      end
+
+      def program_long_desc(desc)
+        @io.puts "> #{desc}"
+        @io.puts
+      end
+
+      # Gives you the program version
+      def version(version)
+        @io.puts "*v#{version}*"
+        @io.puts
+        # Hacking in the overview file
+        if File.exist?('OVERVIEW.md')
+          @io.puts IO.read('OVERVIEW.md')
+          @io.puts
+        end
+      end
+
+      def options
+        if @nest.size == 1
+          @io.puts "## Global Options"
+        else
+          @io.puts header("Options", 1)
+        end
+        @io.puts
+      end
+
+      # Gives you a flag in the current context
+      def flag(name, aliases, desc, long_desc, default_value, arg_name, must_match, _type)
+        invocations = ([name] + Array(aliases)).map { |_| "`" + add_dashes(_) + "`" }.join(' | ')
+        usage = "#{invocations} #{arg_name || 'arg'}"
+        @io.puts header(usage, 2)
+        @io.puts
+        @io.puts String(desc).strip
+        @io.puts "\n*Default Value:* `#{default_value || 'None'}`\n" unless default_value.nil?
+        @io.puts "\n*Must Match:* `#{must_match.to_s}`\n" unless must_match.nil?
+        cmd_desc = String(long_desc).strip
+        @io.puts "> #{cmd_desc}\n" unless cmd_desc.length == 0
+        @io.puts
+      end
+
+      # Gives you a switch in the current context
+      def switch(name, aliases, desc, long_desc, negatable)
+        if negatable
+          name = "[no-]#{name}" if name.to_s.length > 1
+          aliases = aliases.map { |_|  _.to_s.length > 1 ? "[no-]#{_}" : _ }
+        end
+        invocations = ([name] + aliases).map { |_| "`" + add_dashes(_).strip + "`" }.join('|')
+        @io.puts header("#{invocations}", 2)
+        @io.puts
+        @io.puts String(desc).strip
+        cmd_desc = String(long_desc).strip
+        @io.puts "\n> #{cmd_desc}\n" unless cmd_desc.length == 0
+        @io.puts
+      end
+
+      def end_options
+      end
+
+      def commands
+        @io.puts header("Commands", 1)
+        @io.puts
+        increment_nest
+      end
+
+      # Gives you a command in the current context and creates a new context of this command
+      def command(name, aliases, desc, long_desc, arg_name, arg_options)
+        @parent_command.push ([name] + aliases).join('|')
+        arg_name_fmt = @arg_name_formatter.format(arg_name, arg_options, [])
+        arg_name_fmt = " `#{arg_name_fmt.strip}`" if arg_name_fmt
+        @io.puts header("`$ #{@exe}` <mark>`#{@parent_command.join(' ')}`</mark>#{arg_name_fmt}", 1)
+        @io.puts
+        @io.puts "*#{String(desc).strip}*"
+        @io.puts
+        cmd_desc = String(long_desc).strip.split("\n").map { |_| "> #{_}" }.join("\n")
+        @io.puts "#{cmd_desc}\n\n" unless cmd_desc.length == 0
+        increment_nest
+      end
+
+      # Ends a command, and "pops" you back up one context
+      def end_command(_name)
+        @parent_command.pop
+        decrement_nest
+        @io.puts "* * * * * *\n\n" unless @nest.size > 2
+      end
+
+      # Gives you the name of the current command in the current context
+      def default_command(name)
+        @io.puts "#### [Default Command] #{name}" unless name.nil?
+      end
+
+      def end_commands
+        decrement_nest
+      end
+
+      private
+
+      def add_dashes(name)
+        name = "-#{name}"
+        name = "-#{name}" if name.length > 2
+        name
+      end
+
+      def header(content, increment)
+        if @nest.size + increment > 6
+          "**#{content}**"
+        else
+          "#{@nest}#{'#'*increment} #{content}"
+        end
+      end
+
+      def increment_nest(increment=1)
+        @nest = "#{@nest}#{'#'*increment}"
+      end
+
+      def decrement_nest(increment=1)
+        @nest.gsub!(/#{'#'*increment}$/, '')
+      end
+    end
+  end
+end
+
+GLI::Commands::Doc::FORMATS['markdown'] = GLI::Commands::MarkdownDocumentListener

data/lib/doing/note.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Doing
+  ##
+  ## @brief      This class describes an item note.
+  ##
+  class Note < Array
+    def initialize(note = [])
+      super()
+
+      add(note) if note
+    end
+
+    def add(note, replace: false)
+      clear if replace
+      if note.is_a?(String)
+        append_string(note)
+      elsif note.is_a?(Array)
+        append(note)
+      end
+    end
+
+    def append(lines)
+      concat(lines)
+      replace compress
+    end
+
+    def append_string(input)
+      concat(input.split(/\n/).map(&:strip))
+      replace compress
+    end
+
+    def compress!
+      replace compress
+    end
+
+    def compress
+      delete_if { |l| l =~ /^\s*$/ || l =~ /^#/ }
+    end
+
+    def strip_lines!
+      replace strip_lines
+    end
+
+    def strip_lines
+      map(&:strip)
+    end
+
+    def to_s
+      compress.strip_lines.join("\n")
+    end
+
+    def equal?(other)
+      return false unless other.is_a?(Note)
+
+      to_s == other.to_s
+    end
+  end
+end

data/lib/doing/pager.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Doing
+  # Pagination
+  module Pager
+    class << self
+      def paginate
+        @paginate ||= false
+      end
+
+      def paginate=(should_paginate)
+        @paginate = should_paginate
+      end
+
+      def page(text)
+        unless @paginate
+          puts text
+          return
+        end
+
+        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
+          Doing.logger.debug('Pager:', "Using #{pager}")
+          begin
+            exec(pager.join(' '))
+          rescue SystemCallError => e
+            raise Errors::DoingStandardError, "Pager error, #{e}"
+          end
+        end
+
+        begin
+          read_io.close
+          write_io.write(text)
+          write_io.close
+        rescue SystemCallError => e
+          raise Errors::DoingStandardError, "Pager error, #{e}"
+        end
+
+        _, status = Process.waitpid2(pid)
+        status.success?
+      end
+
+      def which_pager
+        pagers = [ENV['GIT_PAGER'], ENV['PAGER']]
+
+        if Util.exec_available('git')
+          git_pager = `git config --get-all core.pager || true`.split.first
+          git_pager && pagers.push(git_pager)
+        end
+
+        pagers.concat(%w[bat less more pager])
+
+        pagers.select! do |f|
+          if f
+            if f.strip =~ /[ |]/
+              f
+            elsif f == 'most'
+              Doing.logger.warn('most not allowed as pager')
+              false
+            else
+              system "which #{f}", out: File::NULL, err: File::NULL
+            end
+          else
+            false
+          end
+        end
+
+        pg = pagers.first
+        args = case pg
+               when /^more$/
+                 ' -r'
+               when /^less$/
+                 ' -Xr'
+               when /^bat$/
+                 ' -p --pager="less -Xr"'
+               else
+                 ''
+               end
+
+        [pg, args]
+      end
+    end
+  end
+end