doing 2.1.30 → 2.1.31pre

data/lib/doing/completion/zsh_completion.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module Doing
   module Completion
+    # Generate completions for zsh
     class ZshCompletions
-
       attr_accessor :commands, :global_options
 
       def generate_helpers
@@ -34,58 +36,11 @@ module Doing
           }
 
         EOFUNCTIONS
+        @bar.advance(status: '✅')
         @bar.finish
         out
       end
 
-      def get_help_sections(command = '')
-        res = `doing help #{command}`.strip
-        scanned = res.scan(/(?m-i)^([A-Z ]+)\n([\s\S]*?)(?=\n+[A-Z]+|\Z)/)
-        sections = {}
-        scanned.each do |sect|
-          title = sect[0].downcase.strip.gsub(/ +/, '_').to_sym
-          content = sect[1].split(/\n/).map(&:strip).delete_if(&:empty?)
-          sections[title] = content
-        end
-        sections
-      end
-
-      def parse_option(option)
-        res = option.match(/(?:-(?<short>\w), )?(?:--(?:\[no-\])?(?<long>\w+)(?:=(?<arg>\w+))?)\s+- (?<desc>.*?)$/)
-        return nil unless res
-
-        {
-          short: res['short'],
-          long: res['long'],
-          arg: res[:arg],
-          description: res['desc'].short_desc
-        }
-      end
-
-      def parse_options(options)
-        options.map { |opt| parse_option(opt) }
-      end
-
-      def parse_command(command)
-        res = command.match(/^(?<cmd>[^, \t]+)(?<alias>(?:, [^, \t]+)*)?\s+- (?<desc>.*?)$/)
-        if res.nil?
-          Doing.logger.error('Completion:', "Error parsing #{command}")
-          return nil
-
-        end
-        commands = [res['cmd']]
-        commands.concat(res['alias'].split(/, /).delete_if(&:empty?)) if res['alias']
-
-        {
-          commands: commands,
-          description: res['desc'].short_desc
-        }
-      end
-
-      def parse_commands(commands)
-        commands.map { |cmd| parse_command(cmd) }
-      end
-
       def generate_subcommand_completions
         out = []
         @commands.each_with_index do |cmd, i|
@@ -103,11 +58,11 @@ module Doing
         @commands.each_with_index do |cmd, i|
           @bar.advance(status: cmd[:commands].first)
 
-          data = get_help_sections(cmd[:commands].first)
+          data = Completion.get_help_sections(cmd[:commands].first)
           option_arr = []
 
           if data[:command_options]
-            parse_options(data[:command_options]).each do |option|
+            Completion.parse_options(data[:command_options]).each do |option|
               next if option.nil?
 
               arg = option[:arg] ? '=' : ''
@@ -129,11 +84,12 @@ module Doing
       end
 
       def initialize
-        data = get_help_sections
-        @global_options = parse_options(data[:global_options])
-        @commands = parse_commands(data[:commands])
-        @bar = TTY::ProgressBar.new(" \033[0;0;33mGenerating Zsh completions: \033[0;35;40m[:bar] :status\033[0m", total: @commands.count, bar_format: :blade, status: 'processing subcommands')
-        @bar.resize(25)
+        data = Completion.get_help_sections
+        @global_options = Completion.parse_options(data[:global_options])
+        @commands = Completion.parse_commands(data[:commands])
+        @bar = TTY::ProgressBar.new(" \033[0;0;33mGenerating Zsh completions: \033[0;35;40m[:bar] :status\033[0m", total: @commands.count + 1, bar_format: :block, hide_cursor: true, status: 'processing subcommands')
+        width = TTY::Screen.columns - 45
+        @bar.resize(width)
       end
 
       def generate_completions

data/lib/doing/completion.rb

@@ -11,25 +11,118 @@ require 'bash_completion'
 module Doing
   # Completion script generator
   module Completion
+    OPTIONS_RX = /(?:-(?<short>\w), )?(?:--(?:\[no-\])?(?<long>\w+)(?:=(?<arg>\w+))?)\s+- (?<desc>.*?)$/.freeze
+    SECTIONS_RX = /(?m-i)^([A-Z ]+)\n([\s\S]*?)(?=\n+[A-Z]+|\Z)/.freeze
+    COMMAND_RX = /^(?<cmd>[^, \t]+)(?<alias>(?:, [^, \t]+)*)?\s+- (?<desc>.*?)$/.freeze
+
     class << self
+      def get_help_sections(command = '')
+        res = `doing help #{command}`.strip
+        scanned = res.scan(SECTIONS_RX)
+        sections = {}
+        scanned.each do |sect|
+          title = sect[0].downcase.strip.gsub(/ +/, '_').to_sym
+          content = sect[1].split(/\n/).map(&:strip).delete_if(&:empty?)
+          sections[title] = content
+        end
+        sections
+      end
+
+      def parse_option(option)
+        res = option.match(OPTIONS_RX)
+        return nil unless res
+
+        {
+          short: res['short'],
+          long: res['long'],
+          arg: res['arg'],
+          description: res['desc'].short_desc
+        }
+      end
+
+      def parse_options(options)
+        options.map { |opt| parse_option(opt) }
+      end
+
+      def parse_command(command)
+        res = command.match(COMMAND_RX)
+        commands = [res['cmd']]
+        commands.concat(res['alias'].split(/, /).delete_if(&:empty?)) if res['alias']
+
+        {
+          commands: commands,
+          description: res['desc'].short_desc
+        }
+      end
+
+      def parse_commands(commands)
+        commands.map { |cmd| parse_command(cmd) }
+      end
+
       # Generate a completion script and output to file or
       # stdout
       #
       # @param      type  [String] shell to generate for (zsh|bash|fish)
       # @param      file  [String] Path to save to, or 'stdout'
       #
-      def generate_completion(type: 'zsh', file: 'stdout')
-        if type =~ /^all$/i
-          Doing.logger.log_now(:warn, 'Generating:', 'all completion types, will use default paths')
-          generate_completion(type: 'fish', file: 'lib/completion/doing.fish')
-          Doing.logger.warn('File written:', "fish completions written to lib/completion/doing.fish")
-          generate_completion(type: 'zsh', file: 'lib/completion/_doing.zsh')
-          Doing.logger.warn('File written:', "zsh completions written to lib/completion/_doing.zsh")
-          generate_completion(type: 'bash', file: 'lib/completion/doing.bash')
-          Doing.logger.warn('File written:', "bash completions written to lib/completion/doing.bash")
-          return
+      def generate_completion(type: 'zsh', file: :default, link: true)
+        return generate_all if type =~ /^all$/i
+
+        file = file == :default ? default_file(type) : file
+        file = validate_target(file)
+        result = generate_type(type)
+
+        if file =~ /^stdout$/i
+          $stdout.puts result
+        else
+          File.open(file, 'w') { |f| f.puts result }
+          Doing.logger.warn('File written:', "#{type} completions written to #{file}")
+
+          link_completion_type(type, file) if link
         end
+      end
+
+      def link_default(type)
+        type = normalize_type(type)
+        raise InvalidArgument, 'Unrecognized shell specified' if type == :invalid
+
+        return %i[zsh bash fish].each { |t| link_default(t) } if type == :all
 
+        install_builtin(type)
+
+        link_completion_type(type, File.join(default_dir, default_filenames[type]))
+      end
+
+      def install_builtin(type)
+        FileUtils.mkdir_p(default_dir)
+        src = File.expand_path(File.join(File.dirname(__FILE__), '..', 'completion', default_filenames[type]))
+
+        if File.exist?(File.join(default_dir, default_filenames[type]))
+          return unless Doing::Prompt.yn("Update #{type} completion script", default_response: 'n')
+        end
+
+        FileUtils.cp(src, default_dir)
+        Doing.logger.warn('File written:', "#{type} completions saved to #{default_file(type)}")
+      end
+
+      def normalize_type(type)
+        case type.to_s
+        when /^f/i
+          :fish
+        when /^b/i
+          :bash
+        when /^z/i
+          :zsh
+        when /^a/i
+          :all
+        else
+          :invalid
+        end
+      end
+
+      private
+
+      def generate_type(type)
         generator = case type.to_s
                     when /^f/i
                       FishCompletions.new
@@ -39,16 +132,109 @@ module Doing
                       ZshCompletions.new
                     end
 
-        result = generator.generate_completions
+        generator.generate_completions
+      end
 
-        if file =~ /^stdout$/i
-          $stdout.puts result
-        else
-          File.open(File.expand_path(file), 'w') do |f|
-            f.puts result
+      def validate_target(file)
+        unless file =~ /stdout/i
+          file = validate_file(file)
+
+          validate_dir(file)
+        end
+
+        file
+      end
+
+      def default_dir
+        File.expand_path('~/.local/share/doing/completion')
+      end
+
+      def default_filenames
+        { zsh: '_doing.zsh', bash: 'doing.bash', fish: 'doing.fish' }
+      end
+
+      def default_file(type)
+        type = normalize_type(type)
+
+        File.join(default_dir, default_filenames[type])
+      end
+
+      def validate_file(file)
+        file = File.expand_path(file)
+        if File.exist?(file)
+          res = Doing::Prompt.yn("Overwrite #{file}", default_response: 'y')
+          raise UserCancelled unless res
+
+          FileUtils.rm(file) if res
+        end
+        file
+      end
+
+      def validate_dir(file)
+        dir = File.dirname(file)
+        unless File.directory?(dir)
+          res = Doing::Prompt.yn("#{dir} doesn't exist, create it", default_response: 'y')
+          raise UserCancelled unless res
+
+          FileUtils.mkdir_p(dir)
+        end
+        dir
+      end
+
+      def generate_all
+        Doing.logger.log_now(:warn, 'Generating:', 'all completion types, will use default paths')
+        generate_completion(type: 'fish', file: 'lib/completion/doing.fish', link: false)
+        Doing.logger.warn('File written:', 'fish completions written to lib/completion/doing.fish')
+        generate_completion(type: 'zsh', file: 'lib/completion/_doing.zsh', link: false)
+        Doing.logger.warn('File written:', 'zsh completions written to lib/completion/_doing.zsh')
+        generate_completion(type: 'bash', file: 'lib/completion/doing.bash', link: false)
+        Doing.logger.warn('File written:', 'bash completions written to lib/completion/doing.bash')
+      end
+
+      def link_completion_type(type, file)
+        dir = File.dirname(file)
+        case type.to_s
+        when /^b/i
+          unless dir =~ %r{(\.bash_it/completion|bash_completion/completions)}
+            link_completion(file, ['~/.bash_it/completion/enabled', '/usr/share/bash_completion/completions'], 'doing.bash')
           end
-          Doing.logger.warn('File written:', "#{type} completions written to #{file}")
+        when /^f/i
+          link_completion(file, ['~/.config/fish/completions'], 'doing.fish') unless dir =~ %r{.config/fish/completions}
+        when /^z/i
+          unless dir =~ %r{(\.oh-my-zsh/completions|share/site-functions)}
+            link_completion(file, ['~/.oh-my-zsh/completions', '/usr/local/share/zsh/site-functions'], '_doing.zsh')
+          end
+        end
+      end
+
+      def link_completion(file, targets, filename)
+        return if targets.map { |t| File.expand_path(t) }.include?(File.dirname(file))
+
+        found = false
+        linked = false
+
+        targets.each do |target|
+          next unless File.directory?(File.expand_path(target))
+          found = true
+
+          target_file = File.join(File.expand_path(target), filename)
+          next unless Doing::Prompt.yn("Create link to #{target_file}", default_response: 'n')
+
+          FileUtils.ln_s(File.expand_path(file), target_file, force: true)
+          Doing.logger.warn('File linked:', "#{File.expand_path(file)} -> #{target_file}")
+          linked = true
+          break
+        end
+
+        return if linked
+
+        unless found
+          $stdout.puts 'No known auto-load directory found for specified shell'.red
+          $stdout.puts "Looked for #{targets.join(', ')}, found no existing directory".yellow
         end
+        $stdout.puts 'If you don\'t want to autoload completions'.yellow
+        $stdout.puts 'you can source the script directly in your shell\'s startup file:'.yellow
+        $stdout.puts %(source "#{file}").boldwhite
       end
     end
   end

data/lib/doing/item.rb

@@ -272,7 +272,7 @@ module Doing
     end
 
     def highlight_search(search, distance: nil, negate: false, case_type: nil)
-      prefs = Doing.config.settings['search'] || {}
+      prefs = Doing.setting('search', {})
       matching = prefs.fetch('matching', 'pattern').normalize_matching
       distance ||= prefs.fetch('distance', 3).to_i
       case_type ||= prefs.fetch('case', 'smart').normalize_case
@@ -311,7 +311,7 @@ module Doing
     ## @return     [Boolean] matches search criteria
     ##
     def search(search, distance: nil, negate: false, case_type: nil)
-      prefs = Doing.config.settings['search'] || {}
+      prefs = Doing.setting('search', {})
       matching = prefs.fetch('matching', 'pattern').normalize_matching
       distance ||= prefs.fetch('distance', 3).to_i
       case_type ||= prefs.fetch('case', 'smart').normalize_case
@@ -354,6 +354,24 @@ module Doing
       negate ? !matches : matches
     end
 
+    ##
+    ## Test if item has a @done tag
+    ##
+    ## @return     [Boolean] true item has @done tag
+    ##
+    def finished?
+      tags?('done')
+    end
+
+    ##
+    ## Test if item does not contain @done tag
+    ##
+    ## @return     [Boolean] true if item is missing @done tag
+    ##
+    def unfinished?
+      tags?('done', negate: true)
+    end
+
     ##
     ## Test if item is included in never_finish config and
     ## thus should not receive a @done tag
@@ -436,7 +454,7 @@ module Doing
     private
 
     def should?(key)
-      config = Doing.config.settings
+      config = Doing.settings
       return true unless config[key].is_a?(Array)
 
       config[key].each do |tag|

data/lib/doing/items.rb

@@ -131,9 +131,9 @@ module Doing
       out = []
       @sections.each do |section|
         out.push(section.original)
-        items = in_section(section.title).sort_by { |i| i.date }
-        items.reverse! if Doing.config.settings['doing_file_sort'].normalize_order == :desc
-        items.each { |item| out.push(item.to_s)}
+        items = in_section(section.title).sort_by(&:date)
+        items.reverse! if Doing.setting('doing_file_sort').normalize_order == :desc
+        items.each { |item| out.push(item.to_s) }
       end
 
       out.join("\n")
@@ -141,8 +141,8 @@ module Doing
 
     # @private
     def inspect
-      "#<Doing::Items #{count} items, #{@sections.count} sections: #{@sections.map { |s| "<Section:#{s.title} #{in_section(s.title).count} items>" }.join(', ')}>"
+      sections = @sections.map { |s| "<Section:#{s.title} #{in_section(s.title).count} items>" }.join(', ')
+      "#<Doing::Items #{count} items, #{@sections.count} sections: #{sections}>"
     end
-
   end
 end

data/lib/doing/note.rb

@@ -5,7 +5,6 @@ module Doing
   ## This class describes an item note.
   ##
   class Note < Array
-
     ##
     ## Initializes a new note
     ##
@@ -28,9 +27,10 @@ module Doing
     ##
     def add(note, replace: false)
       clear if replace
-      if note.is_a?(String)
+      case note
+      when String
         append_string(note)
-      elsif note.is_a?(Array)
+      when Array
         append(note)
       end
     end
@@ -55,7 +55,7 @@ module Doing
     ## @return     [Array] Stripped note
     ##
     def strip_lines
-      map(&:strip)
+      Note.new(map(&:strip))
     end
 
     def strip_lines!
@@ -64,8 +64,24 @@ module Doing
 
     ##
     ## Note as multi-line string
-    def to_s
-      compress.strip_lines.map { |l| "\t\t#{l}" }.join("\n")
+    ##
+    ## @param      prefix  [String] prefix for each line (default two tabs, TaskPaper format)
+    ##
+    def to_s(prefix: "\t\t")
+      compress.strip_lines.map { |l| "#{prefix}#{l}" }.join("\n")
+    end
+
+    ##
+    ## Returns note as a single line, newlines separated by
+    ## space
+    ##
+    ## @return     [String] Line representation of the Note.
+    ##
+    ## @param      separator  The separator with which to
+    ##                        join multiple lines
+    ##
+    def to_line(separator: ' ')
+      compress.strip_lines.join(separator)
     end
 
     # @private
@@ -94,7 +110,7 @@ module Doing
     ## @param      lines  [Array] Array of strings
     ##
     def append(lines)
-      concat(lines)
+      concat(lines.utf8)
       replace compress
     end
 
@@ -105,7 +121,7 @@ module Doing
     ##                    newlines will be split
     ##
     def append_string(input)
-      concat(input.split(/\n/).map(&:strip))
+      concat(input.utf8.split(/\n/).map(&:strip))
       replace compress
     end
   end

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

@@ -45,7 +45,9 @@ module Doing
 
     def self.render(wwid, items, variables: {})
 
-      return if items.nil?
+      return unless items.good?
+
+      config = Doing.settings
 
       opt = variables[:options]
       trigger = opt[:output]
@@ -78,7 +80,7 @@ module Doing
         title = "#{title} @section(#{i.section})" unless variables[:is_single]
 
         tags.concat(i.tag_array).sort!.uniq!
-        flagged = day_flagged = true if i.tags?(wwid.config['marker_tag'])
+        flagged = day_flagged = true if i.tags?(config['marker_tag'])
 
         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
@@ -123,8 +125,8 @@ module Doing
       end
 
 
-      template = if wwid.config['export_templates']['dayone'] && File.exist?(File.expand_path(wwid.config['export_templates']['dayone']))
-                   IO.read(File.expand_path(wwid.config['export_templates']['dayone']))
+      template = if config['export_templates']['dayone'] && File.exist?(File.expand_path(config['export_templates']['dayone']))
+                   IO.read(File.expand_path(config['export_templates']['dayone']))
                  else
                    self.template('dayone')
                  end
@@ -144,8 +146,8 @@ module Doing
                     starred: hsh[:starred])
         end
       when :entries
-        entry_template = if wwid.config['export_templates']['dayone_entry'] && File.exist?(File.expand_path(wwid.config['export_templates']['dayone_entry']))
-                           IO.read(File.expand_path(wwid.config['export_templates']['dayone_entry']))
+        entry_template = if config['export_templates']['dayone_entry'] && File.exist?(File.expand_path(config['export_templates']['dayone_entry']))
+                           IO.read(File.expand_path(config['export_templates']['dayone_entry']))
                          else
                            self.template('dayone-entry')
                          end

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

@@ -58,14 +58,14 @@ module Doing
         }
       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']))
+      template = if Doing.setting('export_templates.haml') && File.exist?(File.expand_path(Doing.setting('export_templates.haml')))
+                   IO.read(File.expand_path(Doing.setting('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']))
+      style = if Doing.setting('export_templates.css') && File.exist?(File.expand_path(Doing.setting('export_templates.css')))
+                IO.read(File.expand_path(Doing.setting('export_templates.css')))
               else
                 self.template('css')
               end

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

@@ -29,16 +29,12 @@ module Doing
       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
+        title = i.title.utf8
+        note = i.note.utf8
 
         end_date = i.end_date || ''
         interval = wwid.get_interval(i, formatted: false) || 0
+        duration = i.duration || 0
         note ||= ''
 
         tags = []
@@ -49,14 +45,15 @@ module Doing
           attributes[tag[0]] = tag[1] if tag[1]
         end
 
-        if opt[:output] == 'json'
-
+        case opt[:output]
+        when 'json'
           i = {
             date: i.date,
             end_date: end_date,
             title: title.strip, #+ " #{note}"
-            note: note.instance_of?(Array) ? note.to_s : note,
+            note: note.to_s(prefix: ''),
             time: interval.time_string(format: :clock),
+            duration: duration.time_string(format: :clock),
             tags: tags
           }
 
@@ -64,7 +61,7 @@ module Doing
 
           items_out << i
 
-        elsif opt[:output] == 'timeline'
+        when 'timeline'
           new_item = {
             'id' => index + 1,
             'content' => title.strip, #+ " #{note}"
@@ -74,26 +71,28 @@ module Doing
             'style' => 'color:#4c566b;background-color:#d8dee9;'
           }
 
-
-          if interval && interval.to_i > 0
+          if interval.to_i&.positive?
             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'])
+          new_item['style'] = 'color:white;background-color:#f7921e;' if i.tags?(Doing.setting('marker_tag'))
           items_out.push(new_item)
         end
       end
-      if opt[:output] == 'json'
+      case opt[:output]
+      when '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: opt[:sort_tags], sort_order: opt[:tag_order])
-        })
-      elsif opt[:output] == 'timeline'
+                               'section' => variables[:page_title],
+                               'items' => items_out,
+                               'timers' => wwid.tag_times(format: :json,
+                                                          sort_by: opt[:sort_tags],
+                                                          sort_order: opt[:tag_order])
+                             })
+      when 'timeline'
         template = <<~EOTEMPLATE
                     <!doctype html>
                     <html>

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

@@ -66,8 +66,8 @@ module Doing
         }
       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']))
+      template = if Doing.setting('export_templates.markdown') && File.exist?(File.expand_path(Doing.setting('export_templates.markdown')))
+                   IO.read(File.expand_path(Doing.setting('export_templates.markdown')))
                  else
                    self.template(nil)
                  end