doing 2.0.25 → 2.1.0pre

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

@@ -34,9 +34,7 @@ module Doing
       tags = options[:tag] ? options[:tag].split(/[ ,]+/).map { |t| t.sub(/^@?/, '') } : []
       prefix = options[:prefix] || ''
 
-      @old_items = []
-
-      wwid.content.each { |_, v| @old_items.concat(v[:items]) }
+      @old_items = wwid.content.dup
 
       new_items = read_doing_file(path)
 
@@ -46,7 +44,7 @@ module Doing
       new_items = wwid.filter_items(new_items, opt: options)
 
       skipped = total - new_items.count
-      Doing.logger.debug('Skipped:' , %(#{skipped} items that didn't match filter criteria)) if skipped.positive?
+      Doing.logger.debug('Skipped:', %(#{skipped} items that didn't match filter criteria)) if skipped.positive?
 
       imported = []
 
@@ -76,13 +74,13 @@ module Doing
       dups = new_items.count - imported.count
       Doing.logger.info('Skipped:', %(#{dups} duplicate items)) if dups.positive?
 
-      imported = wwid.dedup(imported, !options[:overlap])
+      imported = wwid.dedup(imported, no_overlap: !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)
+        wwid.content.add_section(item.section) unless wwid.content.section?(item.section)
+        wwid.content.push(item)
       end
 
       Doing.logger.info('Imported:', "#{imported.count} items")

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

@@ -27,7 +27,7 @@ module Doing
       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)
+      wwid.content.add_section(section) unless wwid.content.section?(section)
 
       add_tags = options[:tag] ? options[:tag].split(/[ ,]+/).map { |t| t.sub(/^@?/, '') } : []
       prefix = options[:prefix] || '[Timing.app]'
@@ -73,11 +73,11 @@ module Doing
       filtered = skipped - new_items.count
       Doing.logger.debug('Skipped:' , %(#{filtered} items that didn't match filter criteria)) if filtered.positive?
 
-      new_items = wwid.dedup(new_items, options[:no_overlap])
+      new_items = wwid.dedup(new_items, no_overlap: options[:no_overlap])
       dups = filtered - new_items.count
       Doing.logger.debug('Skipped:' , %(#{dups} items with overlapping times)) if dups.positive?
 
-      wwid.content[section][:items].concat(new_items)
+      wwid.content.concat(new_items)
       Doing.logger.info('Imported:', %(#{new_items.count} items to #{section}))
     end
 

data/lib/doing/prompt.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+module Doing
+  # Terminal Prompt methods
+  module Prompt
+    class << self
+      attr_writer :force_answer, :default_answer
+
+      include Color
+
+      def force_answer
+        @force_answer ||= nil
+      end
+
+      def default_answer
+        @default_answer ||= false
+      end
+
+      ##
+      ## Ask a yes or no question in the terminal
+      ##
+      ## @param      question          [String] The question
+      ##                               to ask
+      ## @param      default_response  (Bool)   default
+      ##                               response if no input
+      ##
+      ## @return     (Bool) yes or no
+      ##
+      def yn(question, default_response: false)
+        unless @force_answer.nil?
+          return @force_answer
+        end
+
+        default = if default_response.is_a?(String)
+                    default_response =~ /y/i ? true : false
+                  else
+                    default_response
+                  end
+
+        # if global --default is set, answer default
+        return default if @default_answer
+
+        # if this isn't an interactive shell, answer default
+        return default unless $stdout.isatty
+
+        # clear the buffer
+        if ARGV&.length
+          ARGV.length.times do
+            ARGV.shift
+          end
+        end
+        system 'stty cbreak'
+
+        cw = white
+        cbw = boldwhite
+        cbg = boldgreen
+        cd = Color.default
+
+        options = unless default.nil?
+                    "#{cw}[#{default ? "#{cbg}Y#{cw}/#{cbw}n" : "#{cbw}y#{cw}/#{cbg}N"}#{cw}]#{cd}"
+                  else
+                    "#{cw}[#{cbw}y#{cw}/#{cbw}n#{cw}]#{cd}"
+                  end
+        $stdout.syswrite "#{cbw}#{question.sub(/\?$/, '')} #{options}#{cbw}?#{cd} "
+        res = $stdin.sysread 1
+        puts
+        system 'stty cooked'
+
+        res.chomp!
+        res.downcase!
+
+        return default if res.empty?
+
+        res =~ /y/i ? true : false
+      end
+
+      def fzf
+        @fzf ||= install_fzf
+      end
+
+      def install_fzf
+        fzf_dir = File.join(File.dirname(__FILE__), '../helpers/fzf')
+        FileUtils.mkdir_p(fzf_dir) unless File.directory?(fzf_dir)
+        fzf_bin = File.join(fzf_dir, 'bin/fzf')
+        return fzf_bin if File.exist?(fzf_bin)
+
+        prev_level = Doing.logger.level
+        Doing.logger.adjust_verbosity({ log_level: :info })
+        Doing.logger.log_now(:warn, 'Compiling and installing fzf -- this will only happen once')
+        Doing.logger.log_now(:warn, 'fzf is copyright Junegunn Choi, MIT License <https://github.com/junegunn/fzf/blob/master/LICENSE>')
+
+        system("'#{fzf_dir}/install' --bin --no-key-bindings --no-completion --no-update-rc --no-bash --no-zsh --no-fish &> /dev/null")
+        unless File.exist?(fzf_bin)
+          Doing.logger.log_now(:warn, 'Error installing, trying again as root')
+          system("sudo '#{fzf_dir}/install' --bin --no-key-bindings --no-completion --no-update-rc --no-bash --no-zsh --no-fish &> /dev/null")
+        end
+        raise RuntimeError.new('Error installing fzf, please report at https://github.com/ttscoff/doing/issues') unless File.exist?(fzf_bin)
+
+        Doing.logger.info("fzf installed to #{fzf}")
+        Doing.logger.adjust_verbosity({ log_level: prev_level })
+        fzf_bin
+      end
+
+      ##
+      ## Generate a menu of options and allow user selection
+      ##
+      ## @return     [String] The selected option
+      ##
+      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
+        fzf_args << %(--prompt "#{prompt}")
+        fzf_args << '--multi' if multiple
+        header = "esc: cancel,#{multiple ? ' tab: multi-select, ctrl-a: select all,' : ''} return: confirm"
+        fzf_args << %(--header "#{header}")
+        options.sort! if sorted
+        res = `echo #{Shellwords.escape(options.join("\n"))}|#{fzf} #{fzf_args.join(' ')}`
+        return false if res.strip.size.zero?
+
+        res
+      end
+
+      ##
+      ## Create an interactive menu to select from a set of Items
+      ##
+      ## @param      items            [Array] list of items
+      ## @param      opt              [Hash] options
+      ## @param      include_section  [Boolean] include section
+      ##
+      ## @option opt [String] :header
+      ## @option opt [String] :prompt
+      ## @option opt [String] :query
+      ## @option opt [Boolean] :show_if_single
+      ## @option opt [Boolean] :menu
+      ## @option opt [Boolean] :sort
+      ## @option opt [Boolean] :multiple
+      ## @option opt [Symbol] :case (:sensitive, :ignore, :smart)
+      ##
+      def choose_from_items(items, **opt)
+        return items unless $stdout.isatty
+
+        return nil unless items.count.positive?
+
+        case_sensitive = opt.fetch(:case, :smart).normalize_case
+        header = opt.fetch(:header, 'Arrows: navigate, tab: mark for selection, ctrl-a: select all, enter: commit')
+        prompt = opt.fetch(:prompt, 'Select entries to act on > ')
+        query = opt.fetch(:query) { opt.fetch(:search, '') }
+        include_section = opt.fetch(:include_section, false)
+
+        pad = items.length.to_s.length
+        options = items.map.with_index do |item, i|
+          out = [
+            format("%#{pad}d", i),
+            ') ',
+            format('%13s', item.date.relative_date),
+            ' | ',
+            item.title
+          ]
+          if include_section
+            out.concat([
+              ' (',
+              item.section,
+              ') '
+            ])
+          end
+          out.join('')
+        end
+
+        fzf_args = [
+          %(--header="#{header}"),
+          %(--prompt="#{prompt.sub(/ *$/, ' ')}"),
+          opt.fetch(:multiple) ? '--multi' : '--no-multi',
+          '-0',
+          '--bind ctrl-a:select-all',
+          %(-q "#{query}"),
+          '--info=inline'
+        ]
+        fzf_args.push('-1') unless opt.fetch(:show_if_single)
+        fzf_args << case case_sensitive
+                    when :sensitive
+                      '+i'
+                    when :ignore
+                      '-i'
+                    end
+        fzf_args << '-e' if opt.fetch(:exact, false)
+
+
+        unless opt.fetch(:menu)
+          raise InvalidArgument, "Can't skip menu when no query is provided" unless query && !query.empty?
+
+          fzf_args.concat([%(--filter="#{query}"), opt.fetch(:sort) ? '' : '--no-sort'])
+        end
+
+        res = `echo #{Shellwords.escape(options.join("\n"))}|#{fzf} #{fzf_args.join(' ')}`
+        selected = []
+        res.split(/\n/).each do |item|
+          idx = item.match(/^ *(\d+)\)/)[1].to_i
+          selected.push(items[idx])
+        end
+
+        opt.fetch(:multiple) ? selected : selected[0]
+      end
+    end
+  end
+end

data/lib/doing/section.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Doing
+  # Section Object
+  class Section
+    attr_accessor :original, :title
+
+    def initialize(title, original: nil)
+      super()
+
+      @title = title
+
+      @original = if original.nil?
+                    "#{title}:"
+                  else
+                    original =~ /:(\s+@\S+(\(.*?\))?)*$/ ? original : "#{original}:"
+                  end
+    end
+
+    # Outputs section title
+    def to_s
+      @title
+    end
+
+    # @private
+    def inspect
+      %(#<Doing::Section @title="#{@title}" @original="#{@original}">)
+    end
+  end
+end

data/lib/doing/string.rb

@@ -20,8 +20,7 @@ module Doing
     ## can be separated by up to *distance* characters in
     ## haystack, spaces indicate unlimited distance.
     ##
-    ## @example    "this word".to_rx(2) =>
-    ## /t.{0,3}h.{0,3}i.{0,3}s.{0,3}.*?w.{0,3}o.{0,3}r.{0,3}d/
+    ## @example    `"this word".to_rx(2) => /t.{0,3}h.{0,3}i.{0,3}s.{0,3}.*?w.{0,3}o.{0,3}r.{0,3}d/`
     ##
     ## @param      distance   [Integer] Allowed distance
     ##                        between characters
@@ -63,6 +62,15 @@ module Doing
       end
     end
 
+    # Compress multiple spaces to single space
+    def compress
+      gsub(/ +/, ' ').strip
+    end
+
+    def compress!
+      replace compress
+    end
+
     ## @param (see #highlight_tags)
     def highlight_tags!(color = 'yellow')
       replace highlight_tags(color)
@@ -289,11 +297,29 @@ module Doing
       title
     end
 
-    def tag!(tag, value: nil, remove: false, rename_to: nil, regex: false, single: false)
-      replace tag(tag, value: value, remove: remove, rename_to: rename_to, regex: regex, single: single)
+    ##
+    ## Add, rename, or remove a tag in place
+    ##
+    ## @see #tag
+    ##
+    def tag!(tag, **options)
+      replace tag(tag, **options)
     end
 
-    def tag(tag, value: nil, remove: false, rename_to: nil, regex: false, single: false)
+    ##
+    ## Add, rename, or remove a tag
+    ##
+    ## @param      tag        The tag
+    ## @param      value      [String] Value for tag (@tag(value))
+    ## @param      remove     [Boolean] Remove the tag instead of adding
+    ## @param      rename_to  [String] Replace tag with this tag
+    ## @param      regex      [Boolean] Tag is regular expression
+    ## @param      single     [Boolean] Operating on a single item (for logging)
+    ## @param      force      [Boolean] With rename_to, add tag if it doesn't exist
+    ##
+    ## @return     [String] The string with modified tags
+    ##
+    def tag(tag, value: nil, remove: false, rename_to: nil, regex: false, single: false, force: false)
       log_level = single ? :info : :debug
       title = dup
       title.chomp!
@@ -307,13 +333,14 @@ module Doing
                end
 
       if remove || rename_to
-        return title unless title =~ /#{rx_tag}(?=[ (]|$)/
+        rx = Regexp.new("(?<=^| )@#{rx_tag}(?<parens>\\((?<value>[^)]*)\\))?(?= |$)", case_sensitive)
+        m = title.match(rx)
 
-        rx = Regexp.new("(^| )@#{rx_tag}(\\([^)]*\\))?(?= |$)", case_sensitive)
-        if title =~ rx
+        if m.nil? && rename_to && force
+          title.tag!(rename_to, value: value, single: single)
+        elsif m
           title.gsub!(rx) do
-            m = Regexp.last_match
-            rename_to ? "#{m[1]}@#{rename_to}#{m[2]}" : m[1]
+            rename_to ? "@#{rename_to}#{value.nil? ? m['parens'] : "(#{value})"}" : ''
           end
 
           title.dedup_tags!
@@ -373,9 +400,16 @@ module Doing
       title
     end
 
-    # Returns the last escape sequence from a string
+    # Returns the last escape sequence from a string.
     #
-    # @param      string  The string to examine
+    # Actually returns all escape codes, with the assumption
+    # that the result of inserting them will generate the
+    # same color as was set at the end of the string.
+    # Because you can send modifiers like dark and bold
+    # separate from color codes, only using the last code
+    # may not render the same style.
+    #
+    # @return     [String]  All escape codes in string
     #
     def last_color
       scan(/\e\[[\d;]+m/).join('')
@@ -386,17 +420,20 @@ module Doing
     ##
     ## @param      opt   [Hash] Additional Options
     ##
-    def link_urls!(opt = {})
-      replace link_urls(opt)
+    def link_urls!(**opt)
+      fmt = opt.fetch(:format, :html)
+      replace link_urls(format: fmt)
     end
 
-    def link_urls(opt = {})
-      opt[:format] ||= :html
+    def link_urls(**opt)
+      fmt = opt.fetch(:format, :html)
+      return self unless fmt
+
       str = dup
 
-      str = str.remove_self_links if opt[:format] == :markdown
+      str = str.remove_self_links if fmt == :markdown
 
-      str.replace_qualified_urls(format: opt[:format]).clean_unlinked_urls
+      str.replace_qualified_urls(format: fmt).clean_unlinked_urls
     end
 
     # Remove <self-linked> formatting
@@ -412,21 +449,24 @@ module Doing
     end
 
     # Replace qualified urls
-    def replace_qualified_urls(opt = {})
-      opt[:format] ||= :html
+    def replace_qualified_urls(**options)
+      fmt = options.fetch(:format, :html)
       gsub(%r{(?mi)(?x:
       (?<!["'\[(\\])
-      ((http|https)://)
-      ([\w\-]+(\.[\w\-]+)+)
-      ([\w\-.,@?^=%&;:/~+#]*[\w\-@^=%&;/~+#])?
+      (?<protocol>(?:http|https)://)
+      (?<domain>[\w\-]+(?:\.[\w\-]+)+)
+      (?<path>[\w\-.,@?^=%&;:/~+#]*[\w\-@^=%&;/~+#])?
       )}) do |_match|
         m = Regexp.last_match
-        proto = m[1].nil? ? 'http://' : ''
-        case opt[:format]
+        url = "#{m['domain']}#{m['path']}"
+        proto = m['protocol'].nil? ? 'http://' : m['protocol']
+        case fmt
+        when :terminal
+          TTY::Link.link_to("#{proto}#{url}", "#{proto}#{url}")
         when :html
-          %(<a href="#{proto}#{m[0]}" title="Link to #{m[0].sub(%r{^https?://}, '')}">[#{m[3]}]</a>)
+          %(<a href="#{proto}#{url}" title="Link to #{m['domain']}">[#{url}]</a>)
         when :markdown
-          "[#{m[0]}](#{proto}#{m[0]})"
+          "[#{url}](#{proto}#{url})"
         else
           m[0]
         end
@@ -444,5 +484,41 @@ module Doing
         end
       end
     end
+
+    def set_type(kind = nil)
+      if kind
+        case kind.to_s
+        when /^a/i
+          gsub(/^\[ *| *\]$/, '').split(/ *, */)
+        when /^i/i
+          to_i
+        when /^f/i
+          to_f
+        when /^sy/i
+          sub(/^:/, '').to_sym
+        when /^b/i
+          self =~ /^(true|yes)$/ ? true : false
+        else
+          to_s
+        end
+      else
+        case self
+        when / *, */
+          gsub(/^\[ *| *\]$/, '').split(/ *, */)
+        when /^[0-9]+$/
+          to_i
+        when /^[0-9]+\.[0-9]+$/
+          to_f
+        when /^:\w+/
+          sub(/^:/, '').to_sym
+        when /^(true|yes)$/i
+          true
+        when /^(false|no)$/i
+          false
+        else
+          to_s
+        end
+      end
+    end
   end
 end

data/lib/doing/util.rb

@@ -21,11 +21,17 @@ module Doing
     def exec_available(cli)
       return false if cli.nil?
 
-      if File.exist?(File.expand_path(cli))
-        File.executable?(File.expand_path(cli))
-      else
-        system "which #{cli}", out: File::NULL, err: File::NULL
-      end
+      !TTY::Which.which(cli).nil?
+    end
+
+    ##
+    ## Return the first valid executable from a list of commands
+    ##
+    ## @example `Doing::Util.first_available_exec('bat', 'less -Xr', 'more -r', 'cat')`
+    ##
+    def first_available_exec(*commands)
+      commands.compact.map(&:strip).reject(&:empty?).uniq
+      .find { |cmd| exec_available(cmd.split.first) }
     end
 
     def merge_default_proc(target, overwrite)
@@ -116,6 +122,7 @@ module Doing
 
       File.open(file, 'w+') do |f|
         f.puts content
+        Doing.logger.debug('Write:', "File written: #{file}")
       end
 
       Hooks.trigger :post_write, file
@@ -183,7 +190,8 @@ module Doing
       Doing.logger.debug('ENV:', 'No EDITOR environment variable, testing available editors')
       editors = %w[vim vi code subl mate mvim nano emacs]
       editors.each do |ed|
-        return ed if exec_available(ed)
+        return TTY::Which.which(ed) if TTY::Which.which(ed)
+
         Doing.logger.debug('ENV:', "#{ed} not available")
       end
 

data/lib/doing/version.rb

@@ -1,3 +1,3 @@
 module Doing
-  VERSION = '2.0.25'
+  VERSION = '2.1.0pre'
 end