na 1.2.35 → 1.2.38

data/lib/na/action.rb

@@ -18,6 +18,32 @@ module NA
       @note = note
     end
 
+    def process(priority: 0, finish: false, add_tag: [], remove_tag: [], note: [])
+      string = @action.dup
+
+      if priority&.positive?
+        string.gsub!(/(?<=\A| )@priority\(\d+\)/, '').strip!
+        string += " @priority(#{priority})"
+      end
+
+      remove_tag.each do |tag|
+        string.gsub!(/(?<=\A| )@#{tag.gsub(/([()*?])/, '\\\\1')}(\(.*?\))?/, '')
+        string.strip!
+      end
+
+      add_tag.each do |tag|
+        string.gsub!(/(?<=\A| )@#{tag.gsub(/([()*?])/, '\\\\1')}(\(.*?\))?/, '')
+        string.strip!
+        string += " @#{tag}"
+      end
+
+      string = "#{string.strip} @done(#{Time.now.strftime('%Y-%m-%d %H:%M')})" if finish && string !~ /(?<=\A| )@done/
+
+      @action = string
+      @action.expand_date_tags
+      @note = note unless note.empty?
+    end
+
     def to_s
       note = if @note.count.positive?
                "\n#{@note.join("\n")}"
@@ -48,25 +74,14 @@ module NA
     ## @param      notes      [Boolean] Include notes
     ##
     def pretty(extension: 'taskpaper', template: {}, regexes: [], notes: false)
-      # Default colorization, can be overridden with full or partial template variable
-      default_template = {
-        file: '{xbk}',
-        parent: '{c}',
-        parent_divider: '{xw}/',
-        action: '{bg}',
-        project: '{xbk}',
-        tags: '{m}',
-        value_parens: '{m}',
-        values: '{y}',
-        output: '%filename%parents| %action',
-        note: '{dw}'
-      }
-      template = default_template.merge(template)
+      theme = NA::Theme.load_theme
+      template = theme.merge(template)
+
       # Create the hierarchical parent string
       parents = @parent.map do |par|
-        NA::Color.template("#{template[:parent]}#{par}")
+        NA::Color.template("{x}#{template[:parent]}#{par}")
       end.join(NA::Color.template(template[:parent_divider]))
-      parents = "{dc}[{x}#{parents}{dc}]{x} "
+      parents = "#{NA.theme[:bracket]}[#{NA.theme[:error]}#{parents}#{NA.theme[:bracket]}]{x} "
 
       # Create the project string
       project = NA::Color.template("#{template[:project]}#{@project}{x} ")
@@ -75,7 +90,7 @@ module NA
       file = @file.sub(%r{^\./}, '').sub(/#{ENV['HOME']}/, '~')
       file = file.sub(/\.#{extension}$/, '')
       # colorize the basename
-      file = file.sub(/#{File.basename(@file, ".#{extension}")}$/, "{dw}#{File.basename(@file, ".#{extension}")}{x}")
+      file = file.highlight_filename
       file_tpl = "#{template[:file]}#{file} {x}"
       filename = NA::Color.template(file_tpl)
 
@@ -174,13 +189,13 @@ module NA
         tag_date = Time.parse(tag_val)
         date = Chronic.parse(val)
 
+        raise ArgumentError if date.nil?
+
         unless val =~ /(\d:\d|a[mp]|now)/i
           tag_date = Time.parse(tag_date.strftime('%Y-%m-%d 12:00'))
           date = Time.parse(date.strftime('%Y-%m-%d 12:00'))
         end
 
-        puts "Comparing #{tag_date} #{tag[:comp]} #{date}" if NA.verbose
-
         case tag[:comp]
         when /^>$/
           tag_date > date
@@ -201,7 +216,7 @@ module NA
         else
           false
         end
-      rescue
+      rescue ArgumentError
         case tag[:comp]
         when /^>$/
           tag_val.to_f > val.to_f
@@ -213,12 +228,14 @@ module NA
           tag_val.to_f >= val.to_f
         when /^==?$/
           tag_val =~ /^#{val.wildcard_to_rx}$/
+        when /^=~$/
+          tag_val =~ Regexp.new(val, Regexp::IGNORECASE)
         when /^\$=$/
           tag_val =~ /#{val.wildcard_to_rx}$/i
         when /^\*=$/
-          tag_val =~ /#{val.wildcard_to_rx}/i
+          tag_val =~ /.*?#{val.wildcard_to_rx}.*?/i
         when /^\^=$/
-          tag_val =~ /^#{val.wildcard_to_rx}/
+          tag_val =~ /^#{val.wildcard_to_rx}/i
         else
           false
         end

data/lib/na/actions.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module NA
+  # Actions controller
+  class Actions < Array
+    def initialize(actions = [])
+      super
+      concat(actions)
+    end
+
+    ##
+    ## Pretty print a list of actions
+    ##
+    ## @param      actions  [Array] The actions
+    ## @param      depth    [Number] The depth
+    ## @param      files    [Array] The files actions originally came from
+    ## @param      regexes  [Array] The regexes used to gather actions
+    ##
+    def output(depth, files: nil, regexes: [], notes: false, nest: false, nest_projects: false)
+      return if files.nil?
+
+      if nest
+        template = NA.theme[:templates][:default]
+
+        parent_files = {}
+        out = []
+
+        if nest_projects
+          each do |action|
+            if parent_files.key?(action.file)
+              parent_files[action.file].push(action)
+            else
+              parent_files[action.file] = [action]
+            end
+          end
+
+          parent_files.each do |file, acts|
+            projects = NA.project_hierarchy(acts)
+            out.push("#{file.sub(%r{^./}, '').shorten_path}:")
+            out.concat(NA.output_children(projects, 0))
+          end
+        else
+          template = NA.theme[:templates][:default]
+
+          each do |action|
+            if parent_files.key?(action.file)
+              parent_files[action.file].push(action)
+            else
+              parent_files[action.file] = [action]
+            end
+          end
+
+          parent_files.each do |k, v|
+            out.push("#{k.sub(%r{^\./}, '')}:")
+            v.each do |a|
+              out.push("\t- [#{a.parent.join('/')}] #{a.action}")
+              out.push("\t\t#{a.note.join("\n\t\t")}") unless a.note.empty?
+            end
+          end
+        end
+        NA::Pager.page out.join("\n")
+      else
+        template = if files.count.positive?
+                     if files.count == 1
+                       NA.theme[:templates][:single_file]
+                     else
+                       NA.theme[:templates][:multi_file]
+                     end
+                   elsif NA.find_files(depth: depth).count > 1
+                     if depth > 1
+                       NA.theme[:templates][:multi_file]
+                     else
+                       NA.theme[:templates][:single_file]
+                     end
+                   else
+                     NA.theme[:templates][:default]
+                   end
+        template += '%note' if notes
+
+        files.map { |f| NA.notify(f, debug: true) } if files
+
+        output = map { |action| action.pretty(template: { output: template }, regexes: regexes, notes: notes) }
+        NA::Pager.page(output.join("\n"))
+      end
+    end
+  end
+end

data/lib/na/colors.rb

@@ -5,7 +5,7 @@ module NA
   # Terminal output color functions.
   module Color
     # Regexp to match excape sequences
-    ESCAPE_REGEX = /(?<=\[)(?:(?:(?:[349]|10)[0-9]|[0-9])?;?)+(?=m)/.freeze
+    ESCAPE_REGEX = /(?<=\[)(?:(?:(?:[349]|10)[0-9]|[0-9])?;?)+(?=m)/
 
     # All available color names. Available as methods and string extensions.
     #
@@ -214,9 +214,15 @@ module NA
       ## m: magenta, r: red, b: bold, u: underline, i: italic,
       ## x: reset (remove background, color, emphasis)
       ##
+      ## Also accepts {#RGB} and {#RRGGBB} strings. Put a b before
+      ## the hash to make it a background color
+      ##
       ## @example Convert a templated string
       ##   Color.template('{Rwb}Warning:{x} {w}you look a little {g}ill{x}')
       ##
+      ## @example Convert using RGB colors
+      ##   Color.template('{#f0a}This is an RGB color')
+      ##
       ## @param      input  [String, Array] The template
       ##                    string. If this is an array, the
       ##                    elements will be joined with a
@@ -228,6 +234,11 @@ module NA
         input = input.join(' ') if input.is_a? Array
         return input.gsub(/(?<!\\)\{(\w+)\}/i, '') unless NA::Color.coloring?
 
+        input = input.gsub(/(?<!\\)\{((?:[fb]g?)?#[a-f0-9]{3,6})\}/i) do
+                  hex = Regexp.last_match(1)
+                  rgb(hex)
+                end
+
         fmt = input.gsub(/%/, '%%')
         fmt = fmt.gsub(/(?<!\\)\{(\w+)\}/i) do
           Regexp.last_match(1).split('').map { |c| "%<#{c}>s" }.join('')
@@ -301,6 +312,17 @@ module NA
       is_bg = hex.match(/^bg?#/) ? true : false
       hex_string = hex.sub(/^([fb]g?)?#/, '')
 
+      if hex_string.length == 3
+        parts = hex_string.match(/(?<r>.)(?<g>.)(?<b>.)/)
+
+        t = []
+        %w[r g b].each do |e|
+          t << parts[e]
+          t << parts[e]
+        end
+        hex_string = t.join('')
+      end
+
       parts = hex_string.match(/(?<r>..)(?<g>..)(?<b>..)/)
       t = []
       %w[r g b].each do |e|

data/lib/na/editor.rb

@@ -0,0 +1,125 @@
+module NA
+  module Editor
+    class << self
+      def default_editor(prefer_git_editor: true)
+        if prefer_git_editor
+          editor ||= ENV['NA_EDITOR'] || ENV['GIT_EDITOR'] || ENV['EDITOR']
+        else
+          editor ||= ENV['NA_EDITOR'] || ENV['EDITOR'] || ENV['GIT_EDITOR']
+        end
+
+        return editor if editor&.good? && TTY::Which.exist?(editor)
+
+        NA.notify("No EDITOR environment variable, testing available editors", debug: true)
+        editors = %w[vim vi code subl mate mvim nano emacs]
+        editors.each do |ed|
+          try = TTY::Which.which(ed)
+          if try
+            NA.notify("Using editor #{try}", debug: true)
+            return try
+          end
+        end
+
+        NA.notify("#{NA.theme[:error]}No editor found", exit_code: 5)
+
+        nil
+      end
+
+      def editor_with_args
+        args_for_editor(default_editor)
+      end
+
+      def args_for_editor(editor)
+        return editor if editor =~ /-\S/
+
+        args = case editor
+               when /^(subl|code|mate)$/
+                 ['-w']
+               when /^(vim|mvim)$/
+                 ['-f']
+               else
+                 []
+               end
+        "#{editor} #{args.join(' ')}"
+      end
+
+      ##
+      ## Create a process for an editor and wait for the file handle to return
+      ##
+      ## @param      input  [String] Text input for editor
+      ##
+      def fork_editor(input = '', message: :default)
+        # raise NonInteractive, 'Non-interactive terminal' unless $stdout.isatty || ENV['DOING_EDITOR_TEST']
+
+        NA.notify("#{NA.theme[:error]}No EDITOR variable defined in environment", exit_code: 5) if default_editor.nil?
+
+        tmpfile = Tempfile.new(['na_temp', '.na'])
+
+        File.open(tmpfile.path, 'w+') do |f|
+          f.puts input
+          unless message.nil?
+            f.puts message == :default ? '# First line is the action, lines after are added as a note' : message
+          end
+        end
+
+        pid = Process.fork { system("#{editor_with_args} #{tmpfile.path}") }
+
+        trap('INT') do
+          begin
+            Process.kill(9, pid)
+          rescue StandardError
+            Errno::ESRCH
+          end
+          tmpfile.unlink
+          tmpfile.close!
+          exit 0
+        end
+
+        Process.wait(pid)
+
+        begin
+          if $?.exitstatus == 0
+            input = IO.read(tmpfile.path)
+          else
+            exit_now! 'Cancelled'
+          end
+        ensure
+          tmpfile.close
+          tmpfile.unlink
+        end
+
+        input.split(/\n/).delete_if(&:ignore?).join("\n")
+      end
+
+      ##
+      ## Takes a multi-line string and formats it as an entry
+      ##
+      ## @param      input  [String] The string to parse
+      ##
+      ## @return     [Array] [[String]title, [Note]note]
+      ##
+      def format_input(input)
+        NA.notify("#{NA.theme[:error]}No content in entry", exit_code: 1) if input.nil? || input.strip.empty?
+
+        input_lines = input.split(/[\n\r]+/).delete_if(&:ignore?)
+        title = input_lines[0]&.strip
+        NA.notify("#{NA.theme[:error]}No content in first line", exit_code: 1) if title.nil? || title.strip.empty?
+
+        title.expand_date_tags
+
+        note = if input_lines.length > 1
+                 input_lines[1..-1]
+               else
+                 []
+               end
+
+        unless note.empty?
+          note.map!(&:strip)
+          note.delete_if { |l| l =~ /^\s*$/ || l =~ /^#/ }
+        end
+
+        [title, note]
+      end
+    end
+  end
+end

data/lib/na/hash.rb

@@ -4,4 +4,35 @@ class ::Hash
   def symbolize_keys
     each_with_object({}) { |(k, v), hsh| hsh[k.to_sym] = v.is_a?(Hash) ? v.symbolize_keys : v }
   end
+
+  ##
+  ## 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