tabry 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8531aa56c6c59a5d678e280ccb39fa8fd891aadac1d4fd194d73cacee20aaa47
+  data.tar.gz: ab532e18804f52824ccebf21667aa8da6416324eaa428d58140b758e22160b6a
+SHA512:
+  metadata.gz: 62d4481040a2c2e06e5f16e0c5ef559fddf4cb6330d61d9962af8295c940d56c40bce23df662dbb168c83c48ed929fe30e1f2bf7e91ddc6fda06595c9576b63c
+  data.tar.gz: 1447eb824ec57c40b4dcc4eaeaefbd1488f514bd10535c7035f3439558f03a1368c1cf1cc7674804d2976ab9dadede3d0a818ff9e87e140cd58f67e983026ffb

data/bin/tabry-bash

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "shellwords"
+require "yaml"
+require_relative "../lib/tabry/util"
+require_relative "../lib/tabry/runner"
+
+# Bash-specific entrypoint, taking COMP_WORDS and COMP_CWORDS and returning possible options
+
+COMP_POINT_SENTINEL = "\uFFFF"
+
+# TODO: in weird scenarios this acts weird: namely, special shell operators like <(ls), $$((1 + 1))
+# Also it crashed on unbalanced quotes, like: foo "bar<TAB>
+# however, this will handle the common scenarios of escaping with quotes, single quotes, and backslashes
+# Split up args and put the argument that comp_point is in in the `last_arg` variable.
+# Just cutting off everything after comp_point might have worked, although
+# maybe we wanted the whole arg? Not sure this is the best.
+cmd_line, comp_point = ARGV
+cmd_line = cmd_line.dup
+cmd_line[comp_point.to_i...comp_point.to_i] = COMP_POINT_SENTINEL
+cmd, *all_args = Shellwords.split(cmd_line)
+last_arg_index = all_args.index { |arg| arg.include?(COMP_POINT_SENTINEL) }
+args = all_args[0..last_arg_index]
+last_arg = args.pop.gsub! COMP_POINT_SENTINEL, ""
+
+cmd_name = cmd.gsub(%r{.*/}, "")
+
+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

data/bin/tabry-help

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/tabry/runner"
+
+# Show usage information stored in a tabry configuration.
+#
+# For ease of use, source sh/tabry_bash_help.sh so you can just do
+# "help mycmd"
+
+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)
+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

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+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

data/bin/tabry-test-parse

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/tabry/runner"
+
+# Test parsing of arguments for a config
+
+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)
+result = runner.parse(args)
+
+puts result.state
+if result.invalid_usage_reason
+  puts "Invalid usage: #{result.invalid_usage_reason}"
+else
+  puts "Valid usage"
+end
+puts "Named args: #{result.named_args.inspect}"

data/lib/tabry/cli/arg_proxy.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative "flag_proxy"
+
+module Tabry
+  module CLI
+    class ArgProxy
+      include Enumerable
+
+      def initialize(args, named_args, reqd: false)
+        @args = args
+        @named_args = FlagProxy.new(named_args)
+        @raw_named_args = named_args
+        @reqd = reqd
+        @reqd_arg_proxy = ArgProxy.new(args, named_args, reqd: true) unless @reqd
+      end
+
+      def each(...)
+        @args.each(...)
+      end
+
+      def [](key)
+        if key.is_a?(Integer)
+          res = @args[key]
+          if @reqd && !res
+            warn "FATAL: Missing required argument number #{key + 1}"
+            exit 1
+          end
+        else
+          key = key.to_s
+          res = @named_args[key]
+          if @reqd && !res
+            warn "FATAL: Missing required argument #{key}"
+            exit 1
+          end
+        end
+        res
+      end
+
+      def slice(*keys)
+        [keys].flatten.each_with_object({}) do |key, result_hash|
+          result_hash[key] = self[key]
+        end
+      end
+
+      def <=>(*args)
+        @args.<=>(*args)
+      end
+
+      def method_missing(met)
+        self[met]
+      end
+
+      def respond_to_missing?(*_args)
+        true # Anything could be an arg name that we haven't set
+      end
+
+      def inspect
+        "ArgProxy: #{@args.inspect}, #{@raw_named_args.inspect}"
+      end
+
+      def to_s
+        "ArgProxy: #{@args}, #{@raw_named_args.inspect}"
+      end
+
+      def reqd
+        @reqd_arg_proxy or raise "no reqd.reqd"
+      end
+    end
+  end
+end

data/lib/tabry/cli/base.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "arg_proxy"
+require_relative "flag_proxy"
+
+module Tabry
+  module CLI
+    class Base
+      attr_reader :args, :flags, :internals
+
+      def initialize(flags, args, named_args, internals)
+        @args = ArgProxy.new(args, named_args)
+        @flags = FlagProxy.new(flags)
+        @internals = internals
+      end
+
+      def self.sub_route(prefix, cli_class)
+        (@sub_route_clis ||= {})[prefix.to_s] = cli_class
+      end
+
+      def self.after_action(*method_names, only: nil, except: nil, &blk)
+        [*method_names, blk].compact.each do |met|
+          (@after_actions ||= []) << [met, { only: only, except: except }]
+        end
+      end
+
+      def self.before_action(*method_names, only: nil, except: nil, &blk)
+        [*method_names, blk].compact.each do |met|
+          (@before_actions ||= []) << [met, { only: only, except: except }]
+        end
+      end
+    end
+  end
+end

data/lib/tabry/cli/builder.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require_relative "../runner"
+require_relative "../util"
+require_relative "internals"
+
+module Tabry
+  module CLI
+    class Builder
+      attr_reader :config, :cli_class, :runner
+
+      def initialize(config_name, cli_class)
+        @cli_class = cli_class
+        @runner = Tabry::Runner.new(config_name: config_name)
+      end
+
+      DISALLOWED_SUBCOMMAND_NAMES = %w[args flags internals].freeze
+
+      def run(raw_args)
+        result = runner.parse(raw_args)
+        check_for_correct_usage(result)
+
+        state = result.state
+
+        met = state.subcommand_stack.join("__").gsub("-", "_")
+
+        ::Tabry::Util.debug "met: #{met.inspect}"
+        ::Tabry::Util.debug "named_args: #{result.named_args.inspect}"
+
+        internals = Internals.new(
+          runner: runner, config: config, raw_args: raw_args,
+          state: state, met: met, result: result
+        )
+
+        cli = instantiate_cli(@cli_class, internals)
+        actual_cli, actual_met = get_cli_object_and_met(cli, met, internals)
+
+        cli_send_met(actual_cli, actual_met)
+      end
+
+      private
+
+      def check_for_correct_usage(result)
+        if result.help?
+          puts result.usage(File.basename($0))
+          exit 0
+        elsif result.invalid_usage_reason
+          puts "Invalid usage: #{result.invalid_usage_reason}"
+          puts
+          puts result.usage(File.basename($0))
+          exit(1)
+        end
+      end
+
+      def instantiate_cli(klass, internals)
+        return klass unless klass.is_a?(Class)
+
+        state = internals.state
+        klass.new(state.flags, state.args, internals.result.named_args, internals)
+      end
+
+      # Recursively look through sub_routes for the CLI to be used
+      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
+        end
+
+        return [cli, "main"] if met.to_s == ""
+
+        sub_route_clis = cli.class.instance_variable_get(:@sub_route_clis)
+        sub_name, rest = met.split("__", 2)
+
+        if sub_route_clis&.dig(sub_name)
+          sub_route_clis[sub_name] = instantiate_cli(sub_route_clis[sub_name], internals)
+          get_cli_object_and_met(sub_route_clis[sub_name], rest, internals)
+        else
+          [cli, met]
+        end
+      end
+
+      def cli_send_met(cli, met)
+        if cli.respond_to?(met.to_sym)
+          run_hooks(cli, met, :@before_actions)
+          cli.send(met.to_sym)
+          run_hooks(cli, met, :@after_actions)
+        else
+          warn %(FATAL: CLI does not support command #{met})
+          exit 1
+        end
+      end
+
+      def run_hooks(cli, met, instance_var)
+        met = met.to_s
+        cli.class.instance_variable_get(instance_var)&.each do |hook, opts|
+          next if Array(opts&.dig(:except))&.map(&:to_s)&.include?(met.to_s)
+          next if opts&.dig(:only) && !Array(opts[:only])&.map(&:to_s)&.include?(met.to_s)
+
+          hook.is_a?(Proc) ? cli.instance_eval(&hook) : cli.send(hook.to_sym)
+        end
+      end
+    end
+  end
+end

data/lib/tabry/cli/flag_proxy.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Tabry
+  module CLI
+    class FlagProxy
+      def initialize(hash)
+        @hash = hash
+      end
+
+      def [](key)
+        key = key.to_s
+        [
+          key,
+          key.gsub("_", "-")
+        ].each do |hash_key|
+          val = @hash[hash_key]
+          return val if val
+        end
+        nil
+      end
+
+      def slice(*keys)
+        [keys].flatten.each_with_object({}) do |key, result_hash|
+          result_hash[key] = self[key]
+        end
+      end
+
+      def method_missing(met, default = nil, *_args)
+        self[met] || default
+      end
+
+      def respond_to_missing?(*_args)
+        true
+      end
+
+      def inspect
+        "FlagProxy: #{@hash.inspect}"
+      end
+
+      def to_s
+        "FlagProxy: #{@hash}"
+      end
+    end
+  end
+end

data/lib/tabry/cli/internals.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Tabry
+  module CLI
+    Internals = Struct.new(
+      :runner, :config_name, :config, :raw_args, :state, :met, :result,
+      keyword_init: true
+    )
+  end
+end

data/lib/tabry/cli/util/config.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "ostruct"
+require "yaml"
+require "json"
+
+# Simple YAML configuration
+# Example:
+# require 'tabry/cli/util/config'
+# module MyCli
+#   Config = Tabry::CLI::Util::Config.new('~/.mycli.yml')
+# end
+
+class Hash
+  def to_openstruct
+    JSON.parse to_json, object_class: OpenStruct
+  end
+end
+
+class Array
+  def to_openstruct
+    JSON.parse to_json, object_class: OpenStruct
+  end
+end
+
+module Tabry
+  module CLI
+    module Util
+      class Config
+        def initialize(path)
+          @path = path.gsub(/^~/, Dir.home)
+        end
+
+        def config
+          @config ||= YAML.load_file(@path).to_openstruct
+        end
+
+        def method_missing(*args)
+          config.send(*args)
+        end
+
+        def respond_to_missing?(*args)
+          super?(*args) || config.respond_to_missing?(*args)
+        end
+      end
+    end
+  end
+end

data/lib/tabry/cli/util.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "shellwords"
+
+# Utils that may be useful to CLIs
+module Tabry
+  module CLI
+    module Util
+      module_function
+
+      def make_cmdline(cmdline, *args, echo: false, echo_only: false)
+        args = Array(args).flatten
+        cmdline = cmdline % args.map { |a| Shellwords.escape(a) }
+        warn cmdline if echo || echo_only
+        return nil if echo_only
+
+        cmdline
+      end
+
+      def system(*cmdline, **opts)
+        cmdline = make_cmdline(*cmdline, **opts)
+        Kernel.system cmdline if cmdline
+      end
+
+      # TODO: would be nice to get separate STDERR and STDOUT
+      def backtick_or_die(*cmdline, **opts)
+        backtick_with_process_status(*cmdline, **opts).first
+      end
+
+      def backtick_with_process_status(*cmdline, valid_statuses: [0], **opts)
+        cmdline = make_cmdline(*cmdline, **opts)
+        return [nil, nil] unless cmdline
+
+        res = `#{cmdline}`
+        status = $?
+        if valid_statuses && !valid_statuses.include?(status.exitstatus)
+          warn "COMMAND FAILED with exit code #{status.exitstatus}: #{cmdline}"
+          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)}"
+        end
+      end
+    end
+  end
+end

data/lib/tabry/config_loader.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "models/config"
+
+module Tabry
+  class ConfigLoader
+    class ConfigNotFound < StandardError; end
+
+    EXTENSIONS = %w[json yml yaml].freeze
+
+    def self.load(**args)
+      new(**args).load
+    end
+
+    attr_reader :name
+
+    def initialize(name:)
+      @name = name
+    end
+
+    def load
+      return load_from_file(name) if name =~ /\.json$/i || name =~ /\.ya?ml$/i
+
+      load_paths.each do |dir|
+        EXTENSIONS.each do |extension|
+          filename = "#{dir}/#{name}.#{extension}"
+          return load_from_file(filename) if File.exist?(filename)
+        end
+      end
+
+      raise ConfigNotFound, "Could not find Tabry config #{name}.(#{EXTENSIONS.join(", ")}) in paths: #{load_paths.inspect}"
+    end
+
+    private
+
+    def load_paths
+      @load_paths ||= [
+        *ENV["TABRY_IMPORTS_PATH"]&.split(":")&.reject(&:empty?),
+        Dir.home + "/.tabry/",
+      ]
+    end
+
+    def load_from_file(filename)
+      if filename =~ /\.json$/
+        require "json"
+        Tabry::Models::Config.new(raw: JSON.parse(File.read(filename)))
+      elsif filename =~ /\.ya?ml$/
+        require "yaml"
+        Tabry::Models::Config.new(raw: YAML.safe_load(File.read(filename)))
+      else
+        raise "unknown file type"
+      end
+    end
+  end
+end

data/lib/tabry/core_ext/string/colors.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+class String
+  def decolorize
+    gsub(/\e\[(\d+)(;\d+)*m/, "")
+  end
+
+  def black
+    "\e[30m#{self}\e[0m"
+  end
+
+  def red
+    "\e[31m#{self}\e[0m"
+  end
+
+  def green
+    "\e[32m#{self}\e[0m"
+  end
+
+  def brown
+    "\e[33m#{self}\e[0m"
+  end
+
+  def blue
+    "\e[34m#{self}\e[0m"
+  end
+
+  def magenta
+    "\e[35m#{self}\e[0m"
+  end
+
+  def cyan
+    "\e[36m#{self}\e[0m"
+  end
+
+  def gray
+    "\e[37m#{self}\e[0m"
+  end
+
+  def bg_black
+    "\e[40m#{self}\e[0m"
+  end
+
+  def bg_red
+    "\e[41m#{self}\e[0m"
+  end
+
+  def bg_green
+    "\e[42m#{self}\e[0m"
+  end
+
+  def bg_brown
+    "\e[43m#{self}\e[0m"
+  end
+
+  def bg_blue
+    "\e[44m#{self}\e[0m"
+  end
+
+  def bg_magenta
+    "\e[45m#{self}\e[0m"
+  end
+
+  def bg_cyan
+    "\e[46m#{self}\e[0m"
+  end
+
+  def bg_gray
+    "\e[47m#{self}\e[0m"
+  end
+
+  def bold
+    "\e[1m#{self}\e[22m"
+  end
+
+  def italic
+    "\e[3m#{self}\e[23m"
+  end
+
+  def underline
+    "\e[4m#{self}\e[24m"
+  end
+
+  def blink
+    "\e[5m#{self}\e[25m"
+  end
+
+  def reverse_color
+    "\e[7m#{self}\e[27m"
+  end
+end