doing 2.1.27 → 2.1.31pre

data/lib/doing/changelog/changes.rb

@@ -6,13 +6,15 @@ module Doing
     attr_reader :changes
     attr_writer :changes_only
 
-    def initialize(lookup: nil, search: nil, changes_only: false)
-      @changes_only = changes_only
+    def initialize(lookup: nil, search: nil, changes: false, sort: :desc)
+      @changes_only = changes
       changelog = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'CHANGELOG.md'))
       raise 'Error locating changelog' unless File.exist?(changelog)
 
       @content = IO.read(changelog)
       parse_changes(lookup, search)
+
+      @changes.reverse! if sort == :asc
     end
 
     def latest
@@ -23,6 +25,22 @@ module Doing
       end
     end
 
+    def versions
+      @changes.select { |change| change.entries&.count > 0 }.map { |change| change.version }
+    end
+
+    def interactive
+      Doing::Prompt.choose_from(versions,
+                                prompt: 'Select a version to see its changelog',
+                                sorted: false,
+                                fzf_args: [
+                                  %(--preview='doing changes --render -l {1}'),
+                                  '--disabled',
+                                  '--height=50',
+                                  '--preview-window="right,70%"'
+                                ])
+    end
+
     def to_s
       if @changes_only
         @changes.map(&:changes_only).join().force_encoding('utf-8')
@@ -48,18 +66,19 @@ module Doing
     def lookup(lookup_version)
       range = []
 
-      if lookup_version =~ /([\d.]+) *-+ *([\d.]+)/
+      if lookup_version =~ /([\d.]+) *(?:-|to)+ *([\d.]+)/
         m = Regexp.last_match
         lookup("> #{m[1]}")
         lookup("< #{m[2]}")
-      elsif lookup_version.scan(/[<>]/).count > 1
-        params = lookup_version.scan(/[<>] [\d.]+/)
+      elsif lookup_version.scan(/(?:<=?|prior|before|older|>=?|since|after|newer) *[0-9*?.]+/).count > 1
+        params = lookup_version.scan(/(?:<=?|prior|before|older|>=?|since|after|newer) *[0-9*?.]+/)
         params.each { |query| lookup(query) }
       else
+        inclusive = lookup_version =~ /=/ ? true : false
         comp = case lookup_version
                when /(<|prior|before|older)/
                  :older
-               when />|since|after|newer/
+               when /(>|since|after|newer)/
                  :newer
                else
                  :equal
@@ -67,7 +86,7 @@ module Doing
         version = Version.new(lookup_version)
 
         @changes.select! do |change|
-          change.version.compare(version, comp)
+          change.version.compare(version, comp, inclusive: inclusive)
         end
       end
     end

data/lib/doing/changelog/version.rb

@@ -37,7 +37,7 @@ module Doing
     end
 
 
-    def compare(other, comp)
+    def compare(other, comp, inclusive: false)
       case comp
       when :older
         if @maj <= other.maj
@@ -46,7 +46,11 @@ module Doing
           elsif @maj == other.maj && (other.min.nil? || @min < other.min)
             true
           elsif @maj == other.maj && @min == other.min
-            other.patch.nil? ? false : @patch < other.patch
+            if other.patch.nil?
+              false
+            else
+              inclusive ? @patch <= other.patch : @patch < other.patch
+            end
           else
             false
           end
@@ -60,7 +64,11 @@ module Doing
           elsif @maj == other.maj && (other.min.nil? || @min > other.min)
             true
           elsif @maj == other.maj && @min == other.min
-            other.patch.nil? || @patch >= other.patch
+            if other.patch.nil?
+              false
+            else
+              inclusive ? @patch >= other.patch : @patch > other.patch
+            end
           else
             false
           end

data/lib/doing/completion/bash_completion.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 module Doing
   module Completion
+    # Generate completions for Bash
     class BashCompletions
       attr_accessor :commands, :global_options
 
@@ -11,7 +14,7 @@ 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)
 
           arg = data[:synopsis].join(' ').strip.split(/ /).last
           case arg
@@ -26,7 +29,7 @@ module Doing
           end
 
           if data[:command_options]
-            options = parse_options(data[:command_options])
+            options = Completion.parse_options(data[:command_options])
             out << command_function(cmd[:commands].first, options, type)
 
             if first
@@ -119,56 +122,13 @@ module Doing
         [func, logic]
       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>.*?)$/)
-        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 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 Bash completions: \033[0;35;40m[:bar] :status\033[0m", total: @commands.count, bar_format: :blade, status: 'Reading 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 Bash completions: \033[0;35;40m[:bar] :status\033[0m", total: @commands.count + 1, bar_format: :box, hide_cursor: true, status: 'Reading subcommands')
+        width = TTY::Screen.columns - 45
+        @bar.resize(width)
       end
 
       def generate_completions
@@ -176,6 +136,7 @@ module Doing
         out = []
         out << main_function
         out << 'complete -F _doing doing'
+        @bar.advance(status: '✅')
         @bar.finish
         out.join("\n")
       end

data/lib/doing/completion/fish_completion.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 module Doing
   module Completion
+    # Generate completions for Fish
     class FishCompletions
 
       attr_accessor :commands, :global_options
@@ -137,53 +140,12 @@ module Doing
         EOFUNCTIONS
       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>.*?)$/)
-        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|
-          out << "complete -xc doing -n '__fish_doing_needs_command' -a '#{cmd[:commands].join(' ')}' -d #{Shellwords.escape(cmd[:description])}"
+        @commands.each do |cmd|
+          desc = Shellwords.escape(cmd[:description])
+          cmds = cmd[:commands].join(' ')
+          out << "complete -xc doing -n '__fish_doing_needs_command' -a '#{cmds}' -d #{desc}"
         end
 
         out.join("\n")
@@ -203,14 +165,14 @@ 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)
 
           if data[:synopsis].join(' ').strip.split(/ /).last =~ /(path|file)/i
             out << "complete -c doing -F -n '__fish_doing_using_command #{cmd[:commands].join(" ")}'"
           end
 
           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] ? '-r' : ''
@@ -267,11 +229,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 Fish 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 Fish 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
@@ -280,6 +243,7 @@ module Doing
         out << generate_helpers
         out << generate_subcommand_completions
         out << generate_subcommand_option_completions
+        @bar.advance(status: '✅')
         @bar.finish
         out.join("\n")
       end

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,53 +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>.*?)$/)
-        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|
@@ -98,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] ? '=' : ''
@@ -124,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