gorails 0.1.0 → 0.1.3

data/vendor/deps/cli-kit/lib/cli/kit/args/parser.rb

@@ -0,0 +1,128 @@
+# typed: true
+require 'cli/kit'
+
+module CLI
+  module Kit
+    module Args
+      class Parser
+        extend T::Sig
+
+        autoload :Node, 'cli/kit/args/parser/node'
+
+        Error = Class.new(Args::Error)
+
+        class InvalidOptionError < Error
+          extend T::Sig
+          sig { params(option: String).void }
+          def initialize(option)
+            super("invalid option -- '#{option}'")
+          end
+        end
+
+        class OptionRequiresAnArgumentError < Error
+          extend T::Sig
+          sig { params(option: String).void }
+          def initialize(option)
+            super("option requires an argument -- '#{option}'")
+          end
+        end
+
+        sig { params(tokens: T::Array[Tokenizer::Token]).returns(T::Array[Node]) }
+        def parse(tokens)
+          nodes = T.let([], T::Array[Node])
+          args = T.let(tokens, T::Array[T.nilable(Tokenizer::Token)])
+          args << nil # to make each_cons pass (args.last, nil) on the final round.
+          state = :init
+          # TODO: test that "--height -- 3" is parsed correctly.
+          args.each_cons(2) do |(arg, next_arg)|
+            case state
+            when :skip
+              state = :init
+            when :init
+              state, val = parse_token(T.must(arg), next_arg)
+              nodes << val
+            when :unparsed
+              unless arg.is_a?(Tokenizer::Token::UnparsedArgument)
+                raise(Error, 'bug: non-unparsed argument after unparsed argument')
+              end
+
+              unparsed = nodes.last
+              unless unparsed.is_a?(Node::Unparsed)
+                # :nocov: not actually possible, in theory
+                raise(Error, 'bug: parser failed to recognize first unparsed argument')
+                # :nocov:
+              end
+
+              unparsed.value << arg.value
+            end
+          end
+          nodes
+        end
+
+        sig { params(definition: Definition).void }
+        def initialize(definition)
+          @defn = definition
+        end
+
+        private
+
+        sig do
+          params(token: Tokenizer::Token, next_token: T.nilable(Tokenizer::Token))
+            .returns([Symbol, Parser::Node])
+        end
+        def parse_token(token, next_token)
+          case token
+          when Tokenizer::Token::LongOptionName
+            case @defn.lookup_long(token.value)
+            when Definition::Option
+              [:skip, parse_option(token, next_token)]
+            when Definition::Flag
+              [:init, Node::LongFlag.new(token.value)]
+            else
+              raise(InvalidOptionError, token.value)
+            end
+          when Tokenizer::Token::ShortOptionName
+            case @defn.lookup_short(token.value)
+            when Definition::Option
+              [:skip, parse_option(token, next_token)]
+            when Definition::Flag
+              [:init, Node::ShortFlag.new(token.value)]
+            else
+              raise(InvalidOptionError, token.value)
+            end
+          when Tokenizer::Token::OptionValue
+            raise(Error, "bug: unexpected option value in argument parse sequence: #{token.value}")
+          when Tokenizer::Token::PositionalArgument
+            [:init, Node::Argument.new(token.value)]
+          when Tokenizer::Token::OptionValueOrPositionalArgument
+            [:init, Node::Argument.new(token.value)]
+          when Tokenizer::Token::UnparsedArgument
+            [:unparsed, Node::Unparsed.new([token.value])]
+          else
+            raise(Error, "bug: unexpected token type: #{token.class}")
+          end
+        end
+
+        sig { params(arg: Tokenizer::Token::OptionName, next_arg: T.nilable(Tokenizer::Token)).returns(Node) }
+        def parse_option(arg, next_arg)
+          case next_arg
+          when nil, Tokenizer::Token::LongOptionName,
+            Tokenizer::Token::ShortOptionName, Tokenizer::Token::PositionalArgument
+            raise(OptionRequiresAnArgumentError, arg.value)
+          when Tokenizer::Token::OptionValue, Tokenizer::Token::OptionValueOrPositionalArgument
+            case arg
+            when Tokenizer::Token::LongOptionName
+              Node::LongOption.new(arg.value, next_arg.value)
+            when Tokenizer::Token::ShortOptionName
+              Node::ShortOption.new(arg.value, next_arg.value)
+            else
+              raise(Error, "bug: unexpected token type: #{arg.class}")
+            end
+          else
+            raise(Error, "bug: unexpected argument type: #{next_arg.class}")
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/deps/cli-kit/lib/cli/kit/args/tokenizer.rb

@@ -0,0 +1,132 @@
+# typed: true
+require 'cli/kit'
+
+module CLI
+  module Kit
+    module Args
+      module Tokenizer
+        extend T::Sig
+
+        Error = Class.new(Args::Error)
+
+        class InvalidShortOption < Error
+          extend T::Sig
+          sig { params(short_option: String).void }
+          def initialize(short_option)
+            super("invalid short option: '-#{short_option}'")
+          end
+        end
+
+        class InvalidCharInShortOption < Error
+          extend T::Sig
+          sig { params(short_option: String, char: String).void }
+          def initialize(short_option, char)
+            super("invalid character '#{char}' in short option: '-#{short_option}'")
+          end
+        end
+
+        class Token
+          extend T::Sig
+
+          sig { returns(String) }
+          attr_reader :value
+
+          sig { params(value: String).void }
+          def initialize(value)
+            @value = value
+          end
+
+          sig { returns(String) }
+          def inspect
+            "#<#{self.class.name} #{@value}>"
+          end
+
+          sig { params(other: T.untyped).returns(T::Boolean) }
+          def ==(other)
+            self.class == other.class && @value == other.value
+          end
+
+          OptionName = Class.new(Token)
+          LongOptionName = Class.new(OptionName)
+          ShortOptionName = Class.new(OptionName)
+
+          OptionValue = Class.new(Token)
+          PositionalArgument = Class.new(Token)
+          OptionValueOrPositionalArgument = Class.new(Token)
+          UnparsedArgument = Class.new(Token)
+        end
+
+        class << self
+          extend T::Sig
+
+          sig { params(raw_args: T::Array[String]).returns(T::Array[Token]) }
+          def tokenize(raw_args)
+            args = []
+
+            mode = :init
+
+            raw_args.each do |arg|
+              case mode
+              when :unparsed
+                args << Token::UnparsedArgument.new(arg)
+              when :init
+                case arg
+                when '--'
+                  mode = :unparsed
+                when /\A--/
+                  name, value = arg.split('=', 2)
+                  args << Token::LongOptionName.new(T.must(T.must(name)[2..-1]))
+                  if value
+                    args << Token::OptionValue.new(value)
+                  end
+                when /\A-/
+                  args.concat(tokenize_short_option(T.must(arg[1..-1])))
+                else
+                  args << if args.last.is_a?(Token::OptionName)
+                    Token::OptionValueOrPositionalArgument.new(arg)
+                  else
+                    Token::PositionalArgument.new(arg)
+                  end
+                end
+              end
+            end
+
+            args
+          end
+
+          sig { params(arg: String).returns(T::Array[Token]) }
+          def tokenize_short_option(arg)
+            args = []
+            mode = :init
+            number = +''
+            arg.each_char do |char|
+              case mode
+              when :numeric
+                case char
+                when /[0-9]/
+                  number << char
+                else
+                  raise(InvalidShortOption, arg)
+                end
+              when :init
+                case char
+                when /[a-zA-Z]/
+                  args << Token::ShortOptionName.new(char)
+                when /[0-9]/
+                  mode = :numeric
+                  number << char
+                else
+                  raise(InvalidCharInShortOption.new(arg, char))
+                end
+              end
+            end
+            if number != ''
+              args << Token::OptionValue.new(number)
+            end
+            args
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# typed: true
+require 'cli/kit'
+
+module CLI
+  module Kit
+    module Args
+      Error = Class.new(StandardError)
+
+      autoload :Definition, 'cli/kit/args/definition'
+      autoload :Parser, 'cli/kit/args/parser'
+      autoload :Evaluation, 'cli/kit/args/evaluation'
+      autoload :Tokenizer, 'cli/kit/args/tokenizer'
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# typed: true
+require 'cli/kit'
+
+module CLI
+  module Kit
+    class BaseCommand
+      extend T::Sig
+      extend T::Helpers
+      include CLI::Kit::CommandHelp
+      extend CLI::Kit::CommandHelp::ClassMethods
+      abstract!
+
+      sig { returns(T::Boolean) }
+      def self.defined?
+        true
+      end
+
+      sig { params(args: T::Array[String], command_name: String).void }
+      def self.call(args, command_name)
+        new.call(args, command_name)
+      end
+
+      sig { returns(T::Boolean) }
+      def has_subcommands?
+        false
+      end
+    end
+  end
+end

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