tabry 0.1.5 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fe7c5c94f54f4d6fb603a73a8ec6b8364c63b6247a9dc3f095d4359fe96b5018
-  data.tar.gz: 4a29c24624360099c44dfd5c8c1420ef701bb21ee6535dc1e7a3540315002811
+  metadata.gz: 5d76e2e99f45b1f9b964d21f0ed8820d37b973c358b032a97c3d5314afdae8a1
+  data.tar.gz: e84a7977c95fc91282291d1406ffc2e577f4c23a140e69b05f3b6fe10da4f85d
 SHA512:
-  metadata.gz: b9b58e549801135afe35686048bd3b84b76c9e41cb5ecd5dc49bff3a1c3ea3ac26f10a2187eca5775ce4aa2d02d46157c559cefc2d376267ff62ebcf630b721c
-  data.tar.gz: a21e775881c48a511363cce6690e99cd13ccb32a3b829670bf049f3de63ab6e590b351a591717bb8137f112eb0e81514f548cefb8e3a0f4a79e5339118fafb33
+  metadata.gz: d1a4d514766abadeee72d0f1db0e1de14c0bf1bc26964911460adffaa716f6a6dd9f36604632274b6a4772a3d734903af0543c8689257b214a439679a1ebb8e3
+  data.tar.gz: 23351f80640e72147ea32638327e99891aa4b46f8fedee2551ecdcadd2fb63102f6c505b430882171cd736320baac633dc7f93a26f9ccb89dfdd232c4bf6c833

data/bin/tabry-bash

@@ -3,34 +3,7 @@
 
 # Run by the tabry_bash_core.sh bash tab completion function to plug into Tabry
 # to get completion options.
-
-require "shellwords"
-require "yaml"
-require_relative "../lib/tabry/util"
-require_relative "../lib/tabry/runner"
-require_relative "../lib/tabry/shell_splitter"
-
 # Bash-specific entrypoint, taking COMP_WORDS and COMP_CWORDS and returning possible options
 
-cmd_line, comp_point = ARGV
-cmd_name, args, last_arg = Tabry::ShellSplitter.split(cmd_line, comp_point)
-opts = Tabry::Runner.new(config_name: cmd_name).options(args, last_arg)
-
-if Tabry::Util.debug?
-  require "json"
-  $stderr.puts
-  warn "debug: got command line and comp_point: #{cmd_line.inspect}, #{comp_point}"
-  warn "using args: #{args.inspect}"
-  warn "using lastarg: #{last_arg.inspect}"
-  warn "results from Tabry#options(): #{opts.inspect}"
-  warn "--- end debug output ---"
-end
-
-normal_opts = opts.select { |t| t.is_a?(String) }
-special_opts = opts.select { |t| t.is_a?(Symbol) }
-
-puts normal_opts.map { |t| Shellwords.escape(t) }.join("\n")
-if special_opts.any?
-  puts
-  puts special_opts.join("\n")
-end
+require_relative "../lib/tabry/shells/bash/wrapper"
+Tabry::Bash::Wrapper.run(*ARGV)

data/bin/tabry-generate-bash-complete

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/tabry/cli/all_in_one"
+require_relative "../lib/tabry/shells/bash"
+
+Tabry::CLI::AllInOne.run do
+  config(names_underscores_to_dashes: true) do
+    desc <<~DESC
+      Generates bash completion for the tabry relative to this script
+      for the given command name and tabry JSON/YML file. Generates
+      bash functions unique to the command name to avoid conflicting with
+      other potential tabry installations.
+    DESC
+    arg :command_name, "Name of the command, e.g. 'mycli'"
+    arg :tabry_json_path, "Path to the mycli.json or mycli.yml compiled tabry file"
+    flagarg "uniq-fn-id,i", <<~DESC
+      Unique identifier to use for the unique tabry completion bash functions
+      (default is the capitalized command name)
+    DESC
+  end
+
+  def main
+    puts Tabry::Shells::Bash.generate(
+      args.command_name,
+      args.tabry_json_path,
+      uniq_fn_id: flags.uniq_fn_id,
+    )
+  end
+end
+
+

data/bin/tabry-help

@@ -11,7 +11,7 @@ require_relative "../lib/tabry/runner"
 raise "Usage: tabry-help config_name [arg1 [arg2]]..." unless ARGV.length >= 1
 
 config_name, *args = ARGV
-result = Tabry::Runner.new(config_name: config_name).parse(args)
+result = Tabry::Runner.new(config: config_name).parse(args)
 usage = result.usage(config_name)
 puts "(Usage info from tabry-help; running command directly may provide more help)\n\n"
 puts usage

data/bin/tabry-test-options

@@ -6,4 +6,4 @@ require_relative "../lib/tabry/runner"
 raise "Usage: tabry-test-options config_name arg1 [arg2]..." unless ARGV.length >= 1
 
 config_name, *args, last = ARGV
-puts Tabry::Runner.new(config_name: config_name).options(args, last).inspect
+puts Tabry::Runner.new(config: config_name).options(args, last).inspect

data/bin/tabry-test-parse

@@ -8,7 +8,7 @@ require_relative "../lib/tabry/runner"
 raise "Usage: tabry-test-parse config_name arg1 [arg2]..." unless ARGV.length >= 1
 
 config_name, *args = ARGV
-runner = Tabry::Runner.new(config_name: config_name)
+runner = Tabry::Runner.new(config: config_name)
 result = runner.parse(args)
 
 puts result.state

data/lib/tabry/cli/all_in_one.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "builder"
+require_relative "../config_builder"
+
+# Define a Tabry Config + CLI in one call to build or run. The block passed in should define
+# your CLI methods and include a call to `config` with a tabry config or block that defines
+# one (passed on to Tabry::ConfigBuilder)
+module Tabry
+  module CLI
+    module AllInOne
+      class AllInOneBase < Base
+        def self.config(opts = {}, &blk)
+          require_relative "../models/config"
+          if opts.is_a?(Tabry::Models::Config)
+            conf = opts
+          else
+            require_relative "../config_builder"
+            conf = Tabry::ConfigBuilder.build(**opts, &blk)
+          end
+
+          # Set it in the CLI class itself so AllInOne.build can find it
+          instance_variable_set(:@tabry_all_in_one_config, conf)
+
+          # Hack to avoid processing block any more if only running completion
+          # That way you an have expensive requires after the include
+          if (ARGV.first == "completion") && ARGV.length == 3 && ARGV[2].to_s =~ /^[0-9]+$/
+            throw :run_completion, true
+          end
+        end
+      end
+
+      # Creates and runs a CLI whose only purpose is to create a completion
+      # wrapper for another program
+      def self.completion_only(completion_conf = nil, **opts, &cmd_conf_blk)
+        completion_conf ||= Tabry::ConfigBuilder.build(**opts, &cmd_conf_blk)
+        cmd_name = completion_conf.cmd or raise "cmd is mandatory for completion_only configs"
+
+        cli_class = Class.new(Tabry::CLI::Base)
+        cli_conf = Tabry::ConfigBuilder.build { completion }
+        define_completion_methods(cli_class, completion_conf, cmd_name: cmd_name)
+        Tabry::CLI::Builder.new(cli_conf, cli_class).run(ARGV)
+      end
+
+      def self.define_completion_methods(cli_class, config, cmd_name: nil)
+        cli_class.module_eval do
+          define_method :completion__bash do
+            require_relative "../shells/bash"
+            Kernel.puts Tabry::Shells::Bash.generate_self(cmd_name: cmd_name)
+          end
+
+          define_method :completion do
+            require_relative "../shells/bash/wrapper"
+            Tabry::Bash::Wrapper.run(args.cmd_line, args.comp_point, config: config)
+          end
+        end
+      end
+
+      # Instead of passing in config, you can also run `config` with a block or a config option
+      # in inside blk. Doing this will also enable the "run completion fast" (see config method)
+      def self.build(cli: nil, config: nil, &blk)
+        # def self.build(cli: nil, config: nil, &blk)
+        cli ||= Class.new(AllInOneBase)
+
+        # If block given. run it to define the CLI methods and/or setting the config
+        # with a call to AllInOneBase.config
+        if blk
+          run_completion = catch(:run_completion) do
+            cli.module_eval(&blk)
+            nil
+          end
+        end
+
+        config ||= cli.instance_variable_get(:@tabry_all_in_one_config)
+
+        # If we recognize command is going to be a completion command, fast track and
+        # run completion now
+        if run_completion
+          require_relative "../shells/bash/wrapper"
+          Tabry::Bash::Wrapper.run(ARGV[1], ARGV[2], config: config)
+        end
+
+        # If we recognize there is a "completion" subcommand, add completion
+        # methods -- if not already defined by caller in the block
+        if config.main.subs.by_name["completion"] && !cli.instance_methods.include?(:completion__bash)
+          define_completion_methods(cli, config)
+        end
+
+        Tabry::CLI::Builder.new(config, cli)
+      end
+
+      def self.run(**kwargs, &blk)
+        build(**kwargs, &blk).run(ARGV)
+      end
+    end
+  end
+end

data/lib/tabry/cli/arg_proxy.rb

@@ -15,8 +15,8 @@ module Tabry
         @reqd_arg_proxy = ArgProxy.new(args, named_args, reqd: true) unless @reqd
       end
 
-      def each(...)
-        @args.each(...)
+      def each(&blk)
+        @args.each(&blk)
       end
 
       def [](key)
@@ -24,14 +24,14 @@ module Tabry
           res = @args[key]
           if @reqd && !res
             warn "FATAL: Missing required argument number #{key + 1}"
-            exit 1
+            Kernel.exit 1
           end
         else
           key = key.to_s
           res = @named_args[key]
           if @reqd && !res
             warn "FATAL: Missing required argument #{key}"
-            exit 1
+            Kernel.exit 1
           end
         end
         res

data/lib/tabry/cli/builder.rb

@@ -4,14 +4,16 @@ require_relative "../runner"
 require_relative "../util"
 require_relative "internals"
 
+# Responsible for building the CLI object, making a Runner to parse the
+# arguments, and running the proper action method of the CLI object.
 module Tabry
   module CLI
     class Builder
-      attr_reader :config, :cli_class, :runner
+      attr_reader :cli_class, :runner
 
       def initialize(config_name, cli_class)
         @cli_class = cli_class
-        @runner = Tabry::Runner.new(config_name: config_name)
+        @runner = Tabry::Runner.new(config: config_name)
       end
 
       DISALLOWED_SUBCOMMAND_NAMES = %w[args flags internals].freeze
@@ -28,7 +30,7 @@ module Tabry
         ::Tabry::Util.debug "named_args: #{result.named_args.inspect}"
 
         internals = Internals.new(
-          runner: runner, config: config, raw_args: raw_args,
+          runner: runner, raw_args: raw_args,
           state: state, met: met, result: result
         )
 
@@ -43,12 +45,12 @@ module Tabry
       def check_for_correct_usage(result)
         if result.help?
           puts result.usage(File.basename($0))
-          exit 0
+          Kernel.exit 0
         elsif result.invalid_usage_reason
           puts "Invalid usage: #{result.invalid_usage_reason}"
           puts
           puts result.usage(File.basename($0))
-          exit(1)
+          Kernel.exit(1)
         end
       end
 
@@ -63,7 +65,7 @@ module Tabry
       def get_cli_object_and_met(cli, met, internals)
         if DISALLOWED_SUBCOMMAND_NAMES.include?(met)
           warn %(FATAL: Tabry does not support top-level subcommands named: #{DISALLOWED_SUBCOMMAND_NAMES.join(",")})
-          exit 1
+          Kernel.exit 1
         end
 
         return [cli, "main"] if met.to_s == ""
@@ -90,7 +92,7 @@ module Tabry
           run_hooks(cli, met, :@after_actions)
         else
           warn %(FATAL: CLI does not support command #{met})
-          exit 1
+          Kernel.exit 1
         end
       end
 

data/lib/tabry/cli/internals.rb

@@ -3,7 +3,7 @@
 module Tabry
   module CLI
     Internals = Struct.new(
-      :runner, :config_name, :config, :raw_args, :state, :met, :result,
+      :runner, :raw_args, :state, :met, :result,
       keyword_init: true
     )
   end

data/lib/tabry/cli/util.rb

@@ -8,7 +8,7 @@ module Tabry
     module Util
       module_function
 
-      def make_cmdline(cmdline, *args, echo: false, echo_only: false)
+      def make_cmdline(cmdline, *args, echo: false, echo_only: false, merge_stderr: false)
         # Allow to pass in an array, or varargs:
         args = args.first if args.length == 1 && args.first.is_a?(Array)
 
@@ -21,6 +21,7 @@ module Tabry
           end
         end
         cmdline = cmdline % args
+        cmdline = "{ #{cmdline} ;} 2>&1" if merge_stderr
 
         warn cmdline if echo || echo_only
         return nil if echo_only
@@ -35,26 +36,38 @@ module Tabry
 
       # TODO: would be nice to get separate STDERR and STDOUT
       def backtick_or_die(*cmdline, **opts)
-        backtick_with_process_status(*cmdline, **opts).first
+        backtick_with_status(*cmdline, valid_statuses: [0], **opts).first
       end
 
-      def backtick_with_process_status(*cmdline, valid_statuses: [0], **opts)
+      def backtick_with_status(*cmdline, valid_statuses: nil, **opts)
         cmdline = make_cmdline(*cmdline, **opts)
         return [nil, nil] unless cmdline
 
-        res = `#{cmdline}`
+        enoent_error = false
+        begin
+          res = `#{cmdline}`
+        rescue Errno::ENOENT
+          enoent_error = true
+        end
+
         status = $?
         if valid_statuses && !valid_statuses.include?(status.exitstatus)
-          warn "COMMAND FAILED with exit code #{status.exitstatus}: #{cmdline}"
-          exit 1
+          msg = "COMMAND FAILED with exit code #{status.exitstatus}"
+          msg += " (command does not exist)" if enoent_error
+          Kernel.warn "#{msg}: #{cmdline}"
+          Kernel.warn "Command output:\n#{res}"
+          Kernel.exit 1
         end
         [res, status]
       end
 
-      def open_web_page(url)
-        command = RUBY_PLATFORM.include?("linux") ? "xdg-open" : "open"
-        unless system("(%s %s 2>&1) >/dev/null", command, url)
-          warn "WARNING: opening web page failed: #{make_cmdline("%s %s", command, url)}"
+      def open_command
+        RUBY_PLATFORM.include?("linux") ? "xdg-open" : "open"
+      end
+
+      def open_web_page(url_or_urls)
+        unless system("(%s %s 2>&1) >/dev/null", open_command, url_or_urls)
+          warn "WARNING: opening web page failed: #{make_cmdline("%s %s", open_command, url)}"
         end
       end
     end

data/lib/tabry/config_builder/arg_or_flag_builder.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "generic_builder"
+
+module Tabry
+  module ConfigBuilder
+    class ArgOrFlagBuilder < GenericBuilder
+      init_setters :name, :description, split_name_to_aliases: true
+      simple_setter :desc, :description
+      simple_setter :title
+
+      def _include(inc)
+        _append :options, { "type" => "include", "value" => inc }
+      end
+
+      def opts(opt_hashes)
+        _append :options, *opt_hashes
+      end
+
+      def shell(cmd)
+        [{ "type" => "shell", "value" => cmd.to_s }]
+      end
+
+      def file
+        [{ "type" => "file" }]
+      end
+
+      def dir
+        [{ "type" => "dir" }]
+      end
+
+      def const(opts)
+        [opts].flatten.map do |opt|
+          [{ "type" => "const", "value" => opt.to_s }]
+        end
+      end
+    end
+  end
+end

data/lib/tabry/config_builder/flagarg_builder.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "arg_or_flag_builder"
+
+module Tabry
+  module ConfigBuilder
+    class FlagargBuilder < ArgOrFlagBuilder
+      def _init(*args)
+        super(*args)
+        _set :arg, true
+      end
+    end
+  end
+end

data/lib/tabry/config_builder/generic_builder.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+class GenericBuilder
+  attr_reader :_opts
+
+  private_class_method :new
+  def self.build(opts = {}, *args, &blk)
+    builder = new(opts, *args)
+    builder.instance_eval(&blk) if blk
+    builder._obj.compact
+  end
+
+  # Should be used instead of MyBuilder.build to pass in opts
+  def _build(builder, *args, &blk)
+    builder.build(_opts, *args, &blk)
+  end
+
+  def _obj
+    @_obj ||= {}
+  end
+
+  def _append(list_name, *value_or_values)
+    _obj[list_name.to_s] ||= []
+    _obj[list_name.to_s].concat([value_or_values].flatten)
+    value_or_values
+  end
+
+  def _set_hash(hash_name, key, value)
+    _obj[hash_name.to_s] ||= {}
+    _obj[hash_name.to_s][key.to_s] = value
+  end
+
+  def _set(key, val)
+    val = val.chomp if val.is_a?(String)
+    val = val.to_s if val.is_a?(Symbol)
+    if _opts[:names_underscores_to_dashes] && key.to_s == "name"
+      val = val.gsub("_", "-") if val.is_a?(String)
+      val = val.map { |name| name.to_s.gsub("_", "-") } if val.is_a?(Array)
+    end
+    _obj[key.to_s] = val
+  end
+
+  def initialize(opts, *args)
+    @_opts = opts
+    includes, not_includes = args.partition { |arg| (arg.is_a?(Symbol) || arg.is_a?(String)) && arg.to_s.start_with?("@") }
+    includes.each { |arg| include(arg) }
+    _init(*not_includes) if defined?(:_init)
+  end
+
+  def self.simple_setter(name, key = nil)
+    define_method name do |value|
+      value = value.chomp if value.is_a?(String)
+      _set (key || name), value
+    end
+  end
+
+  def self.builder_appender(name, key, builder, merge: {})
+    define_method name.to_sym do |*args, &blk|
+      value = _build(builder, *args, &blk).merge(merge.transform_keys(&:to_s))
+      _append key, value
+    end
+  end
+
+  def include(inc)
+    inc_str = inc.to_s
+    raise "include must be a start with @" unless inc_str.start_with?("@")
+
+    include_name = inc_str[1..]
+    if _opts[:names_underscores_to_dashes]
+      include_name = include_name.gsub("_", "-")
+    end
+
+    _include include_name
+  end
+
+  def _include(_inc)
+    raise "_include not implemented for #{self.class}"
+  end
+
+  def _augment_list_item(list_name, item)
+    item = _obj[list_name].find { |i| i.equal?(item) }
+    yield item
+    item
+  end
+
+  def self.init_setters(*setters, split_name_to_aliases: false)
+    define_method :_init do |*args|
+      args.zip(setters) do |arg, setter|
+        _set setter, arg
+        _split_name_to_aliases if split_name_to_aliases
+      end
+    end
+  end
+
+  def _split_name_to_aliases
+    name = _obj["name"]
+    if name
+      name = name.split(/[ ,]{1,2}/) unless name.is_a?(Array)
+      _obj["name"], *aliases = name
+      aliases.each { |a| _append :aliases, a }
+    end
+  end
+end

data/lib/tabry/config_builder/sub_builder.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "arg_or_flag_builder"
+require_relative "flagarg_builder"
+require_relative "generic_builder"
+
+module Tabry
+  module ConfigBuilder
+    class SubBuilder < GenericBuilder
+      init_setters :name, :description, split_name_to_aliases: true
+      simple_setter :desc, :description
+      builder_appender :arg, :args, ArgOrFlagBuilder
+      builder_appender :opt_arg, :args, ArgOrFlagBuilder, merge: { optional: true }
+      builder_appender :varargs, :args, ArgOrFlagBuilder, merge: { varargs: true }
+      builder_appender :opt_varargs, :args, ArgOrFlagBuilder, merge: { optional: true, varargs: true }
+      builder_appender :sub, :subs, SubBuilder
+      builder_appender :flag, :flags, ArgOrFlagBuilder
+      builder_appender :flagarg, :flags, FlagargBuilder
+
+      def _include(inc)
+        %i[args flags subs].each do |thing_type|
+          _append(thing_type, { "include" => inc })
+        end
+      end
+    end
+  end
+end

data/lib/tabry/config_builder/top_level_builder.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "arg_or_flag_builder"
+require_relative "sub_builder"
+
+module Tabry
+  module ConfigBuilder
+    class TopLevelBuilder < SubBuilder
+      simple_setter :cmd
+
+      def defargs(name, &blk)
+        name = name.to_s.gsub(/^@/, "")
+        _set_hash :arg_includes, name, _build(SubBuilder, &blk)
+      end
+
+      def defopts(name, &blk)
+        name = name.to_s.gsub(/^@/, "")
+        _set_hash :option_includes, name, _build(ArgOrFlagBuilder, &blk)["options"]
+      end
+
+      def completion
+        sub :completion do
+          desc "Get tab completion shell config"
+          sub :bash, "Get tab completion for bash or zsh"
+          arg :cmd_line, "(for internal usage, when used instead of subcommand) full command line for getting completion options"
+          arg :comp_point, "(for internal usage, when used instead of subcommand) comp point"
+        end
+      end
+    end
+  end
+end

data/lib/tabry/config_builder.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "config_builder/top_level_builder"
+require_relative "models/config"
+
+module Tabry
+  module ConfigBuilder
+    def self.build(names_underscores_to_dashes: false, &blk)
+      opts = { names_underscores_to_dashes: names_underscores_to_dashes }
+      conf = TopLevelBuilder.build(opts, &blk)
+      top_level = %w[cmd arg_includes option_includes]
+      conf = conf.slice(*top_level).merge("main" => conf.reject { |k, _v| top_level.include?(k) })
+      Tabry::Models::Config.new(raw: conf)
+    end
+  end
+end

data/lib/tabry/models/config_list.rb

@@ -32,8 +32,8 @@ module Tabry
         to_a.[](*args)
       end
 
-      def each(...)
-        to_a.each(...)
+      def each(&blk)
+        to_a.each(&blk)
       end
 
       def length

data/lib/tabry/models/config_string_hash.rb

@@ -28,8 +28,8 @@ module Tabry
         to_h.[](*args)
       end
 
-      def each(...)
-        to_h.each(...)
+      def each(&blk)
+        to_h.each(&blk)
       end
 
       def empty?

data/lib/tabry/runner.rb

@@ -11,8 +11,12 @@ module Tabry
   class Runner
     attr_reader :config
 
-    def initialize(config_name:)
-      @config = ConfigLoader.load(name: config_name)
+    def initialize(config:)
+      @config = if config.is_a?(Tabry::Models::Config)
+                  config
+                else
+                  ConfigLoader.load(name: config)
+                end
     end
 
     def options(args, last = nil)