doing 1.0.91 → 2.0.3.pre

data/lib/doing/plugins/export/template_export.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+# title: Template Export
+# description: Default export option using configured template placeholders
+# author: Brett Terpstra
+# url: https://brettterpstra.com
+module Doing
+  class TemplateExport
+    include Doing::Color
+    include Doing::Util
+
+    def self.settings
+      {
+        trigger: 'template|doing'
+      }
+    end
+
+    def self.render(wwid, items, variables: {})
+      return if items.nil?
+
+      opt = variables[:options]
+
+      out = ''
+      items.each do |item|
+        if opt[:highlight] && item.title =~ /@#{wwid.config['marker_tag']}\b/i
+          flag = Doing::Color.send(wwid.config['marker_color'])
+          reset = Doing::Color.default
+        else
+          flag = ''
+          reset = ''
+        end
+
+        if (!item.note.empty?) && wwid.config['include_notes']
+          note = item.note.map(&:strip).delete_if(&:empty?)
+          note.map! { |line| "#{line.sub(/^\t*/, '')}  " }
+
+          if opt[:wrap_width]&.positive?
+            width = opt[:wrap_width]
+            note.map! { |line| line.chomp.gsub(/(.{1,#{width}})(\s+|\Z)/, "\\1\n") }
+            note = note.join("\n").split(/\n/).delete_if(&:empty?)
+          end
+        else
+          note = []
+        end
+        output = opt[:template].dup
+
+        output.gsub!(/%[a-z]+/) do |m|
+          if Doing::Color.respond_to?(m.sub(/^%/, ''))
+            Doing::Color.send(m.sub(/^%/, ''))
+          else
+            m
+          end
+        end
+
+        output.sub!(/%(\d+)?date/) do
+          pad = Regexp.last_match(1).to_i
+          format("%#{pad}s", item.date.strftime(opt[:format]))
+        end
+
+        interval = wwid.get_interval(item, record: true) if opt[:times]
+
+        interval ||= ''
+        output.sub!(/%interval/, interval)
+
+        output.sub!(/%(\d+)?shortdate/) do
+          pad = Regexp.last_match(1) || 13
+          format("%#{pad}s", item.date.relative_date)
+        end
+
+        output.sub!(/%section/, item.section) if item.section
+
+        title_offset = Doing::Color.uncolor(output).match(/%(-?\d+)?([ _t]\d+)?title/).begin(0)
+        output.sub!(/%(-?\d+)?(([ _t])(\d+))?title(.*?)$/) do
+          m = Regexp.last_match
+          pad = m[1].to_i
+          indent = ''
+          if m[2]
+            char = m[3] =~ /t/ ? "\t" : " "
+            indent = char * m[4].to_i
+          end
+          after = m[5]
+          if opt[:wrap_width]&.positive? || pad.positive?
+            width = pad.positive? ? pad : opt[:wrap_width]
+            item.title.wrap(width, pad: pad, indent: indent, offset: title_offset, prefix: flag, after: after, reset: reset)
+            # flag + item.title.gsub(/(.{#{opt[:wrap_width]}})(?=\s+|\Z)/, "\\1\n ").sub(/\s*$/, '') + reset
+          else
+            format("%s%#{pad}s%s%s", flag, item.title.sub(/\s*$/, ''), reset, after)
+          end
+        end
+
+        # output.sub!(/(?i-m)^([\s\S]*?)(%(?:[io]d|(?:\^[\s\S])?(?:(?:[ _t]|[^a-z0-9])?\d+)?(?:[\s\S][ _t]?)?)?note)([\s\S]*?)$/, '\1\3\2')
+        if opt[:tags_color]
+          output.highlight_tags!(opt[:tags_color])
+        end
+
+        if note.empty?
+          output.gsub!(/%([io]d|(\^.)?(([ _t]|[^a-z0-9])?\d+)?(.[ _t]?)?)?note/, '')
+        else
+          output.sub!(/%note/, "\n#{note.map { |l| "\t#{l.strip}  " }.join("\n")}")
+          output.sub!(/%idnote/, "\n#{note.map { |l| "\t\t#{l.strip}  " }.join("\n")}")
+          output.sub!(/%odnote/, "\n#{note.map { |l| "#{l.strip}  " }.join("\n")}")
+          output.sub!(/(?mi)%(?:\^(?<mchar>.))?(?:(?<ichar>[ _t]|[^a-z0-9])?(?<icount>\d+))?(?<prefix>.[ _t]?)?note/) do
+            m = Regexp.last_match
+            mark = m['mchar'] || ''
+            indent = if m['ichar']
+                       char = m['ichar'] =~ /t/ ? "\t" : ' '
+                       char * m['icount'].to_i
+                     else
+                       ''
+                     end
+            prefix = m['prefix'] || ''
+            "\n#{note.map { |l| "#{mark}#{indent}#{prefix}#{l.strip}  " }.join("\n")}"
+          end
+          output.sub!(/%chompnote/) do |_m|
+            chomp_note = note.map do |l|
+              l.gsub(/\n+/, ' ').gsub(/(^\s*|\s*$)/, '').gsub(/\s+/, ' ')
+            end
+            chomp_note.join(' ')
+          end
+        end
+
+        output.gsub!(/%hr(_under)?/) do |_m|
+          o = ''
+          `tput cols`.to_i.times do
+            o += Regexp.last_match(1).nil? ? '-' : '_'
+          end
+          o
+        end
+        output.gsub!(/%n/, "\n")
+        output.gsub!(/%t/, "\t")
+
+        out += "#{output}\n"
+      end
+      # Doing.logger.debug('Template Export:', "#{items.count} items output to template #{opt[:template]}")
+      out += wwid.tag_times(format: :text, sort_by_name: opt[:sort_tags], sort_order: opt[:tag_order]) if opt[:totals]
+      out
+    end
+
+    Doing::Plugins.register ['template', 'doing'], :export, self
+  end
+end

data/lib/doing/plugins/import/calendar_import.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+# title: Calendar.app Import
+# description: Import entries from a Calendar.app calendar
+# author: Brett Terpstra
+# url: https://brettterpstra.com
+require 'json'
+
+module Doing
+  ##
+  ## @brief      Plugin for importing from Calendar.app on macOS
+  ##
+  class CalendarImport
+    include Doing::Util
+
+    def self.settings
+      {
+        trigger: 'i?cal(?:endar)?'
+      }
+    end
+
+    def self.import(wwid, _path, options: {})
+      limit_start = options[:start].to_i
+      limit_end = options[:end].to_i
+
+      section = options[:section] || wwid.config['current_section']
+      options[:no_overlap] ||= false
+      options[:autotag] ||= wwid.auto_tag
+
+      wwid.add_section(section) unless wwid.content.key?(section)
+
+      tags = options[:tag] ? options[:tag].split(/[ ,]+/).map { |t| t.sub(/^@?/, '') } : []
+      prefix = options[:prefix] || '[Calendar.app]'
+
+      script = File.join(File.dirname(__FILE__), 'cal_to_json.scpt')
+      res = `/usr/bin/osascript "#{script}" #{limit_start} #{limit_end}`.strip
+      data = JSON.parse(res)
+
+      new_items = []
+      data.each do |entry|
+        # Only process entries with a start and end date
+        next unless entry.key?('start') && entry.key?('end')
+
+        # Round down seconds and convert UTC to local time
+        start_time = Time.parse(entry['start']).getlocal
+        end_time = Time.parse(entry['end']).getlocal
+        next unless start_time && end_time
+
+        title = "#{prefix} "
+        title += entry['name']
+        tags.each do |tag|
+          if title =~ /\b#{tag}\b/i
+            title.sub!(/\b#{tag}\b/i, "@#{tag}")
+          else
+            title += " @#{tag}"
+          end
+        end
+        title = wwid.autotag(title) if options[:autotag]
+        title += " @done(#{end_time.strftime('%Y-%m-%d %H:%M')})"
+        title.gsub!(/ +/, ' ')
+        title.strip!
+        new_entry = { 'title' => title, 'date' => start_time, 'section' => section }
+        new_entry.note = entry['notes'].split(/\n/).map(&:chomp) if entry.key?('notes')
+        new_items.push(new_entry)
+      end
+      total = new_items.count
+      new_items = wwid.dedup(new_items, options[:no_overlap])
+      dups = total - new_items.count
+      Doing.logger.info(%(Skipped #{dups} items with overlapping times)) if dups.positive?
+      wwid.content[section][:items].concat(new_items)
+      Doing.logger.info(%(Imported #{new_items.count} items to #{section}))
+    end
+
+    Doing::Plugins.register 'calendar', :import, self
+  end
+end

data/lib/doing/plugins/import/doing_import.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+# title: Doing Format Import
+# description: Import entries from a Doing-formatted file
+# author: Brett Terpstra
+# url: https://brettterpstra.com
+module Doing
+  class DoingImport
+    include Doing::Util
+
+    def self.settings
+      {
+        trigger: 'doing'
+      }
+    end
+
+    ##
+    ## @brief      Imports a Doing file
+    ##
+    ## @param      wwid     WWID object
+    ## @param      path     (String) Path to Doing file
+    ## @param      options  (Hash) Additional Options
+    ##
+    ## @return     Nothing
+    ##
+    def self.import(wwid, path, options: {})
+      exit_now! 'Path to Doing file required' if path.nil?
+
+      exit_now! 'File not found' unless File.exist?(File.expand_path(path))
+
+      options[:no_overlap] ||= false
+      options[:autotag] ||= wwid.auto_tag
+
+      tags = options[:tag] ? options[:tag].split(/[ ,]+/).map { |t| t.sub(/^@?/, '') } : []
+      prefix = options[:prefix] || ''
+
+      @old_items = []
+
+      wwid.content.each { |_, v| @old_items.concat(v[:items]) }
+
+      new_items = read_doing_file(path)
+
+      if options[:date_filter]
+        new_items = wwid.filter_items(new_items, opt: { count: 0, date_filter: options[:date_filter] })
+      end
+
+      if options[:before] || options[:after]
+        new_items = wwid.filter_items(new_items, opt: { count: 0, before: options[:before], after: options[:after] })
+      end
+
+      imported = []
+
+      new_items.each do |item|
+        next if duplicate?(item)
+
+        title = "#{prefix} #{item.title}"
+        tags.each do |tag|
+          if title =~ /\b#{tag}\b/i
+            title.sub!(/\b#{tag}\b/i, "@#{tag}")
+          else
+            title += " @#{tag}"
+          end
+        end
+        title = wwid.autotag(title) if options[:autotag]
+        title.gsub!(/ +/, ' ')
+        title.strip!
+        section = options[:section] || item.section
+        section ||= wwid.config['current_section']
+
+        new_item = Item.new(item.date, title, section)
+        new_item.note = item.note
+
+        imported.push(new_item)
+      end
+
+      dups = new_items.count - imported.count
+      Doing.logger.info('Skipped:', %(#{dups} duplicate items)) if dups.positive?
+
+      imported = wwid.dedup(imported, !options[:overlap])
+      overlaps = new_items.count - imported.count - dups
+      Doing.logger.debug('Skipped:', "#{overlaps} items with overlapping times") if overlaps.positive?
+
+      imported.each do |item|
+        wwid.add_section(item.section) unless wwid.content.key?(item.section)
+        wwid.content[item.section][:items].push(item)
+      end
+
+      Doing.logger.info('Imported:', "#{imported.count} items")
+    end
+
+    def self.duplicate?(item)
+      @old_items.each do |oi|
+        return true if item.equal?(oi)
+      end
+
+      false
+    end
+
+    def self.read_doing_file(path)
+      doing_file = File.expand_path(path)
+
+      return nil unless File.exist?(doing_file) && File.file?(doing_file) && File.stat(doing_file).size.positive?
+
+      input = IO.read(doing_file)
+      input = input.force_encoding('utf-8') if input.respond_to? :force_encoding
+
+      lines = input.split(/[\n\r]/)
+      current = 0
+
+      items = []
+      section = ''
+
+      lines.each do |line|
+        next if line =~ /^\s*$/
+
+        case line
+        when /^(\S[\S ]+):\s*(@\S+\s*)*$/
+          section = Regexp.last_match(1)
+          current = 0
+        when /^\s*- (\d{4}-\d\d-\d\d \d\d:\d\d) \| (.*)/
+          date = Regexp.last_match(1).strip
+          title = Regexp.last_match(2).strip
+          item = Item.new(date, title, section)
+          items.push(item)
+          current += 1
+        when /^\S/
+          next
+        else
+          next if current.zero?
+
+          prev_item = items[current - 1]
+          prev_item.note = Note.new unless prev_item.note
+
+          prev_item.note.add(line)
+          # end
+        end
+      end
+
+      items
+    end
+
+    Doing::Plugins.register 'doing', :import, self
+  end
+end

data/lib/doing/plugins/import/timing_import.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+# title: Timing.app Import
+# description: Import entries from a Timing.app report (JSON)
+# author: Brett Terpstra
+# url: https://brettterpstra.com
+module Doing
+  class TimingImport
+    include Doing::Util
+
+    def self.settings
+      {
+        trigger: 'tim(?:ing)?'
+      }
+    end
+
+    ##
+    ## @brief      Imports a Timing report
+    ##
+    ## @param      path     (String) Path to JSON report file
+    ## @param      options      (Hash) Additional Options
+    ##
+    def self.import(wwid, path, options: {})
+      exit_now! 'Path to JSON report required' if path.nil?
+      section = options[:section] || wwid.config['current_section']
+      options[:no_overlap] ||= false
+      options[:autotag] ||= wwid.auto_tag
+      wwid.add_section(section) unless wwid.content.key?(section)
+
+      add_tags = options[:tag] ? options[:tag].split(/[ ,]+/).map { |t| t.sub(/^@?/, '') } : []
+      prefix = options[:prefix] || '[Timing.app]'
+      exit_now! 'File not found' unless File.exist?(File.expand_path(path))
+
+      data = JSON.parse(IO.read(File.expand_path(path)))
+      new_items = []
+      data.each do |entry|
+        # Only process task entries
+        next if entry.key?('activityType') && entry['activityType'] != 'Task'
+        # Only process entries with a start and end date
+        next unless entry.key?('startDate') && entry.key?('endDate')
+
+        # Round down seconds and convert UTC to local time
+        start_time = Time.parse(entry['startDate'].sub(/:\d\dZ$/, ':00Z')).getlocal
+        end_time = Time.parse(entry['endDate'].sub(/:\d\dZ$/, ':00Z')).getlocal
+        next unless start_time && end_time
+
+        tags = entry['project'].split(/ ▸ /).map { |proj| proj.gsub(/[^a-z0-9]+/i, '').downcase }
+        tags.concat(add_tags)
+        title = "#{prefix} "
+        title += entry.key?('activityTitle') && entry['activityTitle'] != '(Untitled Task)' ? entry['activityTitle'] : 'Working on'
+        tags.each do |tag|
+          if title =~ /\b#{tag}\b/i
+            title.sub!(/\b#{tag}\b/i, "@#{tag}")
+          else
+            title += " @#{tag}"
+          end
+        end
+        title = wwid.autotag(title) if options[:autotag]
+        title += " @done(#{end_time.strftime('%Y-%m-%d %H:%M')})"
+        title.gsub!(/ +/, ' ')
+        title.strip!
+        new_item = Item.new(start_time, title, section)
+        new_item.note.add(entry['notes']) if entry.key?('notes')
+        new_items.push(new_item)
+      end
+      total = new_items.count
+      skipped = data.count - total
+      Doing.logger.debug('Skipped:' , %(#{skipped} items, invalid type or no time interval)) if skipped.positive?
+      new_items = wwid.dedup(new_items, options[:no_overlap])
+      dups = total - new_items.count
+      Doing.logger.debug('Skipped:' , %(#{dups} items with overlapping times)) if dups.positive?
+      wwid.content[section][:items].concat(new_items)
+      Doing.logger.info('Imported:', %(#{new_items.count} items to #{section}))
+    end
+
+    Doing::Plugins.register 'timing', :import, self
+  end
+end