gorails 0.1.2 → 0.1.3

data/vendor/deps/cli-kit/lib/cli/kit/command_help.rb

@@ -0,0 +1,256 @@
+# typed: true
+require 'cli/kit'
+
+module CLI
+  module Kit
+    module CommandHelp
+      extend T::Sig
+      include Kernel # for sorbet
+
+      sig { params(args: T::Array[String], name: String).void }
+      def call(args, name)
+        begin
+          defn = Args::Definition.new
+          opts = self.class.opts_class
+          opts.new(defn).install_to_definition
+          tokens = Args::Tokenizer.tokenize(args)
+          parse = Args::Parser.new(defn).parse(tokens)
+          result = Args::Evaluation.new(defn, parse)
+          opts_inst = opts.new(result)
+        rescue Args::Evaluation::TooManyPositions, Args::Evaluation::MissingRequiredPosition => e
+          STDERR.puts CLI::UI.fmt("{{red:{{bold:Error: #{e.message}}}}}")
+          STDERR.puts
+          STDERR.puts self.class.build_help
+          raise(AbortSilent)
+        rescue Args::Error => e
+          raise(Abort, e)
+        end
+
+        if opts_inst.helpflag
+          puts self.class.build_help
+        else
+          res = begin
+            opts.new(result)
+          rescue Args::Error => e
+            raise(Abort, e)
+          end
+          invoke_wrapper(res, name)
+        end
+      end
+
+      # use to implement error handling
+      sig { params(op: T.untyped, name: String).void }
+      def invoke_wrapper(op, name)
+        invoke(op, name)
+      end
+
+      sig { params(op: T.untyped, name: String).void }
+      def invoke(op, name)
+        raise(NotImplementedError, '#invoke must be implemented, or #call overridden')
+      end
+
+      sig { params(name: String).void }
+      def self.tool_name=(name)
+        @tool_name = name
+      end
+
+      sig { returns(String) }
+      def self._tool_name
+        unless @tool_name
+          raise 'You must set CLI::Kit::CommandHelp.tool_name='
+        end
+
+        @tool_name
+      end
+
+      module ClassMethods
+        extend T::Sig
+        include Kernel # for sorbet
+
+        DEFAULT_HELP_SECTIONS = [
+          :desc,
+          :long_desc,
+          :usage,
+          :examples,
+          :options,
+        ]
+
+        sig { returns(String) }
+        def build_help
+          h = (@help_sections || DEFAULT_HELP_SECTIONS).map do |section|
+            case section
+            when :desc
+              build_desc
+            when :long_desc
+              @long_desc
+            when :usage
+              @usage_section ||= build_usage
+            when :examples
+              @examples_section ||= build_examples
+            when :options
+              @options_section ||= build_options
+            else
+              raise "Unknown help section: #{section}"
+            end
+          end.compact.map(&:chomp).join("\n\n") + "\n"
+          CLI::UI.fmt(h)
+        end
+
+        sig { returns(String) }
+        def _command_name
+          return @command_name if @command_name
+
+          last_camel = send(:name).split('::').last
+          last_camel.gsub(/([a-z])([A-Z])/, '\1-\2').downcase
+        end
+
+        sig { returns(String) }
+        def _desc
+          @desc
+        end
+
+        sig { returns(String) }
+        def build_desc
+          out = +"{{command:#{CommandHelp._tool_name} #{_command_name}}}"
+          if @desc
+            out << ": #{@desc}"
+          end
+          "{{bold:#{out}}}"
+        end
+
+        sig { returns(T.untyped) }
+        def opts_class
+          T.unsafe(self).const_get(:Opts) # rubocop:disable Sorbet/ConstantsFromStrings
+        rescue NameError
+          Class.new(CLI::Kit::Opts)
+        end
+
+        sig { returns(T.nilable(String)) }
+        def build_options
+          opts = opts_class
+          return(nil) unless opts
+
+          methods = []
+          loop do
+            methods.concat(opts.public_instance_methods(false))
+            break if opts.superclass == CLI::Kit::Opts
+
+            opts = opts.superclass
+          end
+
+          @defn = Args::Definition.new
+          o = opts.new(@defn)
+          o.install_to_definition
+
+          return nil if @defn.options.empty? && @defn.flags.empty?
+
+          merged = T.let(@defn.options, T::Array[T.any(Args::Definition::Option, Args::Definition::Flag)])
+          merged += @defn.flags
+          merged.sort_by!(&:name)
+          "{{bold:Options:}}\n" + merged.map do |o|
+            if o.is_a?(Args::Definition::Option)
+              z = '  ' + [o.short&.prepend('-'), o.long&.prepend('--')].compact.join(', ') + ' VALUE'
+              default = if o.dynamic_default?
+                '(generated default)'
+              elsif o.default.nil?
+                '(no default)'
+              else
+                "(default: #{o.default.inspect})"
+              end
+              z << if o.desc
+                "  {{italic:{{gray:# #{o.desc} #{default}}}}}"
+              else
+                "  {{italic:{{gray:# #{default}}}}}"
+              end
+            else
+              z = '  ' + [o.short&.prepend('-'), o.long&.prepend('--')].compact.join(', ')
+              if o.desc
+                z << "  {{italic:{{gray:# #{o.desc}}}}}"
+              end
+            end
+            z
+          end.join("\n")
+        end
+
+        sig { params(sections: T::Array[Symbol]).void }
+        def help_sections(sections)
+          @help_sections = sections
+        end
+
+        sig { params(command_name: String).void }
+        def command_name(command_name)
+          if @command_name
+            raise(ArgumentError, "Command name already set to #{@command_name}")
+          end
+
+          @command_name = command_name
+        end
+
+        sig { params(desc: String).void }
+        def desc(desc)
+          if desc.size > 80
+            raise(ArgumentError, 'description must be 80 characters or less')
+          end
+          if @desc
+            raise(ArgumentError, 'description already set')
+          end
+
+          @desc = desc
+        end
+
+        sig { params(long_desc: String).void }
+        def long_desc(long_desc)
+          if @long_desc
+            raise(ArgumentError, 'long description already set')
+          end
+
+          @long_desc = long_desc
+        end
+
+        sig { returns(String) }
+        def build_usage
+          '{{bold:Usage:}}' + case (@usage || []).size
+          when 0
+            " {{command:#{CommandHelp._tool_name} #{_command_name}}} [options]\n"
+          when 1
+            " {{command:#{CommandHelp._tool_name} #{_command_name}}} #{@usage.first}\n"
+          else
+            "\n" + @usage.map do |usage|
+              "  {{command:#{CommandHelp._tool_name} #{_command_name}}} #{usage}\n"
+            end.join
+          end
+        end
+
+        sig { returns(T.nilable(String)) }
+        def build_examples
+          return nil unless @examples
+
+          cmd_prefix = "  {{command:#{CommandHelp._tool_name} #{_command_name}}}"
+          "{{bold:Examples:}}\n" + @examples.map do |command, explanation|
+            cmd = "#{cmd_prefix} #{command}"
+            exp = "{{italic:{{gray:# #{explanation}}}}}"
+
+            width = CLI::UI::ANSI.printing_width(CLI::UI.fmt("#{cmd} #{exp}"))
+            if width > CLI::UI::Terminal.width
+              "  #{exp}\n#{cmd}"
+            else
+              "#{cmd}  #{exp}"
+            end
+          end.join("\n\n")
+        end
+
+        sig { params(usage: String).void }
+        def usage(usage)
+          @usage ||= []
+          @usage << usage
+        end
+
+        sig { params(command: String, explanation: T.nilable(String)).void }
+        def example(command, explanation)
+          @examples ||= []
+          @examples << [command, explanation]
+        end
+      end
+    end
+  end
+end

data/vendor/deps/cli-kit/lib/cli/kit/command_registry.rb

@@ -0,0 +1,141 @@
+# typed: true
+require 'cli/kit'
+
+module CLI
+  module Kit
+    class CommandRegistry
+      extend T::Sig
+
+      CommandOrProc = T.type_alias do
+        T.any(T.class_of(CLI::Kit::BaseCommand), T.proc.returns(T.class_of(CLI::Kit::BaseCommand)))
+      end
+
+      sig { returns(T::Hash[String, CommandOrProc]) }
+      attr_reader :commands
+
+      sig { returns(T::Hash[String, String]) }
+      attr_reader :aliases
+
+      module ContextualResolver
+        extend T::Sig
+        extend T::Helpers
+        interface!
+
+        sig { abstract.returns(T::Array[String]) }
+        def command_names; end
+
+        sig { abstract.returns(T::Hash[String, String]) }
+        def aliases; end
+
+        sig { abstract.params(_name: String).returns(T.class_of(CLI::Kit::BaseCommand)) }
+        def command_class(_name); end
+      end
+
+      module NullContextualResolver
+        extend T::Sig
+        extend ContextualResolver
+
+        sig { override.returns(T::Array[String]) }
+        def self.command_names
+          []
+        end
+
+        sig { override.returns(T::Hash[String, String]) }
+        def self.aliases
+          {}
+        end
+
+        sig { override.params(_name: String).returns(T.class_of(CLI::Kit::BaseCommand)) }
+        def self.command_class(_name)
+          raise(CLI::Kit::Abort, 'Cannot be called on the NullContextualResolver since command_names is empty')
+        end
+      end
+
+      sig { params(default: String, contextual_resolver: ContextualResolver).void }
+      def initialize(default:, contextual_resolver: NullContextualResolver)
+        @commands = {}
+        @aliases  = {}
+        @default = default
+        @contextual_resolver = contextual_resolver
+      end
+
+      sig { returns(T::Hash[String, T.class_of(CLI::Kit::BaseCommand)]) }
+      def resolved_commands
+        @commands.each_with_object({}) do |(k, v), a|
+          a[k] = resolve_class(v)
+        end
+      end
+
+      sig { params(const: CommandOrProc, name: String).void }
+      def add(const, name)
+        commands[name] = const
+      end
+
+      sig { params(name: T.nilable(String)).returns([T.nilable(T.class_of(CLI::Kit::BaseCommand)), String]) }
+      def lookup_command(name)
+        name = @default if name.to_s.empty?
+        resolve_command(T.must(name))
+      end
+
+      sig { params(from: String, to: String).void }
+      def add_alias(from, to)
+        aliases[from] = to unless aliases[from]
+      end
+
+      sig { returns(T::Array[String]) }
+      def command_names
+        @contextual_resolver.command_names + commands.keys
+      end
+
+      sig { params(name: String).returns(T::Boolean) }
+      def exist?(name)
+        !resolve_command(name).first.nil?
+      end
+
+      private
+
+      sig { params(name: String).returns(String) }
+      def resolve_alias(name)
+        aliases[name] || @contextual_resolver.aliases.fetch(name, name)
+      end
+
+      sig { params(name: String).returns([T.nilable(T.class_of(CLI::Kit::BaseCommand)), String]) }
+      def resolve_command(name)
+        name = resolve_alias(name)
+        resolve_global_command(name) || \
+          resolve_contextual_command(name) || \
+          [nil, name]
+      end
+
+      sig { params(name: String).returns(T.nilable([T.class_of(CLI::Kit::BaseCommand), String])) }
+      def resolve_global_command(name)
+        klass = resolve_class(commands.fetch(name, nil))
+        return nil unless klass
+
+        [klass, name]
+      rescue NameError
+        nil
+      end
+
+      sig { params(name: String).returns(T.nilable([T.class_of(CLI::Kit::BaseCommand), String])) }
+      def resolve_contextual_command(name)
+        found = @contextual_resolver.command_names.include?(name)
+        return nil unless found
+
+        [@contextual_resolver.command_class(name), name]
+      end
+
+      sig { params(class_or_proc: T.nilable(CommandOrProc)).returns(T.nilable(T.class_of(CLI::Kit::BaseCommand))) }
+      def resolve_class(class_or_proc)
+        case class_or_proc
+        when nil
+          nil
+        when Proc
+          class_or_proc.call
+        else
+          class_or_proc
+        end
+      end
+    end
+  end
+end

data/vendor/deps/cli-kit/lib/cli/kit/config.rb

@@ -0,0 +1,137 @@
+# typed: true
+require 'cli/kit'
+require 'fileutils'
+
+module CLI
+  module Kit
+    class Config
+      extend T::Sig
+
+      XDG_CONFIG_HOME = 'XDG_CONFIG_HOME'
+
+      sig { params(tool_name: String).void }
+      def initialize(tool_name:)
+        @tool_name = tool_name
+      end
+
+      # Returns the config corresponding to `name` from the config file
+      # `false` is returned if it doesn't exist
+      #
+      # #### Parameters
+      # `section` : the section of the config value you are looking for
+      # `name` : the name of the config value you are looking for
+      #
+      # #### Returns
+      # `value` : the value of the config variable (nil if none)
+      #
+      # #### Example Usage
+      # `config.get('name.of.config')`
+      #
+      sig { params(section: String, name: String, default: T.nilable(String)).returns(T.nilable(String)) }
+      def get(section, name, default: nil)
+        all_configs.dig("[#{section}]", name) || default
+      end
+
+      # Coalesce and enforce the value of a config to a boolean
+      sig { params(section: String, name: String, default: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
+      def get_bool(section, name, default: false)
+        case get(section, name)
+        when 'true'
+          true
+        when 'false'
+          false
+        when nil
+          default
+        else
+          raise CLI::Kit::Abort, "Invalid config: #{section}.#{name} is expected to be true or false"
+        end
+      end
+
+      # Sets the config value in the config file
+      #
+      # #### Parameters
+      # `section` : the section of the config you are setting
+      # `name` : the name of the config you are setting
+      # `value` : the value of the config you are setting
+      #
+      # #### Example Usage
+      # `config.set('section', 'name.of.config', 'value')`
+      #
+      sig { params(section: String, name: String, value: T.nilable(T.any(String, T::Boolean))).void }
+      def set(section, name, value)
+        all_configs["[#{section}]"] ||= {}
+        case value
+        when nil
+          T.must(all_configs["[#{section}]"]).delete(name)
+        else
+          T.must(all_configs["[#{section}]"])[name] = value.to_s
+        end
+        write_config
+      end
+
+      # Unsets a config value in the config file
+      #
+      # #### Parameters
+      # `section` : the section of the config you are deleting
+      # `name` : the name of the config you are deleting
+      #
+      # #### Example Usage
+      # `config.unset('section', 'name.of.config')`
+      #
+      sig { params(section: String, name: String).void }
+      def unset(section, name)
+        set(section, name, nil)
+      end
+
+      # Gets the hash for the entire section
+      #
+      # #### Parameters
+      # `section` : the section of the config you are getting
+      #
+      # #### Example Usage
+      # `config.get_section('section')`
+      #
+      sig { params(section: String).returns(T::Hash[String, String]) }
+      def get_section(section)
+        (all_configs["[#{section}]"] || {}).dup
+      end
+
+      sig { returns(String) }
+      def to_s
+        ini.to_s
+      end
+
+      # The path on disk at which the configuration is stored:
+      #   `$XDG_CONFIG_HOME/<toolname>/config`
+      # if ENV['XDG_CONFIG_HOME'] is not set, we default to ~/.config, e.g.:
+      #   ~/.config/tool/config
+      #
+      sig { returns(String) }
+      def file
+        config_home = ENV.fetch(XDG_CONFIG_HOME, '~/.config')
+        File.expand_path(File.join(@tool_name, 'config'), config_home)
+      end
+
+      private
+
+      sig { returns(T::Hash[String, T::Hash[String, String]]) }
+      def all_configs
+        ini.ini
+      end
+
+      sig { returns(CLI::Kit::Ini) }
+      def ini
+        @ini ||= CLI::Kit::Ini.new(file).tap(&:parse)
+      end
+
+      sig { void }
+      def write_config
+        all_configs.each do |section, sub_config|
+          all_configs.delete(section) if sub_config.empty?
+        end
+        FileUtils.mkdir_p(File.dirname(file))
+        File.write(file, to_s)
+      end
+    end
+  end
+end

data/vendor/deps/cli-kit/lib/cli/kit/core_ext.rb

@@ -0,0 +1,30 @@
+# typed: strong
+# frozen_string_literal: true
+
+class Exception
+  extend(T::Sig)
+
+  # You'd think instance variables @bug and @silent would work here. They
+  # don't. I'm not sure why. If you, the reader, want to take some time to
+  # figure it out, go ahead and refactor to that.
+
+  sig { returns(T::Boolean) }
+  def bug?
+    true
+  end
+
+  sig { returns(T::Boolean) }
+  def silent?
+    false
+  end
+
+  sig { params(bug: T::Boolean).void }
+  def bug!(bug = true)
+    singleton_class.define_method(:bug?) { bug }
+  end
+
+  sig { params(silent: T::Boolean).void }
+  def silent!(silent = true)
+    singleton_class.define_method(:silent?) { silent }
+  end
+end