doing 1.0.92 → 2.0.5.pre

data/lib/doing/plugin_manager.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+module Doing
+  # Plugin handling
+  module Plugins
+    class << self
+      def user_home
+        @user_home ||= Util.user_home
+      end
+
+      def plugins
+        @plugins ||= {
+          import: {},
+          export: {}
+        }
+      end
+
+      ##
+      # Load plugins from plugins folder
+      #
+      def load_plugins(add_dir = nil)
+        plugins_path(add_dir).each do |plugin_search_path|
+          Dir.glob(File.join(plugin_search_path, '**', '*.rb')).sort.each do |plugin|
+            require plugin
+          end
+        end
+
+        plugins
+      end
+
+      # Public: Setup the plugin search path
+      #
+      # Returns an Array of plugin search paths
+      def plugins_path(add_dir = nil)
+        paths = Array(File.join(File.dirname(__FILE__), 'plugins'))
+        paths << File.join(add_dir) if add_dir
+        paths.map { |d| File.expand_path(d) }
+      end
+
+      ##
+      # Register a plugin
+      #
+      # param: +[String|Array]+ title  The name of the plugin (can be an array of names)
+      #
+      # param: +type+ The plugin type (:import, :export)
+      #
+      # param: +klass+ The class responding to :render or :import
+      #
+      #
+      # returns: Success boolean
+      #
+      def register(title, type, klass)
+        type = validate_plugin(title, type, klass)
+        return unless type
+
+        if title.is_a?(Array)
+          title.each { |t| register(t, type, klass) }
+          return
+        end
+
+        settings = if klass.respond_to? :settings
+                     klass.settings
+                   else
+                     { trigger: title.normalize_trigger, config: {} }
+                   end
+
+        plugins[type] ||= {}
+        plugins[type][title] = {
+          trigger: settings[:trigger].normalize_trigger || title.normalize_trigger,
+          class: klass,
+          templates: settings[:templates] || nil,
+          config: settings[:config] || {}
+        }
+
+        return unless ENV['DOING_PLUGIN_DEBUG']
+
+        Doing.logger.debug('Plugin Manager:', "Registered #{type} plugin \"#{title}\"")
+      end
+
+      def validate_plugin(title, type, klass)
+        type = valid_type(type)
+        if type == :import && !klass.respond_to?(:import)
+          raise Errors::PluginUncallable.new('Import plugins must respond to :import', type: type, plugin: title)
+        end
+
+        if type == :export && !klass.respond_to?(:render)
+          raise Errors::PluginUncallable.new('Export plugins must respond to :render', type: type, plugin: title)
+        end
+
+        type
+      end
+
+      def valid_type(type, default: nil)
+        type ||= default
+
+        t = type.to_s
+        type = case t
+               when /^i(m(p(o(r(t)?)?)?)?)?$/
+                 :import
+               when /^e(x(p(o(r(t)?)?)?)?)?$/
+                 :export
+               else
+                 raise Errors::InvalidPluginType, 'Invalid plugin type'
+               end
+
+        type.to_sym
+      end
+
+      ##
+      ## @brief      List available plugins to stdout
+      ##
+      ## @param      options  { type, separator }
+      ##
+      def list_plugins(options = {})
+        separator = options[:column] ? "\n" : "\t"
+        type = options[:type].nil? || options[:type] =~ /all/i ? 'all' : [valid_type(options[:type])]
+
+        case type
+        when :import
+          puts plugin_names(type: :import, separator: separator)
+        when :export
+          puts plugin_names(type: :export, separator: separator)
+        else
+          print 'Import plugins: '
+          puts plugin_names(type: :import, separator: ', ')
+          print 'Export plugins: '
+          puts plugin_names(type: :export, separator: ', ')
+        end
+      end
+
+      ##
+      ## @brief      Return array of available plugin names
+      ##
+      ## @param      type  Plugin type (:import, :export)
+      ##
+      ## @returns    [Array<String>] plugin names
+      ##
+      def available_plugins(type: :export)
+        type = valid_type(type)
+        plugins[type].keys.sort
+      end
+
+      ##
+      ## @brief      Return string version of plugin names
+      ##
+      ## @param      type       Plugin type (:import, :export)
+      ## @param      separator  The separator to join names with
+      ##
+      ## @return     [String]   Plugin names
+      ##
+      def plugin_names(type: :export, separator: '|')
+        type = valid_type(type)
+        available_plugins(type: type).join(separator)
+      end
+
+      ##
+      ## @brief      Return a regular expression of all
+      ##             plugin triggers for type
+      ##
+      ## @param      type  The type :import or :export
+      ##
+      def plugin_regex(type: :export)
+        type = valid_type(type)
+        pattern = []
+        plugins[type].each do |_, options|
+          pattern << options[:trigger].normalize_trigger
+        end
+        Regexp.new("^(?:#{pattern.join('|')})$", true)
+      end
+
+      def plugin_templates(type: :export)
+        type = valid_type(type)
+        templates = []
+        plugs = plugins[type].clone
+        plugs.delete_if { |_t, o| o[:templates].nil? }.each do |_, options|
+          options[:templates].each do |t|
+            templates << t[:name]
+          end
+        end
+
+        templates
+      end
+
+      def template_regex(type: :export)
+        type = valid_type(type)
+        pattern = []
+        plugs = plugins[type].clone
+        plugs.delete_if { |_t, o| o[:templates].nil? }.each do |_, options|
+          options[:templates].each do |t|
+            pattern << t[:trigger].normalize_trigger
+          end
+        end
+        Regexp.new("^(?:#{pattern.join('|')})$", true)
+      end
+
+      def template_for_trigger(trigger, type: :export)
+        type = valid_type(type)
+        plugs = plugins[type].clone
+        plugs.delete_if { |_t, o| o[:templates].nil? }.each do |_, options|
+          options[:templates].each do |t|
+            return options[:class].template(trigger) if trigger =~ /^(?:#{t[:trigger].normalize_trigger})$/
+          end
+        end
+        raise Errors::InvalidArgument, "No template type matched \"#{trigger}\""
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# title: CSV Export
+# description: Export CSV formatted data with header row
+# author: Brett Terpstra
+# url: https://brettterpstra.com
+module Doing
+  ##
+  ## @brief      CSV Export
+  ##
+  class CSVExport
+    include Doing::Util
+
+    def self.settings
+      {
+        trigger: 'csv'
+      }
+    end
+
+    def self.render(wwid, items, variables: {})
+      return if items.nil?
+
+      opt = variables[:options]
+
+      output = [CSV.generate_line(%w[start end title note timer section])]
+      items.each do |i|
+        note = format_note(i.note)
+        end_date = i.end_date
+        interval = end_date && opt[:times] ? wwid.get_interval(i, formatted: false) : 0
+        output.push(CSV.generate_line([i.date, end_date, i.title, note, interval, i.section]))
+      end
+      Doing.logger.debug('CSV Export:', "#{items.count} items output to CSV")
+      output.join('')
+    end
+
+    def self.format_note(note)
+      out = ''
+      if note
+        arr = note.map(&:strip).delete_if { |e| e =~ /^\s*$/ }
+        out = arr.join("\n") unless arr.empty?
+      end
+
+      out
+    end
+
+    Doing::Plugins.register 'csv', :export, self
+  end
+end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+# title: HTML Export
+# description: Export styled HTML view of data
+# author: Brett Terpstra
+# url: https://brettterpstra.com
+module Doing
+  class HTMLExport
+    include Doing::Util
+
+    def self.settings
+      {
+        trigger: 'html?|web(?:page)?',
+        templates: [
+          { name: 'haml', trigger: 'h[ta]ml?|web' },
+          { name: 'css', trigger: 'css|styl(?:e|us)' }
+        ]
+      }
+    end
+
+    def self.template(trigger)
+      if trigger =~ /^(css|sty)/
+        IO.read(File.join(File.dirname(__FILE__), '../../../templates/doing.css'))
+      else
+        IO.read(File.join(File.dirname(__FILE__), '../../../templates/doing.haml'))
+      end
+    end
+
+    def self.render(wwid, items, variables: {})
+      return if items.nil?
+
+      opt = variables[:options]
+
+      items_out = []
+      items.each do |i|
+        # if i.has_key?('note')
+        #   note = '<span class="note">' + i.note.map{|n| n.strip }.join('<br>') + '</span>'
+        # else
+        #   note = ''
+        # end
+        if String.method_defined? :force_encoding
+          title = i.title.force_encoding('utf-8').link_urls
+          note = i.note.map { |line| line.force_encoding('utf-8').strip.link_urls } if i.note
+        else
+          title = i.title.link_urls
+          note = i.note.map { |line| line.strip.link_urls } if i.note
+        end
+
+        interval = wwid.get_interval(i) if i.title =~ /@done\((\d{4}-\d\d-\d\d \d\d:\d\d.*?)\)/ && opt[:times]
+        interval ||= false
+
+        items_out << {
+          date: i.date.strftime('%a %-I:%M%p'),
+          title: title.gsub(/(@[^ (]+(\(.*?\))?)/im, '<span class="tag">\1</span>').strip, #+ " #{note}"
+          note: note,
+          time: interval,
+          section: i.section
+        }
+      end
+
+      template = if wwid.config['export_templates']['haml'] && File.exist?(File.expand_path(wwid.config['export_templates']['haml']))
+                   IO.read(File.expand_path(wwid.config['export_templates']['haml']))
+                 else
+                   self.template('html')
+                 end
+
+      style = if wwid.config['export_templates']['css'] && File.exist?(File.expand_path(wwid.config['export_templates']['css']))
+                IO.read(File.expand_path(wwid.config['export_templates']['css']))
+              else
+                self.template('css')
+              end
+
+      totals = opt[:totals] ? wwid.tag_times(format: :html, sort_by_name: opt[:sort_tags], sort_order: opt[:tag_order]) : ''
+      engine = Haml::Engine.new(template)
+      Doing.logger.debug('HTML Export:', "#{items_out.count} items output to HTML")
+      @out = engine.render(Object.new,
+                         { :@items => items_out, :@page_title => variables[:page_title], :@style => style, :@totals => totals })
+    end
+
+    Doing::Plugins.register 'html', :export, self
+  end
+end
+

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

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+# title: JSON Export
+# description: Export JSON-formatted data, including entry durations and tag totals
+# author: Brett Terpstra
+# url: https://brettterpstra.com
+module Doing
+  class JSONExport
+    include Doing::Util
+
+    def self.settings
+      {
+        trigger: 'json|time(?:line)?'
+      }
+    end
+
+    def self.render(wwid, items, variables: {})
+      return if items.nil?
+
+      opt = variables[:options]
+      opt[:output] =  case opt[:output]
+                      when /^t/
+                        'timeline'
+                      else
+                        'json'
+                      end
+      items_out = []
+      last_date = items[-1].date + (60 * 60 * 24)
+      max = last_date.strftime('%F')
+      min = items[0].date.strftime('%F')
+      items.each_with_index do |i, index|
+        if String.method_defined? :force_encoding
+          title = i.title.force_encoding('utf-8')
+          note = i.note.map { |line| line.force_encoding('utf-8').strip } if i.note
+        else
+          title = i.title
+          note = i.note.map { |line| line.strip } if i.note
+        end
+
+        end_date = i.end_date || ''
+        interval = wwid.get_interval(i, formatted: false) || 0
+        note ||= ''
+
+        tags = []
+        attributes = {}
+        skip_tags = %w[meanwhile done cancelled flagged]
+        i.title.scan(/@([^(\s]+)(?:\((.*?)\))?/).each do |tag|
+          tags.push(tag[0]) unless skip_tags.include?(tag[0])
+          attributes[tag[0]] = tag[1] if tag[1]
+        end
+
+        if opt[:output] == 'json'
+
+          i = {
+            date: i.date,
+            end_date: end_date,
+            title: title.strip, #+ " #{note}"
+            note: note.instance_of?(Array) ? note.to_s : note,
+            time: '%02d:%02d:%02d' % wwid.format_time(interval),
+            tags: tags
+          }
+
+          attributes.each { |attr, val| i[attr.to_sym] = val }
+
+          items_out << i
+
+        elsif opt[:output] == 'timeline'
+          new_item = {
+            'id' => index + 1,
+            'content' => title.strip, #+ " #{note}"
+            'title' => title.strip + " (#{'%02d:%02d:%02d' % wwid.format_time(interval)})",
+            'start' => i.date.strftime('%F %T'),
+            'type' => 'box',
+            'style' => 'color:#4c566b;background-color:#d8dee9;'
+          }
+
+
+          if interval && interval.to_i > 0
+            new_item['end'] = end_date.strftime('%F %T')
+            if interval.to_i > 3600
+              new_item['type'] = 'range'
+              new_item['style'] = 'color:white;background-color:#a2bf8a;'
+            end
+          end
+          new_item['style'] = 'color:white;background-color:#f7921e;' if i.tags?(wwid.config['marker_tag'])
+          items_out.push(new_item)
+        end
+      end
+      if opt[:output] == 'json'
+        Doing.logger.debug('JSON Export:', "#{items_out.count} items output to JSON")
+        JSON.pretty_generate({
+          'section' => variables[:page_title],
+          'items' => items_out,
+          'timers' => wwid.tag_times(format: :json, sort_by_name: opt[:sort_tags], sort_order: opt[:tag_order])
+        })
+      elsif opt[:output] == 'timeline'
+        template = <<~EOTEMPLATE
+                    <!doctype html>
+                    <html>
+                    <head>
+                      <link href="https://unpkg.com/vis-timeline@7.4.9/dist/vis-timeline-graph2d.min.css" rel="stylesheet" type="text/css" />
+                      <script src="https://unpkg.com/vis-timeline@7.4.9/dist/vis-timeline-graph2d.min.js"></script>
+                    </head>
+                    <body>
+                      <div id="mytimeline"></div>
+          #{'          '}
+                      <script type="text/javascript">
+                        // DOM element where the Timeline will be attached
+                        var container = document.getElementById('mytimeline');
+          #{'          '}
+                        // Create a DataSet with data (enables two way data binding)
+                        var data = new vis.DataSet(#{items_out.to_json});
+          #{'          '}
+                        // Configuration for the Timeline
+                        var options = {
+                          width: '100%',
+                          height: '800px',
+                          margin: {
+                            item: 20
+                          },
+                          stack: true,
+                          min: '#{min}',
+                          max: '#{max}'
+                        };
+          #{'          '}
+                        // Create a Timeline
+                        var timeline = new vis.Timeline(container, data, options);
+                      </script>
+                    </body>
+                    </html>
+        EOTEMPLATE
+        Doing.logger.debug('Timeline Export:', "#{items_out.count} items output to Timeline")
+        template
+      end
+    end
+
+    Doing::Plugins.register 'timeline', :export, self
+  end
+end
+

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+# title: Markdown Export
+# description: Export GFM-style task list
+# author: Brett Terpstra
+# url: https://brettterpstra.com
+module Doing
+  class MarkdownRenderer
+    attr_accessor :items, :page_title, :totals
+
+    def initialize(page_title, items, totals)
+      @page_title = page_title
+      @items = items
+      @totals = totals
+    end
+
+    def get_binding
+      binding()
+    end
+  end
+
+  class MarkdownExport
+    include Doing::Util
+
+    def self.settings
+      {
+        trigger: 'markdown|mk?d|gfm',
+        templates: [{ name: 'markdown', trigger: 'mk?d|markdown' }]
+      }
+    end
+
+    def self.template(_trigger)
+      IO.read(File.join(File.dirname(__FILE__), '../../../templates/doing-markdown.erb'))
+    end
+
+    def self.render(wwid, items, variables: {})
+      return if items.nil?
+
+      opt = variables[:options]
+
+      all_items = []
+      items.each do |i|
+        if String.method_defined? :force_encoding
+          title = i.title.force_encoding('utf-8').link_urls({format: :markdown})
+          note = i.note.map { |line| line.force_encoding('utf-8').strip.link_urls({format: :markdown}) } if i.note
+        else
+          title = i.title.link_urls({format: :markdown})
+          note = i.note.map { |line| line.strip.link_urls({format: :markdown}) } if i.note
+        end
+
+        title = "#{title} @project(#{i.section})" unless variables[:is_single]
+
+        interval = wwid.get_interval(i, record: true) if i.title =~ /@done\((\d{4}-\d\d-\d\d \d\d:\d\d.*?)\)/ && opt[:times]
+        interval ||= false
+
+        done = i.title =~ /(?<= |^)@done/ ? 'x' : ' '
+
+        all_items << {
+          date: i.date.strftime('%a %-I:%M%p'),
+          shortdate: i.date.relative_date,
+          done: done,
+          note: note,
+          section: i.section,
+          time: interval,
+          title: title.strip
+        }
+      end
+
+      template = if wwid.config['export_templates']['markdown'] && File.exist?(File.expand_path(wwid.config['export_templates']['markdown']))
+                   IO.read(File.expand_path(wwid.config['export_templates']['markdown']))
+                 else
+                   self.template(nil)
+                 end
+
+      totals = opt[:totals] ? wwid.tag_times(format: :markdown, sort_by_name: opt[:sort_tags], sort_order: opt[:tag_order]) : ''
+
+      mdx = MarkdownRenderer.new(variables[:page_title], all_items, totals)
+      Doing.logger.debug('Markdown Export:', "#{all_items.count} items output to Markdown")
+      engine = ERB.new(template)
+      @out = engine.result(mdx.get_binding)
+    end
+
+    Doing::Plugins.register 'markdown', :export, self
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# title: TaskPaper Export
+# description: Export TaskPaper-friendly data
+# author: Brett Terpstra
+# url: https://brettterpstra.com
+module Doing
+  class TaskPaperExport
+    include Doing::Util
+
+    def self.settings
+      {
+        trigger: 'task(?:paper)?|tp'
+      }
+    end
+
+    def self.render(wwid, items, variables: {})
+      return if items.nil?
+
+      options = variables[:options]
+
+      options[:highlight] = false
+      options[:wrap_width] = 0
+      options[:tags_color] = false
+      options[:output] = 'template'
+      options[:template] = '- %title @date(%date)%note'
+
+      Doing.logger.debug('TaskPaper Export:', "#{items.count} items output to TaskPaper format")
+      @out = wwid.list_section(options)
+    end
+
+    Doing::Plugins.register 'taskpaper', :export, self
+  end
+end