na 1.0.0

data/lib/na/colors.rb

@@ -0,0 +1,335 @@
+# frozen_string_literal: true
+
+# Cribbed from <https://github.com/flori/term-ansicolor>
+module NA
+  # Terminal output color functions.
+  module Color
+    # Regexp to match excape sequences
+    ESCAPE_REGEX = /(?<=\[)(?:(?:(?:[349]|10)[0-9]|[0-9])?;?)+(?=m)/.freeze
+
+    # All available color names. Available as methods and string extensions.
+    #
+    # @example Use a color as a method. Color reset will be added to end of string.
+    #   Color.yellow('This text is yellow') => "\e[33mThis text is yellow\e[0m"
+    #
+    # @example Use a color as a string extension. Color reset added automatically.
+    #   'This text is green'.green => "\e[1;32mThis text is green\e[0m"
+    #
+    # @example Send a text string as a color
+    #   Color.send('red') => "\e[31m"
+    ATTRIBUTES = [
+      [:clear,               0], # String#clear is already used to empty string in Ruby 1.9
+      [:reset,               0], # synonym for :clear
+      [:bold,                1],
+      [:dark,                2],
+      [:italic,              3], # not widely implemented
+      [:underline,           4],
+      [:underscore,          4], # synonym for :underline
+      [:blink,               5],
+      [:rapid_blink,         6], # not widely implemented
+      [:negative,            7], # no reverse because of String#reverse
+      [:concealed,           8],
+      [:strikethrough,       9], # not widely implemented
+      [:strike,              9], # not widely implemented
+      [:black,              30],
+      [:red,                31],
+      [:green,              32],
+      [:yellow,             33],
+      [:blue,               34],
+      [:magenta,            35],
+      [:purple,             35],
+      [:cyan,               36],
+      [:white,              37],
+      [:bgblack,            40],
+      [:bgred,              41],
+      [:bggreen,            42],
+      [:bgyellow,           43],
+      [:bgblue,             44],
+      [:bgmagenta,          45],
+      [:bgpurple,           45],
+      [:bgcyan,             46],
+      [:bgwhite,            47],
+      [:boldblack,          90],
+      [:boldred,            91],
+      [:boldgreen,          92],
+      [:boldyellow,         93],
+      [:boldblue,           94],
+      [:boldmagenta,        95],
+      [:boldpurple,         95],
+      [:boldcyan,           96],
+      [:boldwhite,          97],
+      [:boldbgblack,       100],
+      [:boldbgred,         101],
+      [:boldbggreen,       102],
+      [:boldbgyellow,      103],
+      [:boldbgblue,        104],
+      [:boldbgmagenta,     105],
+      [:boldbgpurple,      105],
+      [:boldbgcyan,        106],
+      [:boldbgwhite,       107],
+      [:softpurple,  '0;35;40'],
+      [:hotpants,    '7;34;40'],
+      [:knightrider, '7;30;40'],
+      [:flamingo,    '7;31;47'],
+      [:yeller,      '1;37;43'],
+      [:whiteboard,  '1;30;47'],
+      [:chalkboard,  '1;37;40'],
+      [:led,         '0;32;40'],
+      [:redacted,    '0;30;40'],
+      [:alert,       '1;31;43'],
+      [:error,       '1;37;41'],
+      [:default, '0;39']
+    ].map(&:freeze).freeze
+
+    # Array of attribute keys only
+    ATTRIBUTE_NAMES = ATTRIBUTES.transpose.first
+
+    # Returns true if NA::Color supports the +feature+.
+    #
+    # The feature :clear, that is mixing the clear color attribute into String,
+    # is only supported on ruby implementations, that do *not* already
+    # implement the String#clear method. It's better to use the reset color
+    # attribute instead.
+    def support?(feature)
+      case feature
+      when :clear
+        !String.instance_methods(false).map(&:to_sym).include?(:clear)
+      end
+    end
+
+    # Template coloring
+    class ::String
+      ##
+      ## Extract the longest valid %color name from a string.
+      ##
+      ## Allows %colors to bleed into other text and still
+      ## be recognized, e.g. %greensomething still finds
+      ## %green.
+      ##
+      ## @return     [String] a valid color name
+      ##
+      def validate_color
+        valid_color = nil
+        compiled = ''
+        normalize_color.split('').each do |char|
+          compiled += char
+          valid_color = compiled if Color.attributes.include?(compiled.to_sym) || compiled =~ /^([fb]g?)?#([a-f0-9]{6})$/i
+        end
+
+        valid_color
+      end
+
+      ##
+      ## Normalize a color name, removing underscores,
+      ## replacing "bright" with "bold", and converting
+      ## bgbold to boldbg
+      ##
+      ## @return     [String] Normalized color name
+      ##
+      def normalize_color
+        gsub(/_/, '').sub(/bright/i, 'bold').sub(/bgbold/, 'boldbg')
+      end
+
+      # Get the calculated ANSI color at the end of the
+      # string
+      #
+      # @return     ANSI escape sequence to match color
+      #
+      def last_color_code
+        m = scan(ESCAPE_REGEX)
+
+        em = ['0']
+        fg = nil
+        bg = nil
+        rgbf = nil
+        rgbb = nil
+
+        m.each do |c|
+          case c
+          when '0'
+            em = ['0']
+            fg, bg, rgbf, rgbb = nil
+          when /^[34]8/
+            case c
+            when /^3/
+              fg = nil
+              rgbf = c
+            when /^4/
+              bg = nil
+              rgbb = c
+            end
+          else
+            c.split(/;/).each do |i|
+              x = i.to_i
+              if x <= 9
+                em << x
+              elsif x >= 30 && x <= 39
+                rgbf = nil
+                fg = x
+              elsif x >= 40 && x <= 49
+                rgbb = nil
+                bg = x
+              elsif x >= 90 && x <= 97
+                rgbf = nil
+                fg = x
+              elsif x >= 100 && x <= 107
+                rgbb = nil
+                bg = x
+              end
+            end
+          end
+        end
+
+        escape = "\e[#{em.join(';')}m"
+        escape += "\e[#{rgbb}m" if rgbb
+        escape += "\e[#{rgbf}m" if rgbf
+        escape + "\e[#{[fg, bg].delete_if(&:nil?).join(';')}m"
+      end
+    end
+
+    class << self
+      # Returns true if the coloring function of this module
+      # is switched on, false otherwise.
+      def coloring?
+        @coloring
+      end
+
+      attr_writer :coloring
+
+      ##
+      ## Enables colored output
+      ##
+      ## @example Turn color on or off based on TTY
+      ##   NA::Color.coloring = STDOUT.isatty
+      def coloring
+        @coloring ||= true
+      end
+
+      ##
+      ## Convert a template string to a colored string.
+      ## Colors are specified with single letters inside
+      ## curly braces. Uppercase changes background color.
+      ##
+      ## w: white, k: black, g: green, l: blue, y: yellow, c: cyan,
+      ## m: magenta, r: red, b: bold, u: underline, i: italic,
+      ## x: reset (remove background, color, emphasis)
+      ##
+      ## @example Convert a templated string
+      ##   Color.template('{Rwb}Warning:{x} {w}you look a little {g}ill{x}')
+      ##
+      ## @param      input  [String, Array] The template
+      ##                    string. If this is an array, the
+      ##                    elements will be joined with a
+      ##                    space.
+      ##
+      ## @return     [String] Colorized string
+      ##
+      def template(input)
+        input = input.join(' ') if input.is_a? Array
+        fmt = input.gsub(/%/, '%%')
+        fmt = fmt.gsub(/(?<!\\u)\{(\w+)\}/i) do
+          Regexp.last_match(1).split('').map { |c| "%<#{c}>s" }.join('')
+        end
+
+        colors = { w: white, k: black, g: green, l: blue,
+                   y: yellow, c: cyan, m: magenta, r: red,
+                   W: bgwhite, K: bgblack, G: bggreen, L: bgblue,
+                   Y: bgyellow, C: bgcyan, M: bgmagenta, R: bgred,
+                   d: dark, b: bold, u: underline, i: italic, x: reset }
+
+        format(fmt, colors)
+      end
+    end
+
+    ATTRIBUTES.each do |c, v|
+      new_method = <<-EOSCRIPT
+        # Color string as #{c}
+        def #{c}(string = nil)
+          result = ''
+          result << "\e[#{v}m" if NA::Color.coloring?
+          if block_given?
+            result << yield
+          elsif string.respond_to?(:to_str)
+            result << string.to_str
+          elsif respond_to?(:to_str)
+            result << to_str
+          else
+            return result #only switch on
+          end
+          result << "\e[0m" if NA::Color.coloring?
+          result
+        end
+      EOSCRIPT
+
+      module_eval(new_method)
+
+      next unless c =~ /bold/
+
+      # Accept brightwhite in addition to boldwhite
+      new_method = <<-EOSCRIPT
+        # color string as #{c}
+        def #{c.to_s.sub(/bold/, 'bright')}(string = nil)
+          result = ''
+          result << "\e[#{v}m" if NA::Color.coloring?
+          if block_given?
+            result << yield
+          elsif string.respond_to?(:to_str)
+            result << string.to_str
+          elsif respond_to?(:to_str)
+            result << to_str
+          else
+            return result #only switch on
+          end
+          result << "\e[0m" if NA::Color.coloring?
+          result
+        end
+      EOSCRIPT
+
+      module_eval(new_method)
+    end
+
+    ##
+    ## Generate escape codes for hex colors
+    ##
+    ## @param      hex   [String] The hexadecimal color code
+    ##
+    ## @return     [String] ANSI escape string
+    ##
+    def rgb(hex)
+      is_bg = hex.match(/^bg?#/) ? true : false
+      hex_string = hex.sub(/^([fb]g?)?#/, '')
+
+      parts = hex_string.match(/(?<r>..)(?<g>..)(?<b>..)/)
+      t = []
+      %w[r g b].each do |e|
+        t << parts[e].hex
+      end
+      color =
+      "\e[#{is_bg ? '48' : '38'};2;#{t.join(';')}m"
+    end
+
+    # Regular expression that is used to scan for ANSI-sequences while
+    # uncoloring strings.
+    COLORED_REGEXP = /\e\[(?:(?:[349]|10)[0-7]|[0-9])?m/.freeze
+
+    # Returns an uncolored version of the string, that is all
+    # ANSI-sequences are stripped from the string.
+    def uncolor(string = nil) # :yields:
+      if block_given?
+        yield.to_str.gsub(COLORED_REGEXP, '')
+      elsif string.respond_to?(:to_str)
+        string.to_str.gsub(COLORED_REGEXP, '')
+      elsif respond_to?(:to_str)
+        to_str.gsub(COLORED_REGEXP, '')
+      else
+        ''
+      end
+    end
+
+    # Returns an array of all NA::Color attributes as symbols.
+    def attributes
+      ATTRIBUTE_NAMES
+    end
+    extend self
+  end
+end

data/lib/na/next_action.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+# Next Action methods
+module NA
+  class << self
+    def create_todo(target, basename)
+      File.open(target, 'w') do |f|
+        content = <<~ENDCONTENT
+        Inbox: @inbox
+        #{basename}:
+        \tNew Features:
+        \tIdeas:
+        \tBugs:
+        Archive:
+        Search Definitions:
+        \tTop Priority @search(@priority = 5 and not @done)
+        \tHigh Priority @search(@priority > 3 and not @done)
+        \tMaybe @search(@maybe)
+        \tNext @search(@na and not @done and not project = \"Archive\")
+        ENDCONTENT
+        f.puts(content)
+      end
+      puts NA::Color.template("{y}Created {bw}#{target}{x}")
+    end
+
+    def find_files(depth: 1, extension: 'taskpaper')
+      `find . -name "*.#{extension}" -maxdepth #{depth}`.strip.split("\n")
+    end
+
+    def select_file(files)
+      if TTY::Which.exist?('gum')
+        args = [
+          '--cursor.foreground="151"',
+          '--item.foreground=""'
+        ]
+        `echo #{Shellwords.escape(files.join("\n"))}|#{TTY::Which.which('gum')} choose #{args.join(' ')}`.strip
+      elsif TTY::Which.exist?('fzf')
+        res = choose_from(files, prompt: 'Use which file?')
+        unless res
+          puts 'No file selected, cancelled'
+          Process.exit 1
+        end
+
+        res.strip
+      else
+        reader = TTY::Reader.new
+        puts
+        files.each.with_index do |f, i|
+          puts NA::Color.template(format("{bw}%<idx> 2d{xw}) {y}%<file>s{x}\n", idx: i + 1, file: f))
+        end
+        res = reader.read_line(NA::Color.template('{bw}Use which file? {x}')).strip.to_i
+        files[res - 1]
+      end
+    end
+
+    def add_action(file, action, note = nil)
+      content = IO.read(file)
+      unless content =~ /^[ \t]*Inbox:/i
+        content = "Inbox: @inbox\n#{content}"
+      end
+
+      content.sub!(/^([ \t]*)Inbox:(.*?)$/) do
+        m = Regexp.last_match
+        note = note.nil? ? '' : "\n#{m[1]}\t\t#{note.join('').strip}"
+        "#{m[1]}Inbox:#{m[2]}\n#{m[1]}\t- #{action}#{note}"
+      end
+
+      File.open(file, 'w') { |f| f.puts content }
+
+      puts NA::Color.template("{by}Task added to {bw}#{file}{x}")
+    end
+
+    def output_actions(actions, depth, extension)
+      template = if NA.find_files(depth: depth, extension: extension).count > 1
+                   if depth > 1
+                     '%filename%parent%action'
+                   else
+                     '%project%parent%action'
+                   end
+                 else
+                   '%parent%action'
+                 end
+      puts actions.map { |action| action.pretty(template: { output: template }) }
+    end
+
+    def parse_actions(depth: 1, extension: 'taskpaper', na_tag: 'na', tag: nil, search: nil)
+      actions = []
+      required = []
+      optional = []
+
+      tag&.each do |t|
+        new_rx = " @#{t[:tag]}"
+        new_rx = "#{new_rx}\\(#{t[:value]}\\)" if t[:value]
+
+        optional.push(new_rx)
+        required.push(new_rx) if t[:required]
+      end
+
+      unless search.nil?
+        if search.is_a?(String)
+          optional.push(search)
+          required.push(search)
+        else
+          search.each do |t|
+            new_rx = t[:token].to_s
+
+            optional.push(new_rx)
+            required.push(new_rx) if t[:required]
+          end
+        end
+      end
+
+      na_tag = "@#{na_tag.sub(/^@/, '')}"
+
+      files = find_files(depth: depth, extension: extension)
+      files.each do |file|
+        content = IO.read(file)
+        indent_level = 0
+        parent = []
+        content.split("\n").each do |line|
+          new_action = nil
+          if line =~ /([ \t]*)([^\-]+.*?):/
+            proj = Regexp.last_match(2)
+            indent = line.indent_level
+
+            if indent.zero?
+              parent = [proj]
+            elsif indent <= indent_level
+              parent.slice!(indent_level, parent.count - indent_level)
+              parent.push(proj)
+            elsif indent > indent_level
+              parent.push(proj)
+              indent_level = indent
+            end
+          elsif line =~ /^[ \t]*- / && line !~ / @done/
+            unless optional.empty? && required.empty?
+              next unless line.matches(any: optional, all: required)
+
+            end
+
+            action = line.sub(/^[ \t]*- /, '').sub(/ #{na_tag}/, '')
+            new_action = NA::Action.new(file, File.basename(file, ".#{extension}"), parent.dup, action)
+            actions.push(new_action)
+          end
+        end
+      end
+      actions
+    end
+
+    ##
+    ## Generate a menu of options and allow user selection
+    ##
+    ## @return     [String] The selected option
+    ##
+    ## @param      options   [Array] The options from which to choose
+    ## @param      prompt    [String] The prompt
+    ## @param      multiple  [Boolean] If true, allow multiple selections
+    ## @param      sorted    [Boolean] If true, sort selections alphanumerically
+    ## @param      fzf_args  [Array] Additional fzf arguments
+    ##
+    def choose_from(options, prompt: 'Make a selection: ', multiple: false, sorted: true, fzf_args: [])
+      return nil unless $stdout.isatty
+
+      # fzf_args << '-1' # User is expecting a menu, and even if only one it seves as confirmation
+      default_args = []
+      default_args << %(--prompt="#{prompt}")
+      default_args << "--height=#{options.count + 2}"
+      default_args << '--info=inline'
+      default_args << '--multi' if multiple
+      header = "esc: cancel,#{multiple ? ' tab: multi-select, ctrl-a: select all,' : ''} return: confirm"
+      default_args << %(--header="#{header}")
+      default_args.concat(fzf_args)
+      options.sort! if sorted
+
+      res = `echo #{Shellwords.escape(options.join("\n"))}|#{TTY::Which.which('fzf')} #{default_args.join(' ')}`
+      return false if res.strip.size.zero?
+
+      res
+    end
+  end
+end

data/lib/na/string.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+class ::String
+  def indent_level
+    prefix = match(/(^[ \t]+)/)
+    return 0 if prefix.nil?
+
+    prefix[1].gsub(/  /, "\t").scan(/\t/).count
+  end
+
+  ##
+  ## Colorize @tags with ANSI escapes
+  ##
+  ## @param      color  [String] color (see #Color)
+  ##
+  ## @return     [String] string with @tags highlighted
+  ##
+  def highlight_tags(color: '{m}', value: '{y}', parens: '{m}', last_color: '{g}')
+    tag_color = NA::Color.template(color)
+    paren_color = NA::Color.template(parens)
+    value_color = NA::Color.template(value)
+    gsub(/(\s|m)(@[^ ("']+)(?:(\()(.*?)(\)))?/, "\\1#{tag_color}\\2#{paren_color}\\3#{value_color}\\4#{paren_color}\\5#{last_color}")
+  end
+
+  def matches(any: [], all: [])
+    matches_any(any) && matches_all(all)
+  end
+
+  def matches_any(regexes)
+    regexes.each do |rx|
+      return true if match(Regexp.new(rx, Regexp::IGNORECASE))
+    end
+    false
+  end
+
+  def matches_all(regexes)
+    regexes.each do |rx|
+      return false unless match(Regexp.new(rx, Regexp::IGNORECASE))
+    end
+    true
+  end
+end

data/lib/na/version.rb

@@ -0,0 +1,3 @@
+module Na
+  VERSION = '1.0.0'
+end

data/lib/na.rb

@@ -0,0 +1,11 @@
+require 'na/version.rb'
+
+# Add requires for other files you add to your project here, so
+# you just need to require this one file in your bin file
+require 'shellwords'
+require 'tty-reader'
+require 'tty-which'
+require 'na/colors.rb'
+require 'na/string.rb'
+require 'na/action.rb'
+require 'na/next_action.rb'

data/na.gemspec

@@ -0,0 +1,26 @@
+# Ensure we require the local version and not one we might have installed already
+require File.join([File.dirname(__FILE__),'lib','na','version.rb'])
+spec = Gem::Specification.new do |s|
+  s.name = 'na'
+  s.version = Na::VERSION
+  s.author = 'Brett Terpstra'
+  s.email = 'me@brettterpstra.com'
+  s.homepage = 'https://brettterpstra.com'
+  s.platform = Gem::Platform::RUBY
+  s.summary = 'A command line tool for adding and listing project todos'
+  s.license = 'MIT'
+  s.files = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.strip =~ %r{^((test|spec|features)/|\.git|buildnotes|.*\.taskpaper)} }
+  end
+  s.require_paths << 'lib'
+  s.extra_rdoc_files = ['README.rdoc','na.rdoc']
+  s.rdoc_options << '--title' << 'na' << '--main' << 'README.rdoc' << '-ri'
+  s.bindir = 'bin'
+  s.executables << 'na'
+  s.add_development_dependency('rake','~> 0.9.2')
+  s.add_development_dependency('rdoc', '~> 4.3')
+  s.add_development_dependency('minitest', '~> 5.14')
+  s.add_runtime_dependency('gli','~> 2.21.0')
+  s.add_runtime_dependency('tty-reader', '~> 0.9', '>= 0.9.0')
+  s.add_runtime_dependency('tty-which', '~> 0.5', '>= 0.5.0')
+end