gorails 0.1.2 → 0.1.5

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

@@ -0,0 +1,237 @@
+# typed: true
+require 'cli/kit'
+
+module CLI
+  module Kit
+    module Args
+      class Evaluation
+        extend T::Sig
+
+        Error = Class.new(Args::Error)
+
+        class MissingRequiredOption < Error
+          extend T::Sig
+          sig { params(name: String).void }
+          def initialize(name)
+            super("missing required option `#{name}'")
+          end
+        end
+
+        class MissingRequiredPosition < Error
+          extend T::Sig
+          sig { void }
+          def initialize
+            super('more arguments required')
+          end
+        end
+
+        class TooManyPositions < Error
+          extend T::Sig
+          sig { void }
+          def initialize
+            super('too many arguments')
+          end
+        end
+
+        class FlagProxy
+          extend T::Sig
+
+          sig { params(sym: Symbol).returns(T::Boolean) }
+          def method_missing(sym)
+            flag = @evaluation.defn.lookup_flag(sym)
+            unless flag
+              raise NoMethodError, "undefined flag `#{sym}' for #{self}"
+            end
+
+            @evaluation.send(:lookup_flag, flag)
+          end
+
+          sig { params(sym: Symbol, include_private: T::Boolean).returns(T::Boolean) }
+          def respond_to_missing?(sym, include_private = false)
+            !!@evaluation.defn.lookup_flag(sym)
+          end
+
+          sig { params(evaluation: Evaluation).void }
+          def initialize(evaluation)
+            @evaluation = evaluation
+          end
+        end
+
+        class OptionProxy
+          extend T::Sig
+
+          sig { params(sym: Symbol).returns(T.any(NilClass, String, T::Array[String])) }
+          def method_missing(sym)
+            opt = @evaluation.defn.lookup_option(sym)
+            unless opt
+              raise NoMethodError, "undefined option `#{sym}' for #{self}"
+            end
+
+            @evaluation.send(:lookup_option, opt)
+          end
+
+          sig { params(sym: Symbol, include_private: T::Boolean).returns(T::Boolean) }
+          def respond_to_missing?(sym, include_private = false)
+            !!@evaluation.defn.lookup_option(sym)
+          end
+
+          sig { params(evaluation: Evaluation).void }
+          def initialize(evaluation)
+            @evaluation = evaluation
+          end
+        end
+
+        class PositionProxy
+          extend T::Sig
+
+          sig { params(sym: Symbol).returns(T.any(NilClass, String, T::Array[String])) }
+          def method_missing(sym)
+            position = @evaluation.defn.lookup_position(sym)
+            unless position
+              raise NoMethodError, "undefined position `#{sym}' for #{self}"
+            end
+
+            @evaluation.send(:lookup_position, position)
+          end
+
+          sig { params(sym: Symbol, include_private: T::Boolean).returns(T::Boolean) }
+          def respond_to_missing?(sym, include_private = false)
+            !!@evaluation.defn.lookup_position(sym)
+          end
+
+          sig { params(evaluation: Evaluation).void }
+          def initialize(evaluation)
+            @evaluation = evaluation
+          end
+        end
+
+        sig { returns(FlagProxy) }
+        def flag
+          @flag_proxy ||= FlagProxy.new(self)
+        end
+
+        sig { returns(OptionProxy) }
+        def opt
+          @option_proxy ||= OptionProxy.new(self)
+        end
+
+        sig { returns(PositionProxy) }
+        def position
+          @position_proxy ||= PositionProxy.new(self)
+        end
+
+        sig { returns(Definition) }
+        attr_reader :defn
+
+        sig { returns(T::Array[Parser::Node]) }
+        attr_reader :parse
+
+        sig { returns(T::Array[String]) }
+        def unparsed
+          @unparsed ||= begin
+            nodes = T.cast(
+              parse.select { |node| node.is_a?(Parser::Node::Unparsed) },
+              T::Array[Parser::Node::Unparsed],
+            )
+            nodes.flat_map(&:value)
+          end
+        end
+
+        sig { params(defn: Definition, parse: T::Array[Parser::Node]).void }
+        def initialize(defn, parse)
+          @defn = defn
+          @parse = parse
+          check_required!
+        end
+
+        sig { void }
+        def check_required!
+          @defn.options.each do |opt|
+            next unless opt.required
+
+            node = @parse.detect do |node|
+              node.is_a?(Parser::Node::Option) && node.name == opt.name
+            end
+            if !node || T.cast(node, Parser::Node::Option).value.nil?
+              raise(MissingRequiredOption, opt.as_written_by_user)
+            end
+          end
+          min_positions = @defn.positions.count(&:required?)
+          max_positions = if @defn.positions.last&.multiple?
+            Float::INFINITY
+          else
+            min_positions + @defn.positions.count(&:optional?)
+          end
+          raise(MissingRequiredPosition) if args.size < min_positions
+          raise(TooManyPositions) if args.size > max_positions
+        end
+
+        sig { params(flag: Definition::Flag).returns(T::Boolean) }
+        def lookup_flag(flag)
+          if flag.short
+            flags = T.cast(
+              parse.select { |node| node.is_a?(Parser::Node::ShortFlag) },
+              T::Array[Parser::Node::ShortFlag],
+            )
+            return true if flags.any? { |node| node.value == flag.short }
+          end
+          if flag.long
+            flags = T.cast(
+              parse.select { |node| node.is_a?(Parser::Node::LongFlag) },
+              T::Array[Parser::Node::LongFlag],
+            )
+            return true if flags.any? { |node| node.value == flag.long }
+          end
+          false
+        end
+
+        sig { params(opt: Definition::Option).returns(T.any(NilClass, String, T::Array[String])) }
+        def lookup_option(opt)
+          if opt.short
+            opts = T.cast(
+              parse.select { |node| node.is_a?(Parser::Node::ShortOption) },
+              T::Array[Parser::Node::ShortOption],
+            )
+            matches = opts.reverse.select { |node| node.name == opt.short }
+            if (first = matches.first)
+              return(opt.multi ? matches.map(&:value) : first.value)
+            end
+          end
+          if opt.long
+            opts = T.cast(
+              parse.select { |node| node.is_a?(Parser::Node::LongOption) },
+              T::Array[Parser::Node::LongOption],
+            )
+            matches = opts.reverse.select { |node| node.name == opt.long }
+            if (first = matches.first)
+              return(opt.multi ? matches.map(&:value) : first.value)
+            end
+          end
+          opt.multi ? [] : opt.default
+        end
+
+        sig { params(position: Definition::Position).returns(T.any(NilClass, String, T::Array[String])) }
+        def lookup_position(position)
+          if position.multiple?
+            args[position.index..]
+          else
+            args[position.index]
+          end
+        end
+
+        private
+
+        sig { returns(T::Array[String]) }
+        def args
+          @args ||= begin
+            nodes = T.cast(
+              parse.select { |node| node.is_a?(Parser::Node::Argument) },
+              T::Array[Parser::Node::Argument],
+            )
+            nodes.map(&:value)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,131 @@
+# typed: true
+require 'cli/kit'
+
+module CLI
+  module Kit
+    module Args
+      class Parser
+        class Node
+          extend T::Sig
+
+          sig { void }
+          def initialize
+          end
+
+          sig { params(other: T.untyped).returns(T::Boolean) }
+          def ==(other)
+            self.class == other.class
+          end
+
+          class Option < Node
+            extend T::Sig
+
+            sig { returns(String) }
+            attr_reader :name
+
+            sig { returns(String) }
+            attr_reader :value
+
+            sig { params(name: String, value: String).void }
+            def initialize(name, value)
+              @name = name
+              @value = value
+              super()
+            end
+            private_class_method(:new) # don't instantiate this class directly
+
+            sig { returns(String) }
+            def inspect
+              "#<#{self.class.name} #{@name}=#{@value}>"
+            end
+
+            sig { params(other: T.untyped).returns(T::Boolean) }
+            def ==(other)
+              !!(super(other) && @value == other.value && @name == other.name)
+            end
+          end
+
+          class LongOption < Option
+            public_class_method(:new)
+          end
+
+          class ShortOption < Option
+            public_class_method(:new)
+          end
+
+          class Flag < Node
+            sig { returns(String) }
+            attr_reader :value
+
+            sig { params(value: String).void }
+            def initialize(value)
+              @value = value
+              super()
+            end
+            private_class_method(:new) # don't instantiate this class directly
+
+            sig { returns(String) }
+            def inspect
+              "#<#{self.class.name} #{@value}>"
+            end
+
+            sig { params(other: T.untyped).returns(T::Boolean) }
+            def ==(other)
+              !!(super(other) && @value == other.value)
+            end
+          end
+
+          class LongFlag < Flag
+            public_class_method(:new)
+          end
+
+          class ShortFlag < Flag
+            public_class_method(:new)
+          end
+
+          class Argument < Node
+            sig { returns(String) }
+            attr_reader :value
+
+            sig { params(value: String).void }
+            def initialize(value)
+              @value = value
+              super()
+            end
+
+            sig { returns(String) }
+            def inspect
+              "#<#{self.class.name} #{@value}>"
+            end
+
+            sig { params(other: T.untyped).returns(T::Boolean) }
+            def ==(other)
+              !!(super(other) && @value == other.value)
+            end
+          end
+
+          class Unparsed < Node
+            sig { returns(T::Array[String]) }
+            attr_reader :value
+
+            sig { params(value: T::Array[String]).void }
+            def initialize(value)
+              @value = value
+              super()
+            end
+
+            sig { returns(String) }
+            def inspect
+              "#<#{self.class.name} #{@value.join(" ")}>"
+            end
+
+            sig { params(other: T.untyped).returns(T::Boolean) }
+            def ==(other)
+              !!(super(other) && @value == other.value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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