claide 0.5.0 → 0.6.0

data/lib/claide/command/parser.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+module CLAide
+  class Command
+    # Loads a command instances from arguments.
+    #
+    module Parser
+      # @param  [Array, ARGV] argv
+      #         A list of (remaining) parameters.
+      #
+      # @return [Command] An instance of the command class that was matched by
+      #         going through the arguments in the parameters and drilling down
+      #         command classes.
+      #
+      def self.parse(command, argv)
+        argv = ARGV.coherce(argv)
+        cmd = argv.arguments.first
+        if cmd && subcommand = command.find_subcommand(cmd)
+          argv.shift_argument
+          parse(subcommand, argv)
+        elsif command.abstract_command? && command.default_subcommand
+          load_default_subcommand(command, argv)
+        else
+          command.new(argv)
+        end
+      end
+
+      # @param  [Array, ARGV] argv
+      #         A list of (remaining) parameters.#
+      #
+      # @return [Command] Returns the default subcommand initialized with the
+      #         given arguments.
+      #
+      def self.load_default_subcommand(command, argv)
+        default_subcommand = command.default_subcommand
+        subcommand = command.find_subcommand(default_subcommand)
+        unless subcommand
+          raise 'Unable to find the default subcommand ' \
+            "`#{default_subcommand}` for command `#{self}`."
+        end
+        result = parse(subcommand, argv)
+        result.invoked_as_default = true
+        result
+      end
+    end
+  end
+end

data/lib/claide/command/plugins_helper.rb

@@ -0,0 +1,112 @@
+# encoding: utf-8
+
+module CLAide
+  class Command
+    module PluginsHelper
+      # Loads additional plugins via rubygems looking for files named after the
+      # `PLUGIN_PREFIX_plugin`.
+      #
+      def self.load_plugins(plugin_prefix)
+        paths = PluginsHelper.plugin_load_paths(plugin_prefix)
+        loaded_paths = []
+        paths.each do |path|
+          if PluginsHelper.safe_require(path)
+            loaded_paths << path
+          end
+        end
+        loaded_paths
+      end
+
+      # Returns the name and the version of the plugin with the given path.
+      #
+      # @param  [String] path
+      #         The load path of the plugin.
+      #
+      # @return [String] A string including the name and the version or a
+      #         failure message.
+      #
+      def self.plugin_info(path)
+        if gemspec = find_gemspec(path)
+          spec = Gem::Specification.load(gemspec)
+        end
+
+        if spec
+          "#{spec.name}: #{spec.version}"
+        else
+          "[!] Unable to load a specification for `#{path}`"
+        end
+      end
+
+      # @return [String] Finds the path of the gemspec of a path. The path is
+      # iterated upwards until a dir with a single gemspec is found.
+      #
+      # @param  [String] path
+      #         The load path of a plugin.
+      #
+      def self.find_gemspec(path)
+        reverse_ascending_paths(path).find do |candidate_path|
+          glob = Dir.glob("#{candidate_path}/*.gemspec")
+          if glob.count == 1
+            return glob.first
+          end
+        end
+        nil
+      end
+
+      # @return [String] Returns the list of the parents paths of a path.
+      #
+      # @param  [String] path
+      #         The path for which the list is needed.
+      #
+      def self.reverse_ascending_paths(path)
+        components = path.split('/')[0...-1]
+        progress = nil
+        components.map do |component|
+          if progress
+            progress = progress + '/' + component
+          else
+            progress = component
+          end
+        end.reverse
+      end
+
+      # Returns the paths of the files to require to load the available
+      # plugins.
+      #
+      # @return [Array] The found plugins load paths.
+      #
+      def self.plugin_load_paths(plugin_prefix)
+        if plugin_prefix && !plugin_prefix.empty?
+          if Gem.respond_to? :find_latest_files
+            Gem.find_latest_files("#{plugin_prefix}_plugin")
+          else
+            Gem.find_files("#{plugin_prefix}_plugin")
+          end
+        else
+          []
+        end
+      end
+
+      # Loads the given path. If any exception occurs it is catched and an
+      # informative message is printed.
+      #
+      # @param  [String] path
+      #         The path to load
+      #
+      # rubocop:disable RescueException
+      def self.safe_require(path)
+        require path
+        true
+      rescue Exception => exception
+        message = "\n---------------------------------------------"
+        message << "\nError loading the plugin with path `#{path}`.\n"
+        message << "\n#{exception.class} - #{exception.message}"
+        message << "\n#{exception.backtrace.join("\n")}"
+        message << "\n---------------------------------------------\n"
+        puts message.ansi.yellow
+        false
+      end
+      # rubocop:enable RescueException
+    end
+  end
+end

data/lib/claide/command/shell_completion_helper.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+require 'claide/command/shell_completion_helper/zsh_completion_generator'
+
+module CLAide
+  class Command
+    module ShellCompletionHelper
+      # Returns the completion template generated for the given command for the
+      # given shell. If the shell is not provided it will be inferred by the
+      # environment.
+      #
+      def self.completion_template(command, shell = nil)
+        shell ||= ENV['SHELL'].split('/').last
+        case shell
+        when 'zsh'
+          ZSHCompletionGenerator.generate(command)
+        else
+          raise Help, "Auto-completion generator for `#{shell}` shell not" \
+            ' implemented.'
+        end
+      end
+
+      # Indents the lines of the given string except the first one to the given
+      # level. Uses two spaces per each level.
+      #
+      # @param  [String] string
+      #         The string to indent.
+      #
+      # @param  [Fixnum] indentation
+      #         The indentation amount.
+      #
+      # @return [String] An indented string.
+      #
+      def self.indent(string, indentation)
+        string.gsub("\n", "\n#{' ' * indentation * 2}")
+      end
+    end
+  end
+end

data/lib/claide/command/shell_completion_helper/zsh_completion_generator.rb

@@ -0,0 +1,191 @@
+module CLAide
+  class Command
+    module ShellCompletionHelper
+      # Generates a completion script for the Z shell.
+      #
+      module ZSHCompletionGenerator
+        # @return [String] The completion script.
+        #
+        # @param  [Class] command
+        #         The command to generate the script for.
+        #
+        # rubocop:disable MethodLength
+        def self.generate(command)
+          result = <<-DOC.strip_margin('|')
+            |#compdef #{command.command}
+            |# setopt XTRACE VERBOSE
+            |# vim: ft=zsh sw=2 ts=2 et
+            |
+            |local -a _subcommands
+            |local -a _options
+            |
+            |#{case_statement_fragment(command)}
+          DOC
+
+          post_process(result)
+        end
+        # rubocop:enable MethodLength
+
+        # Returns a case statement for a given command with the given nesting
+        # level.
+        #
+        # @param  [Class] command
+        #         The command to generate the fragment for.
+        #
+        # @param  [Fixnum] nesting_level
+        #         The nesting level to detect the index of the words array.
+        #
+        # @return [String] the case statement fragment.
+        #
+        # @example
+        #   case "$words[2]" in
+        #     spec-file)
+        #       [..snip..]
+        #     ;;
+        #     *) # bin
+        #       _subcommands=(
+        #         "spec-file:"
+        #       )
+        #       _describe -t commands "bin subcommands" _subcommands
+        #       _options=(
+        #         "--completion-script:Print the auto-completion script"
+        #         "--help:Show help banner of specified command"
+        #         "--verbose:Show more debugging information"
+        #         "--version:Show the version of the tool"
+        #       )
+        #       _describe -t options "bin options" _options
+        #     ;;
+        #   esac
+        #
+        # rubocop:disable MethodLength
+        def self.case_statement_fragment(command, nest_level = 0)
+          entries = case_statement_entries_fragment(command, nest_level + 1)
+          subcommands = subcommands_fragment(command)
+          options = options_fragment(command)
+
+          result = <<-DOC.strip_margin('|')
+            |case "$words[#{nest_level + 2}]" in
+            |  #{ShellCompletionHelper.indent(entries, 1)}
+            |  *) # #{command.full_command}
+            |    #{ShellCompletionHelper.indent(subcommands, 2)}
+            |    #{ShellCompletionHelper.indent(options, 2)}
+            |  ;;
+            |esac
+          DOC
+          result.gsub(/\n *\n/, "\n").chomp
+        end
+        # rubocop:enable MethodLength
+
+        # Returns a case statement for a given command with the given nesting
+        # level.
+        #
+        # @param  [Class] command
+        #         The command to generate the fragment for.
+        #
+        # @param  [Fixnum] nesting_level
+        #         The nesting level to detect the index of the words array.
+        #
+        # @return [String] the case statement fragment.
+        #
+        # @example
+        #   repo)
+        #     case "$words[5]" in
+        #       *) # bin spec-file lint
+        #         _options=(
+        #           "--help:Show help banner of specified command"
+        #           "--only-errors:Skip warnings"
+        #           "--verbose:Show more debugging information"
+        #         )
+        #         _describe -t options "bin spec-file lint options" _options
+        #       ;;
+        #     esac
+        #   ;;
+        #
+        def self.case_statement_entries_fragment(command, nest_level)
+          subcommands = command.subcommands_for_command_lookup
+          subcommands.sort_by(&:name).map do |subcommand|
+            subcase = case_statement_fragment(subcommand, nest_level)
+            <<-DOC.strip_margin('|')
+              |#{subcommand.command})
+              |  #{ShellCompletionHelper.indent(subcase, 1)}
+              |;;
+            DOC
+          end.join("\n")
+        end
+
+        # Returns the fragment of the subcommands array.
+        #
+        # @param  [Class] command
+        #         The command to generate the fragment for.
+        #
+        # @return [String] The fragment.
+        #
+        def self.subcommands_fragment(command)
+          subcommands = command.subcommands_for_command_lookup
+          list = subcommands.sort_by(&:name).map do |subcommand|
+            "\"#{subcommand.command}:#{subcommand.summary}\""
+          end
+          describe_fragment(command, 'subcommands', 'commands', list)
+        end
+
+        # Returns the fragment of the options array.
+        #
+        # @param  [Class] command
+        #         The command to generate the fragment for.
+        #
+        # @return [String] The fragment.
+        #
+        def self.options_fragment(command)
+          list = command.options.sort_by(&:first).map do |option|
+            "\"#{option[0]}:#{option[1]}\""
+          end
+          describe_fragment(command, 'options', 'options', list)
+        end
+
+        # Returns the fragment for a list of completions and the ZSH
+        # `_describe` function.
+        #
+        # @param  [Class] command
+        #         The command to generate the fragment for.
+        #
+        # @param  [String] name
+        #         The name of the list.
+        #
+        # @param  [Class] tag
+        #         The ZSH tag to use (e.g. command or option).
+        #
+        # @param  [Array<String>] list
+        #         The list of the entries.
+        #
+        # @return [String] The fragment.
+        #
+        def self.describe_fragment(command, name, tag, list)
+          if list && !list.empty?
+            <<-DOC.strip_margin('|')
+              |_#{name}=(
+              |  #{ShellCompletionHelper.indent(list.join("\n"), 1)}
+              |)
+              |_describe -t #{tag} "#{command.full_command} #{name}" _#{name}
+            DOC
+          else
+            ''
+          end
+        end
+
+        # Post processes a script to remove any artifact and escape any needed
+        # character.
+        #
+        # @param  [String] string
+        #         The string to post process.
+        #
+        # @return [String] The post processed script.
+        #
+        def self.post_process(string)
+          string.gsub!(/\n *\n/, "\n\n")
+          string.gsub!(/`/, '\\\`')
+          string
+        end
+      end
+    end
+  end
+end

data/lib/claide/command/validation_helper.rb

@@ -0,0 +1,82 @@
+# encoding: utf-8
+
+module CLAide
+  class Command
+    module ValidationHelper
+      # @return [String] Returns a message including a suggestion for the given
+      #         unrecognized arguments.
+      #
+      # @param  [Array<String>] arguments
+      #         The unrecognized arguments.
+      #
+      # @param  [Class] command_class
+      #         The class of the command which encountered the unrecognized
+      #         arguments.
+      #
+      def self.argument_suggestion(arguments, command_class)
+        string = arguments.first
+        type = ARGV::Parser.argument_type(string)
+        list = suggestion_list(command_class, type)
+        suggestion = ValidationHelper.suggestion(string, list)
+        pretty_suggestion = prettify_validation_suggestion(suggestion, type)
+        string_type = type == :arg ? 'command' : 'option'
+        "Unknown #{string_type}: `#{string}`\n" \
+          "Did you mean: #{pretty_suggestion}"
+      end
+
+      # @return [Array<String>] The list of the valid arguments for a command
+      #         according to the type of the argument.
+      #
+      # @param  [Command] command_class
+      #         The class of the command for which the list of arguments is
+      #         needed.
+      #
+      # @param  [Symbol] type
+      #         The type of the argument.
+      #
+      def self.suggestion_list(command_class, type)
+        case type
+        when :option, :flag
+          command_class.options.map(&:first)
+        when :arg
+          command_class.subcommands_for_command_lookup.map(&:command)
+        end
+      end
+
+      # Returns a suggestion for a string from a list of possible elements.
+      #
+      # @return [String] string
+      #         The string for which the suggestion is needed.
+      #
+      # @param  [Array<String>] list
+      #         The list of the valid elements
+      #
+      def self.suggestion(string, list)
+        sorted = list.sort_by do |element|
+          Helper.levenshtein_distance(string, element)
+        end
+        sorted.first
+      end
+
+      # Prettifies the given validation suggestion according to the type.
+      #
+      # @param  [String] suggestion
+      #         The suggestion to prettify.
+      #
+      # @param  [Type]
+      #         The type of the suggestion: either `:command` or `:option`.
+      #
+      # @return [String] A handsome suggestion.
+      #
+      def self.prettify_validation_suggestion(suggestion, type)
+        case type
+        when :option, :flag
+          suggestion = "#{suggestion}"
+          suggestion.ansi.blue
+        when :arg
+          suggestion.ansi.green
+        end
+      end
+    end
+  end
+end