cli-template 3.1.0 → 3.2.0

data/lib/templates/colon_namespaces/lib/%underscored_name%/command.rb.tt

@@ -0,0 +1,186 @@
+require "thor"
+require "active_support" # for autoload
+require "active_support/core_ext"
+
+# Override thor's long_desc identation behavior
+# https://github.com/erikhuda/thor/issues/398
+class Thor
+  module Shell
+    class Basic
+      def print_wrapped(message, options = {})
+        message = "\n#{message}" unless message[0] == "\n"
+        stdout.puts message
+      end
+    end
+  end
+end
+
+module <%= project_class_name %>
+  class Command < Thor
+    class << self
+      # thor_args is an array of commands. Examples:
+      #   ["help"]
+      #   ["dynamodb:migrate"]
+      #
+      # Same signature as RakeCommand.perform.  Signature is a little weird
+      # with some repetition.  Examples:
+      #
+      #   <%= project_class_name %>::Main.perform("hello", ["hello"])
+      #   <%= project_class_name %>::Main.perform("dynamodb:migrate", ["migrate"])
+      #
+      def perform(full_command, thor_args)
+        config = {} # doesnt seem like config is used
+        dispatch(nil, thor_args, nil, config)
+      rescue Thor::InvocationError => e
+        puts e.message
+        puts "  ufo #{full_command} -h # for more help"
+        exit 1
+      end
+
+      # Track all command subclasses.
+      def subclasses
+        @subclasses ||= []
+      end
+
+      def inherited(base)
+        super
+
+        if base.name
+          self.subclasses << base
+        end
+      end
+
+      # Useful for help menu when we need to have all the definitions loaded.
+      # Using constantize instead of require so we dont care about
+      # order. The eager load actually uses autoloading.
+      @@eager_loaded = false
+      def eager_load!
+        return if @@eager_loaded
+
+        path = File.expand_path("../../", __FILE__)
+        Dir.glob("#{path}/<%= underscored_name %>/**/*.rb").select do |path|
+          next if !File.file?(path)
+
+          class_name = path
+                        .sub(/\.rb$/,'')
+                        .sub(%r{.*/lib/},'')
+                        .classify
+
+          if class_name.include?('-')
+            puts "WARN: Unable to autoload a class with a dash in the name" if debug?
+            next
+          end
+
+          class_name = class_map[class_name] || class_name
+
+          puts "eager_load! loading path: #{path} class_name: #{class_name}" if debug?
+          class_name.constantize # dont have to worry about order.
+        end
+
+        @@eager_loaded = true
+      end
+
+      # Special class mapping cases. This is because ActiveSupport's autoloading
+      # forces a specific naming convention.
+      def class_map
+        map = {
+          "<%= project_class_name %>::Cli" => "<%= project_class_name %>::CLI",
+          "<%= project_class_name %>::Version" => "<%= project_class_name %>::VERSION",
+          "<%= project_class_name %>::Completion" => "<%= project_class_name %>::Completions",
+        }
+        map.merge(additional_class_map)
+        map
+      end
+
+      # Override this if you need add addtional class mappings.
+      def additional_class_map
+        {}
+      end
+
+      # Fully qualifed task names. Examples:
+      #   hello
+      #   sub:goodbye
+      def namespaced_commands
+        eager_load!
+        subclasses.map do |klass|
+          klass.all_tasks.keys.map do |task_name|
+            klass = klass.to_s.sub('<%= project_class_name %>::','')
+            namespace = klass =~ /^Main/ ? nil : klass.underscore.gsub('/',':')
+            [namespace, task_name].compact.join(':')
+          end
+        end.flatten.sort
+      end
+
+      # Use <%= project_class_name %> banner instead of Thor to account for namespaces in commands.
+      def banner(command, namespace = nil, subcommand = false)
+        namespace = namespace_from_class(self)
+        command_name = command.usage # set with desc when defining tht Thor class
+        namespaced_command = [namespace, command_name].compact.join(':')
+
+        "<%= project_name %> #{namespaced_command}"
+      end
+
+      def namespace_from_class(klass)
+        namespace = klass.to_s.sub('<%= project_class_name %>::', '').underscore.gsub('/',':')
+        namespace unless namespace == "main"
+      end
+
+      def help_list(all=false)
+        # hack to show hidden comands when requested
+        Thor::HiddenCommand.class_eval do
+          def hidden?; false; end
+        end if all
+
+        list = []
+        eager_load!
+        subclasses.each do |klass|
+          commands = klass.printable_commands(true, false)
+          commands.reject! { |array| array[0].include?(':help') }
+          list += commands
+        end
+
+        list.sort_by! { |array| array[0] }
+      end
+
+      # Example:
+      #    klass_from_namespace(nil) => Main
+      #    klass_from_namespace("sub") => Sub
+      def klass_from_namespace(namespace)
+        if namespace.nil?
+          <%= project_class_name %>::Main
+        else
+          class_name = namespace.gsub(':','/')
+          class_name = "<%= project_class_name %>::#{class_name.classify}"
+          class_name = class_map[class_name] || class_name
+          class_name.constantize
+        end
+      end
+
+      # If this fails to match then it'l just return the original full command
+      def autocomplete(full_command)
+        return nil if full_command.nil? # <%= project_name %> help
+
+        eager_load!
+
+        words = full_command.split(':')
+        namespace = words[0..-2].join(':') if words.size > 1
+        command = words.last
+
+        # Thor's normalize_command_name autocompletes the command but then we need to add the namespace back
+        begin
+          thor_subclass = klass_from_namespace(namespace) # could NameError
+          command = thor_subclass.normalize_command_name(command) # could Thor::AmbiguousCommandError
+          [namespace, command].compact.join(':')
+        rescue NameError
+          full_command # return original full_command
+        rescue Thor::AmbiguousCommandError => e
+          full_command # return original full_command
+        end
+      end
+
+      def debug?
+        ENV['DEBUG'] && !ENV['TEST']
+      end
+    end
+  end
+end

data/lib/templates/colon_namespaces/lib/%underscored_name%/completer.rb.tt

@@ -0,0 +1,145 @@
+# Code Explanation.  This is mainly focused on the run method.
+#
+# There are 3 main branches of logic for completions:
+#
+#   1. top-level commands - when there are zero completed words
+#   2. params completions - when a command has some required params
+#   3. options completions - when we have finished auto-completing the top-level command and required params, the rest of the completion words will be options
+#
+# Terms:
+#
+#   params - these are params in the command itself. Example: for the method `scale(service, count)` the params would be `service, count`.
+#   options - these are cli options flags.  Examples: --noop, --verbose
+#
+# When we are done processing method params, the completions will be only options. When the detected params size is greater than the arity we are have finished auto-completing the parameters in the method declaration.  For example, say you had a method for a CLI command with the following form:
+#
+#   scale(service, count) = arity of 2
+#
+#   <%= project_name %> scale service count [TAB] # there are 3 params including the "scale" command
+#
+# So the completions will be something like:
+#
+#   --noop --verbose etc
+#
+# A note about artity values:
+#
+# We are using the arity of the command method to determine if we have finish auto-completing the params completions. When the ruby method has a splat param, it's arity will be negative.  Here are some example methods and their arities.
+#
+#    ship(service) = 1
+#    scale(service, count) = 2
+#    ships(*services) = -1
+#    foo(example, *rest) = -2
+#
+# Fortunately, negative and positive arity values are processed the same way. So we take simply take the abs of the arity.
+#
+# To test:
+#
+#   <%= project_name %> completions
+#   <%= project_name %> completions hello
+#   <%= project_name %> completions hello name
+#   <%= project_name %> completions hello name --
+#   <%= project_name %> completions hello name --noop
+#
+#   <%= project_name %> completions
+#   <%= project_name %> completions sub:goodbye
+#   <%= project_name %> completions sub:goodbye name
+#
+# Note when testing, the first top-level word must be an exact match
+#
+#   <%= project_name %> completions hello # works fine
+#   <%= project_name %> completions he # incomplete, this will just break
+#
+# The completions assumes that the top-level word that is being passed in
+# from completor/scripts.sh will always match exactly.  This must be the
+# case.  For parameters, the word does not have to match exactly.
+#
+module <%= project_class_name %>
+  class Completer
+    autoload :Script, '<%= underscored_name %>/completer/script'
+
+    def initialize(*params)
+      @params = params
+    end
+
+    def run
+      if @params.size == 0
+        puts all_commands
+        return
+      end
+
+      # will only get to here if the top-level command has been fully auto-completed.
+      arity = command_class.instance_method(trailing_command).arity.abs
+      if @params.size <= arity
+        puts params_completions(current_command)
+      else
+        puts options_completions(current_command)
+      end
+    end
+
+    # all top-level commands
+    def all_commands
+      # Interesing, extra :help commands show up here but no whne using
+      # <%= project_class_name %>::Command.help_list in main_help -> thor_list
+      # We'll filter out :help for auto-completion.
+      commands = <%= project_class_name %>::Command.namespaced_commands
+      commands.reject { |c| c =~ /:help$/ }
+    end
+
+    def params_completions(current_command)
+      method_params = command_class.instance_method(trailing_command).parameters
+      # Example:
+      # >> Sub.instance_method(:goodbye).parameters
+      # => [[:req, :name]]
+      # >>
+      method_params.map!(&:last)
+
+      offset = @params.size - 1
+      offset_params = method_params[offset..-1]
+      method_params[offset..-1].first
+    end
+
+    def options_completions(current_command)
+      used = ARGV.select { |a| a.include?('--') } # so we can remove used options
+
+      method_options = command_class.all_commands[trailing_command].options.keys
+      class_options = command_class.class_options.keys
+
+      all_options = method_options + class_options + ['help']
+
+      all_options.map! { |o| "--#{o.to_s.dasherize}" }
+      filtered_options = all_options - used
+      filtered_options.uniq
+    end
+
+    def current_command
+      @params[0]
+    end
+
+    # Example: sub:goodbye => "sub"
+    def namespace
+      return nil unless current_command
+
+      if current_command.include?(':')
+        words = current_command.split(':')
+        words.pop
+        words.join(':')
+      end
+    end
+
+    # Example: sub:goodbye => "goodbye"
+    def trailing_command
+      current_command.split(':').last
+    end
+
+    def command_class
+      @command_class ||= <%= project_class_name %>::Command.klass_from_namespace(namespace)
+    end
+
+    # Useful for debugging. Using puts messes up completion.
+    def log(msg)
+      File.open("/tmp/complete.log", "a") do |file|
+        file.puts(msg)
+      end
+    end
+  end
+end

data/lib/templates/colon_namespaces/lib/%underscored_name%/completer/script.rb.tt

@@ -0,0 +1,6 @@
+class <%= project_class_name %>::Completer::Script
+  def self.generate
+    bash_script = File.expand_path("script.sh", File.dirname(__FILE__))
+    puts "source #{bash_script}"
+  end
+end

data/lib/templates/colon_namespaces/lib/%underscored_name%/completer/script.sh.tt

@@ -0,0 +1,16 @@
+_<%= project_name %>() {
+  COMPREPLY=()
+  local word="${COMP_WORDS[COMP_CWORD]}"
+
+  if [ "$COMP_CWORD" -eq 1 ]; then
+    local completions=$(<%= project_name %> completions)
+    COMPREPLY=( $(compgen -W "$completions" -- "$word") )
+  else
+    local words=("${COMP_WORDS[@]}")
+    unset words[0]
+    local completions=$(<%= project_name %> completions ${words[@]})
+    COMPREPLY=( $(compgen -W "$completions" -- "$word") )
+  fi
+}
+
+complete -F _<%= project_name %> <%= project_name %>

data/lib/templates/colon_namespaces/lib/%underscored_name%/help.rb.tt

@@ -0,0 +1,9 @@
+module <%= project_class_name %>::Help
+  class << self
+    def text(namespaced_command)
+      path = namespaced_command.to_s.gsub(':','/')
+      path = File.expand_path("../help/#{path}.md", __FILE__)
+      IO.read(path) if File.exist?(path)
+    end
+  end
+end

data/lib/templates/colon_namespaces/lib/%underscored_name%/help/hello.md.tt

@@ -0,0 +1,5 @@
+Examples:
+
+  <%= project_name %> hello
+  <%= project_name %> hello NAME
+  <%= project_name %> hello NAME --from me

data/lib/templates/colon_namespaces/lib/%underscored_name%/help/main.md.tt

@@ -0,0 +1,5 @@
+Add -h to any of the commands for more help.  Examples:
+
+  <%= project_name %> hello -h
+  <%= project_name %> version
+  <%= project_name %> -h

data/lib/templates/colon_namespaces/lib/%underscored_name%/help/sub/goodbye.md.tt

@@ -0,0 +1,5 @@
+Examples:
+
+  <%= project_name %> sub:goodbye
+  <%= project_name %> sub:goodbye NAME
+  <%= project_name %> sub:goodbye NAME --from me

data/lib/templates/colon_namespaces/lib/%underscored_name%/sub.rb.tt

@@ -0,0 +1,12 @@
+module <%= project_class_name %>
+  class Sub < Command
+
+    desc "goodbye NAME", "say goodbye to NAME"
+    long_desc Help.text("sub:goodbye")
+    option :from, desc: "from person"
+    def goodbye(name="you")
+      puts "from: #{options[:from]}" if options[:from]
+      puts "Goodbye #{name}"
+    end
+  end
+end

data/lib/templates/colon_namespaces/lib/%underscored_name%/version.rb.tt

@@ -0,0 +1,3 @@
+module <%= project_class_name %>
+  VERSION = "0.1.0"
+end

data/lib/templates/colon_namespaces/spec/lib/cli_spec.rb.tt

@@ -0,0 +1,37 @@
+require "spec_helper"
+
+describe <%= project_class_name %>::CLI do
+  before(:all) do
+    @args = "--from Tung"
+  end
+
+  describe "<%= project_name %>" do
+    it "hello" do
+      out = execute("exe/<%= project_name %> hello world #{@args}")
+      expect(out).to include("from: Tung\nHello world")
+    end
+
+    it "goodbye" do
+      out = execute("exe/<%= project_name %> sub:goodbye world #{@args}")
+      expect(out).to include("from: Tung\nGoodbye world")
+    end
+
+    it "completions" do
+      out = execute("exe/<%= project_name %> completions")
+      expect(out).to include("hello")
+      expect(out).to include("sub:goodbye")
+
+      out = execute("exe/<%= project_name %> completions hello")
+      expect(out).to include("name")
+
+      out = execute("exe/<%= project_name %> completions hello name")
+      expect(out).to include("--from")
+
+      out = execute("exe/<%= project_name %> completions sub:goodbye")
+      expect(out).to include("name")
+
+      out = execute("exe/<%= project_name %> completions sub:goodbye name")
+      expect(out).to include("--from")
+    end
+  end
+end