tabry 0.1.0

data/lib/tabry/models/include_sub.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Tabry
+  module Models
+    class IncludeSub
+      attr_reader :include_name, :_root
+
+      def initialize(raw:, root:)
+        @include_name = raw["include"]
+        @_root = root
+      end
+
+      def flatten
+        _root.arg_includes[include_name].subs.flatten
+      end
+    end
+  end
+end

data/lib/tabry/models/option.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "config_error"
+require_relative "const_option"
+require_relative "shell_option"
+require_relative "include_option"
+require_relative "file_option"
+require_relative "dir_option"
+
+module Tabry
+  module Models
+    module Option
+      def self.new(**args)
+        # TODO: assert type
+        hash = args[:raw]
+        case hash["type"]
+        when "const"
+          ConstOption.new(**args)
+        when "shell"
+          ShellOption.new(**args)
+        when "include"
+          IncludeOption.new(**args)
+        when "file"
+          FileOption.new(**args)
+        when "dir"
+          DirOption.new(**args)
+        else
+          raise ConfigError, "unknown option type #{hash["type"]}"
+        end
+      end
+    end
+  end
+end

data/lib/tabry/models/option_base.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "config_object"
+
+module Tabry
+  module Models
+    class OptionBase < ConfigObject
+      FIELDS = {
+        type: :string,
+        value: :string,
+      }.freeze
+
+      attr_reader(*FIELDS.keys)
+
+      def flatten
+        self
+      end
+    end
+  end
+end

data/lib/tabry/models/option_includes.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "config_string_hash"
+require_relative "options_list"
+
+module Tabry
+  module Models
+    class OptionIncludes < ConfigStringHash
+      def initialize(**args)
+        super(**args, klass: OptionsList)
+      end
+    end
+  end
+end

data/lib/tabry/models/options_list.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "config_list"
+require_relative "option"
+
+module Tabry
+  module Models
+    class OptionsList < ConfigList
+      def initialize(**args)
+        super(**args, klass: Option)
+      end
+
+      def options(token)
+        to_a.map { |option| option.options(token) }.inject(&:|)
+      end
+    end
+  end
+end

data/lib/tabry/models/shell_option.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "option_base"
+
+module Tabry
+  module Models
+    class ShellOption < OptionBase
+      def options(token)
+        `#{value}`.chomp.split("\n").select { |opt| opt.start_with?(token) }
+      end
+    end
+  end
+end

data/lib/tabry/models/sub.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative "args_list"
+require_relative "flags_list"
+require_relative "subs_list"
+require_relative "include_sub"
+
+module Tabry
+  module Models
+    class Sub < ConfigObject
+      def self.new(**args)
+        hash = args[:raw]
+        if hash["include"]
+          IncludeSub.new(**args)
+        else
+          super(**args)
+        end
+      end
+
+      FIELDS = {
+        aliases: :string_array,
+        args: [:list_object, :ArgsList],
+        description: :string,
+        flags: [:list_object, :FlagsList],
+        name: :string,
+        subs: [:list_object, :SubsList],
+      }.freeze
+
+      attr_reader(*FIELDS.keys)
+
+      # TODO: put this default stuff into ConfigObject
+      def subs
+        @subs ||= SubsList.new(raw: [], root: _root)
+      end
+
+      def flags
+        @flags ||= FlagsList.new(raw: [], root: _root)
+      end
+
+      def args
+        @args ||= ArgsList.new(raw: [], root: _root)
+      end
+
+      def flatten
+        self
+      end
+
+      def min_args
+        args.reject(&:optional).count
+      end
+
+      def max_args
+        return Float::INFINITY if args.any?(&:varargs?)
+
+        args.count
+      end
+    end
+  end
+end

data/lib/tabry/models/subs_list.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "config_list"
+require_relative "sub"
+
+module Tabry
+  module Models
+    class SubsList < ConfigList
+      def initialize(**args)
+        super(**args, klass: Sub)
+      end
+
+      def by_name
+        @by_name ||= to_a.to_h { |sub| [sub.name, sub] }
+      end
+
+      def match(token)
+        to_a.find do |sub|
+          [sub.name, *sub.aliases].include?(token)
+        end
+      end
+
+      def options(token)
+        to_a.map(&:name).select { |name| name.start_with?(token) }
+      end
+    end
+  end
+end

data/lib/tabry/options_finder.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Tabry
+  class OptionsFinder
+    attr_reader :result
+
+    # Returns an array of options
+    def self.options(result, token)
+      new(result).options(token)
+    end
+
+    def initialize(result)
+      @result = result
+    end
+
+    def options(token)
+      # Bit of a hack: send this down to autocomplete shell commands
+      # TODO: set this only in ShellOption -- would require passing state down on thru
+      ENV["TABRY_AUTOCOMPLETE_STATE"] = {
+        cmd: result.config.cmd,
+        flags: result.state.flags,
+        args: result.state.args,
+        current_flag: result.state.current_flag
+      }.to_json
+
+      send(:"options_#{state.mode}", token || "")
+    end
+
+    private
+
+    def state
+      result.state
+    end
+
+    def current_sub
+      @current_sub ||= result.current_sub
+    end
+
+    def options_subcommand(token)
+      if token.to_s == ""
+        result.sub_stack.each do |sub|
+          required_flag = sub.flags.first_required_flag(used: state.flags)
+          if required_flag
+            return [required_flag.name_with_dashes]
+          end
+        end
+      end
+
+      options_subcommand_subs(token) |
+        options_subcommand_flags(token) |
+        options_subcommand_args(token)
+    end
+
+    def options_flagarg(token)
+      result.sub_stack.map do |sub|
+        sub.flags[state.current_flag]&.options&.options(token)
+      end.compact.flatten.uniq
+    end
+
+    def options_subcommand_subs(token)
+      if state.args.any?
+        # once an arg has been given, can no longer use a subcommand
+        []
+      else
+        current_sub.subs.options(token)
+      end
+    end
+
+    def options_subcommand_flags(token)
+      return [] if state.dashdash
+
+      result.sub_stack.map { |sub| sub.flags.options(token, used: state.flags) }.flatten.uniq
+    end
+
+    def options_subcommand_args(token)
+      arg = if current_sub.args.n_passed_in_varargs(state.args.length) > 0
+              current_sub.args.varargs_arg
+            else
+              current_sub.args[state.args.length]
+            end
+
+      arg&.options&.options(token) || []
+    end
+  end
+end

data/lib/tabry/result.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require_relative "usage_generator"
+
+# Encapsulates a config and state, often representing the end state (except
+# when you call options()), and adds functionality regarding this state.
+module Tabry
+  class Result
+    attr_reader :config, :state
+
+    def initialize(config, state)
+      @config = config
+      @state = state
+    end
+
+    def current_sub
+      @current_sub ||= sub_stack.last
+    end
+
+    def sub_stack
+      @sub_stack ||= config.dig_sub_array(state.subcommand_stack)
+    end
+
+    def invalid_usage_reason
+      waiting_on_flag_arg? ||
+        wrong_number_of_args? ||
+        missing_required_flags?
+    end
+
+    def waiting_on_flag_arg?
+      if state.mode != :subcommand
+        "arg required for flag #{state.current_flag}"
+      end
+    end
+
+    def wrong_number_of_args?
+      n_args = state.args.length
+      if n_args == 0 && current_sub.subs.any?
+        if current_sub.args.any?
+          "missing subcommand or arg(s)"
+        else
+          "missing subcommand"
+        end
+      elsif !(current_sub.min_args..current_sub.max_args).include?(n_args)
+        if n_args == 0
+          if current_sub.max_args == 1
+            msg = "missing argument"
+            msg += " #{current_sub.args[0].name.inspect}" if current_sub.args[0].name
+            msg
+          elsif current_sub.min_args == 1
+            "missing one or more args"
+          else
+            "missing args"
+          end
+        else
+          "got #{state.args.count} args, " \
+            "must be between #{current_sub.min_args} and #{current_sub.max_args}"
+        end
+      end
+    end
+
+    def non_varargs
+      @non_varargs ||= state.args.first(state.args.length - n_passed_in_varargs)
+    end
+
+    def varargs
+      @varargs ||= state.args.last(n_passed_in_varargs)
+    end
+
+    def n_passed_in_varargs
+      current_sub.args.n_passed_in_varargs(state.args.count)
+    end
+
+    def missing_required_flags?
+      current_sub.flags.each do |flag|
+        if flag.required && !state.flags[flag.name]
+          return "missing required flag #{flag.name}"
+        end
+      end
+      nil
+    end
+
+    def usage(cmd_name = nil)
+      cmd_name ||= config.cmd
+      Tabry::UsageGenerator.new(sub_stack, cmd_name).usage
+    end
+
+    def top_level?
+      state.subcommand_stack.empty?
+    end
+
+    def help?
+      state.help
+    end
+
+    def named_args
+      @named_args ||= {}.tap do |res|
+        if (varargs_name = current_sub.args.varargs_arg&.name)
+          res[varargs_name] = varargs
+        end
+
+        non_varargs.each_with_index do |arg_val, i|
+          if (arg_name = current_sub.args[i]&.name)
+            res[arg_name] = arg_val
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tabry/runner.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "config_loader"
+require_relative "machine"
+require_relative "options_finder"
+require_relative "result"
+
+# Loads a config, runs the machine, creates a Result object to encapsulate results.
+# Also options() convenience function
+module Tabry
+  class Runner
+    attr_reader :config
+
+    def initialize(config_name:)
+      @config = ConfigLoader.load(name: config_name)
+    end
+
+    def options(args, last = nil)
+      Tabry::OptionsFinder.options(parse(args), last)
+    end
+
+    def parse(args)
+      state = Tabry::Machine.run(config, args)
+      Tabry::Result.new(config, state)
+    end
+  end
+end

data/lib/tabry/state.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Tabry
+  State = Struct.new(
+    :mode,
+    :subcommand_stack,
+    :args,
+    :flags,
+    :current_flag,
+    :dashdash,
+    :help,
+    keyword_init: true
+  )
+end

data/lib/tabry/usage_generator.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require_relative "core_ext/string/colors"
+
+module Tabry
+  class UsageGenerator
+    attr_reader :sub, :cmdline_string, :top_level, :sub_stack
+
+    def initialize(sub_stack, cmd_name)
+      @sub_stack = sub_stack
+      @sub = sub_stack.last
+      non_main_subs = sub_stack[1..]
+      @cmdline_string = [cmd_name, *non_main_subs.map(&:name)].join(" ")
+      @top_level = sub_stack.length == 1
+    end
+
+    USAGE = "Usage:".bold
+
+    def usage
+      lines = []
+      if description
+        lines << description
+        lines << ""
+      end
+      if subs.any?
+        lines << "#{USAGE} #{cmdline_string} <subcommand> ..."
+      end
+
+      if args.any?
+        arg_strings = args.map do |a|
+          name = a.title || "arg"
+          str = "<#{name}>"
+          str += " [<#{name}>...]" if a.varargs?
+          str = "[#{str}]" if a.optional
+          str
+        end
+        lines << ["#{USAGE} #{cmdline_string}", *arg_strings].join(" ")
+      end
+
+      if subs.empty? && args.empty?
+        lines << "#{USAGE} #{cmdline_string}"
+      end
+
+      usage_add_subcommands(lines, top_level)
+      usage_add_args(lines)
+      usage_add_flags(lines)
+
+      lines.join("\n")
+    end
+
+    def add_text_with_indent(lines, text, indent_string)
+      return unless text
+
+      text.split("\n").each do |line|
+        lines << (indent_string + line)
+      end
+    end
+
+    def usage_add_subcommands(lines, top_level)
+      if subs.any? || top_level
+        lines << ""
+        lines << "SUBCOMMANDS".green.bold
+      end
+
+      subs_by_name = subs.by_name
+      sub_names = subs_by_name.keys
+      sub_names |= ["help"] if top_level
+
+      sub_names.sort.each do |name|
+        if (s = subs_by_name[name])
+          name_line = name.bold
+          if s.aliases&.length == 1
+            name_line += " (alias: #{s.aliases.first})"
+          elsif s.aliases
+            name_line += " (aliases: #{s.aliases.join(", ")})"
+          end
+
+          lines << name_line
+          add_text_with_indent(lines, s.description, "  ")
+        elsif name == "help"
+          lines << "help".bold
+          lines << "  Show help on command or subcommand"
+        end
+      end
+    end
+
+    def usage_add_flags(lines)
+      partial_sub_stack = []
+      sub_stack_with_names = sub_stack.map do |sub|
+        partial_sub_stack << sub.name
+        [sub, partial_sub_stack.compact.join(" ")]
+      end
+
+      sub_stack_with_names.reverse.each do |sub, full_sub_name|
+        next unless sub.flags.any?
+
+        lines << ""
+        lines << "FLAGS".green.bold
+        if sub != sub_stack.last
+          lines.last << if full_sub_name == ""
+                          " (global)".green.bold
+                        else
+                          " (#{full_sub_name})".green.bold
+                        end
+        end
+
+        sub.flags.map(&:name).sort.each do |name|
+          flag = sub.flags[name]
+          flag_name = [flag.name, *flag.aliases].map { |al| flag.alias_with_dash(al).bold }.join(", ")
+          flag_name << " <arg>" if flag.arg
+          flag_name << " (required)" if flag.required
+          lines << flag_name
+          add_text_with_indent(lines, flag.description, "  ")
+        end
+      end
+    end
+
+    def usage_add_args(lines)
+      if args.any?(&:description)
+        lines << ""
+        lines << "ARGS".green.bold
+        args.each do |arg|
+          arg_name = arg.name.bold
+          arg_name += " (optional)" if arg.optional
+          lines << arg_name
+          add_text_with_indent(lines, arg.description, "  ")
+        end
+      end
+    end
+
+    %i[subs args description].each do |met|
+      define_method met do
+        sub.send met
+      end
+    end
+  end
+end

data/lib/tabry/util.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Tabry
+  module Util
+    module_function
+
+    def debug(msg)
+      warn msg if debug?
+    end
+
+    def debug?
+      !ENV["TABRY_DEBUG"].to_s.empty?
+    end
+  end
+end

data/sh/tabry_bash.sh

@@ -0,0 +1,61 @@
+#/usr/bin/env bash
+
+# Bash completion
+# _tabry_completions function is same for any command you use with tabry, you just need
+# to do `complete -F _tabry_completions mycmd` for your command. This calls the tabry-bash
+# ruby script. For more info see LANGUAGE_REFERENCE.md
+
+_tabry_bash="$( dirname "${BASH_SOURCE[0]:-${(%):-%x}}" )"/../bin/tabry-bash
+
+_tabry_completions()
+{
+  [[ -n "$TABRY_DEBUG" ]] && echo && echo -n tabry start bash: && date +%s.%N >&2
+  local saveifs="$IFS"
+  IFS=$'\n'
+
+  local result=`"$_tabry_bash" "$COMP_LINE" "$COMP_POINT"`
+  local specials
+
+  if [[ $result == *$'\n'$'\n'* ]]; then
+    # double newline signals use of specials (file, directory)
+    # Warning: fragile code ahead.
+    # Split on double-newline to get regular options and specials.
+    specials="$(echo "$result"|sed '1,/^$/d')"
+    result="$(echo "$result)"|sed '/^$/q')"
+
+    # First, add anything before the double newline in (regular options)
+    COMPREPLY=($result)
+
+    # File special
+    if [[ $'\n'$specials$'\n' == *$'\n'file$'\n'* ]]; then
+      # doesn't seem to be a "plusfiles" like there is for "plusdirs"
+      COMPREPLY+=($(compgen -A file "${COMP_WORDS[$COMP_CWORD]}"))
+    fi
+
+    # Directory special
+    if [[ $'\n'$specials$'\n' == *$'\n'directory$'\n'* ]]; then
+      # If there are only directory results, use nospace to not add a space after it,
+      # like "cd" tab completion does.
+      [[ ${#COMPREPLY[@]} -eq 0 ]] && compopt -o nospace
+      compopt -o plusdirs
+    fi
+
+    # "description_if_optionless" special: Options are are meant to be description or examples
+    # and not actual options. Add an empty option so we won't tab complete.
+    if [[ $'\n'$specials$'\n' == *$'\n'description_if_optionless$'\n'* ]]; then
+      compopt -o nosort
+      COMPREPLY+=('')
+    fi
+  else
+    COMPREPLY=($result)
+  fi
+
+  IFS="$saveifs"
+  [[ -n "$TABRY_DEBUG" ]] && echo -n tabry end bash: && date +%s.%N >&2
+}
+
+# To use: put a .json/.yml tabry config file in ~/.tabry (e.g. ~/.aws.json)
+# Then, run this script in your shell startup scripts, plus (e.g.)
+#
+# complete -F _tabry_completions aws
+

data/sh/tabry_bash_help.sh

@@ -0,0 +1,7 @@
+# 'help mycommand' -> show tabry help for a tabry-CLI or command you have a
+# tabry tab completion config for
+
+_tabry_help="$( dirname "${BASH_SOURCE[0]}" )"/../bin/tabry-help
+help() {
+  tabry-help "$@" 2>/dev/null || command help "$@"
+}

data/spec/fixtures/basiccli.json

@@ -0,0 +1 @@
+{"cmd":"basiccli","main":{"subs":[{"name":"foo","args":[{"name":"bar"}]}]}}

data/spec/fixtures/basiccli.tabry

@@ -0,0 +1,5 @@
+cmd basiccli
+
+sub foo {
+  arg bar
+}

data/spec/fixtures/basiccli2.tabry

@@ -0,0 +1,5 @@
+cmd basiccli2
+
+sub waz {
+  arg bar
+}