optimistic-json 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 45e3814e28d44c2e46ceb3bcfe8ea5dc8e023ce1a3913160689b2350b1b9c6a6
-  data.tar.gz: 8934140b815b7dee15a613406a936d5b2dda445539a15a43c7c58bf2025a9e0c
+  metadata.gz: '08ee5067a3b7ef874e5984f616721e9c17bed1290db547aae2e5289ec33b7cd4'
+  data.tar.gz: 25fb09be11dac26cb7c51c86793f5c68deb31f1ae571fa866f6c0f85e9784182
 SHA512:
-  metadata.gz: 311262c5b081205bb62b07727d473f124cb440a81c7516fb2bcc8f2fde3c4ad6a2c5062ae86997ba88da835333d955a4cb2550eb68af45e09217eb0b939b14c4
-  data.tar.gz: 01f2fdcdc3d7e97fb6b3e4b86fde020cd16bbdd57d4910010a3b19fc6becfc77ad1fe2872ecaa94bfa933d51f31e98675630c59109d7b5a132b08d4e5e5fc37e
+  metadata.gz: 50b769dc9870c36b4b085cd3829040d7255cfa7c7f2d61ab52f5517829e63f477d29953e725d62f042fd3272654a7c1b2c6c2397ae8e60760dfd16c88a1d0139
+  data.tar.gz: baa73fc379e765243fb7570d0b7046a02f1a3af7e7f9d88f07169011fe47dd330e5c3824a6287ce39eb67a268aec663751f6d54c470379ddeae67c9c9a09cb2e

data/.ruby-version

@@ -0,0 +1 @@
+3.4.2

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 ## [Unreleased]
 
+## [0.1.3] - 2026-05-11
+
+- Remove `sorbet-runtime` from runtime dependencies
+- Add inline RBS type annotations to public and private API
+- Expand CI matrix to test Ruby 3.1–3.4
+
 ## [0.1.2] - 2024-04-09
 
 - Remove `debug` from runtime

data/Rakefile

@@ -9,4 +9,8 @@ require "rubocop/rake_task"
 
 RuboCop::RakeTask.new
 
-task default: %i[spec rubocop]
+task :typecheck do
+  sh "bundle exec srb tc"
+end
+
+task default: %i[spec rubocop typecheck]

data/lib/optimistic/json/parser.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: false
 
 require "logger"
 require "multi_json"
@@ -11,6 +12,7 @@ module Optimistic
       ##
       # Raised when there is no parser for a given token
       class MissingParser < StandardError
+        #: (tokens: String, ?msg: String?) -> void
         def initialize(tokens:, msg: nil)
           super(msg || "No registered parser for `#{tokens[0]}`: #{tokens}")
           @tokens = tokens
@@ -18,10 +20,11 @@ module Optimistic
       end
 
       ##
-      # Raised when a supported token is found, but is invali
+      # Raised when a supported token is found but is invalid
       class InvalidToken < StandardError
+        #: (tokens: String, ?msg: String?) -> void
         def initialize(tokens:, msg: nil)
-          super(msg || "Unknown token starting with `#{tokens[0]}`: #{tokens}")
+          super(msg || "Invalid token starting with `#{tokens[0]}`: #{tokens}")
           @tokens = tokens
         end
       end
@@ -37,13 +40,18 @@ module Optimistic
         null: ["n"]
       }.freeze
 
-      attr_accessor :parsers, :logger
+      #: Logger
+      attr_accessor :logger
+      #: Hash[String, Method]
+      attr_reader :parsers
 
+      #: (?logger: Logger?) -> void
       def initialize(logger: nil)
         @logger = logger || ::Logger.new($stdout)
         @parsers = setup_parsers
       end
 
+      #: (String tokens) -> untyped
       def parse(tokens)
         ::MultiJson.load(tokens)
       rescue ::MultiJson::ParseError => e
@@ -58,12 +66,14 @@ module Optimistic
         result[:data]
       end
 
+      #: (String tokens, untyped data, String remaining_tokens) -> void
       def handle_remaining_tokens(tokens, data, remaining_tokens)
         logger.info({ tokens: tokens, data: data, remaining_tokens: remaining_tokens })
       end
 
       private
 
+      #: () -> Hash[String, Method]
       def setup_parsers
         parsers = {}
 
@@ -76,6 +86,7 @@ module Optimistic
         parsers
       end
 
+      #: (String tokens, StandardError err) -> { data: untyped, remainder: String }
       def parse_any(tokens, err)
         parser = parsers[tokens[0]]
 
@@ -84,11 +95,13 @@ module Optimistic
         parser.call(tokens, err)
       end
 
+      #: (String tokens, StandardError err) -> { data: untyped, remainder: String }
       def parse_space(tokens, err)
         tokens = tokens.lstrip
         parse_any(tokens, err)
       end
 
+      #: (String tokens, StandardError err) -> { data: Array[untyped], remainder: String }
       def parse_array(tokens, err)
         # Skip the opening bracket & remove any spaces
         tokens = tokens[1..].lstrip
@@ -114,12 +127,13 @@ module Optimistic
         { data: data, remainder: tokens }
       end
 
+      #: (String tokens, StandardError err) -> { data: Hash[String, untyped], remainder: String }
       def parse_object(tokens, err)
         tokens = tokens[1..].lstrip
         data = {}
 
         while tokens.length.positive?
-          # Skip the closing bracket
+          # Skip the closing brace
           if tokens[0] == "}"
             tokens = tokens[1..]
             break
@@ -147,6 +161,7 @@ module Optimistic
         { data: data, remainder: tokens }
       end
 
+      #: (String tokens, StandardError _err) -> { data: (Integer | Float | String), remainder: String }
       def parse_number(tokens, _err)
         i = 0
         while i < tokens.length
@@ -165,11 +180,12 @@ module Optimistic
         { data: number_or_tokens(tokens), remainder: "" }
       end
 
+      #: (String tokens) -> (Integer | Float | String)
       def number_or_tokens(tokens)
         return 0 if tokens == "-"
 
         if tokens.include?(".")
-          # Handle incomplete floats
+          # Drop trailing dot and parse as float (e.g. "12." => 12.0)
           tokens.end_with?(".") ? Float(tokens[0...-1]) : Float(tokens)
         else
           Integer(tokens)
@@ -179,6 +195,7 @@ module Optimistic
         tokens
       end
 
+      #: (String tokens, StandardError _err) -> { data: String, remainder: String }
       def parse_string(tokens, _err)
         i = 1
         while i < tokens.length
@@ -192,27 +209,31 @@ module Optimistic
             str = tokens[0..i]
             tokens = tokens[(i + 1)..]
 
-            return { data: MultiJson.load(str), remainder: tokens }
+            return { data: ::MultiJson.load(str), remainder: tokens }
           end
 
           i += 1
         end
 
-        { data: MultiJson.load("#{tokens}\""), remainder: "" }
+        { data: ::MultiJson.load("#{tokens}\""), remainder: "" }
       end
 
+      #: (String tokens, StandardError err) -> { data: TrueClass, remainder: String }
       def parse_true(tokens, err)
         parse_token(tokens, "true", true, err)
       end
 
+      #: (String tokens, StandardError err) -> { data: FalseClass, remainder: String }
       def parse_false(tokens, err)
         parse_token(tokens, "false", false, err)
       end
 
+      #: (String tokens, StandardError err) -> { data: nil, remainder: String }
       def parse_null(tokens, err)
         parse_token(tokens, "null", nil, err)
       end
 
+      #: [T] (String tokens, String token_str, T token_val, StandardError _err) -> { data: T, remainder: String }
       def parse_token(tokens, token_str, token_val, _err)
         i = token_str.length
 

data/lib/optimistic/json/version.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
+# typed: true
 
 module Optimistic
   module Json
-    VERSION = "0.1.2"
+    VERSION = "0.1.3"
   end
 end

data/lib/optimistic/json.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 
 require "logger"
 require "multi_json"

data/sorbet/config

@@ -0,0 +1,4 @@
+--dir=lib
+--dir=sorbet/rbi
+--enable-experimental-rbs-comments
+--parser=prism

data/sorbet/rbi/annotations/.gitattributes

@@ -0,0 +1 @@
+**/*.rbi linguist-vendored=true

data/sorbet/rbi/annotations/rainbow.rbi

@@ -0,0 +1,269 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+module Rainbow
+  # @shim: https://github.com/sickill/rainbow/blob/master/lib/rainbow.rb#L10-L12
+  sig { returns(T::Boolean) }
+  attr_accessor :enabled
+
+  class Color
+    sig { returns(Symbol) }
+    attr_reader :ground
+
+    sig { params(ground: Symbol, values: T.any([Integer], [Integer, Integer, Integer])).returns(Color) }
+    def self.build(ground, values); end
+
+    sig { params(hex: String).returns([Integer, Integer, Integer]) }
+    def self.parse_hex_color(hex); end
+
+    class Indexed < Rainbow::Color
+      sig { returns(Integer) }
+      attr_reader :num
+
+      sig { params(ground: Symbol, num: Integer).void }
+      def initialize(ground, num); end
+
+      sig { returns(T::Array[Integer]) }
+      def codes; end
+    end
+
+    class Named < Rainbow::Color::Indexed
+      NAMES = T.let(nil, T::Hash[Symbol, Integer])
+
+      sig { params(ground: Symbol, name: Symbol).void }
+      def initialize(ground, name); end
+
+      sig { returns(T::Array[Symbol]) }
+      def self.color_names; end
+
+      sig { returns(String) }
+      def self.valid_names; end
+    end
+
+    class RGB < Rainbow::Color::Indexed
+      sig { returns(Integer) }
+      attr_reader :r, :g, :b
+
+      sig { params(ground: Symbol, values: Integer).void }
+      def initialize(ground, *values); end
+
+      sig { returns(T::Array[Integer]) }
+      def codes; end
+
+      sig { params(value: Numeric).returns(Integer) }
+      def self.to_ansi_domain(value); end
+    end
+
+    class X11Named < Rainbow::Color::RGB
+      include Rainbow::X11ColorNames
+
+      sig { params(ground: Symbol, name: Symbol).void }
+      def initialize(ground, name); end
+
+      sig { returns(T::Array[Symbol]) }
+      def self.color_names; end
+
+      sig { returns(String) }
+      def self.valid_names; end
+    end
+  end
+
+  sig { returns(Wrapper) }
+  def self.global; end
+
+  sig { returns(T::Boolean) }
+  def self.enabled; end
+
+  sig { params(value: T::Boolean).returns(T::Boolean) }
+  def self.enabled=(value); end
+
+  sig { params(string: String).returns(String) }
+  def self.uncolor(string); end
+
+  class NullPresenter < String
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def color(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def foreground(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def fg(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def background(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def bg(*values); end
+
+    sig { returns(NullPresenter) }
+    def reset; end
+
+    sig { returns(NullPresenter) }
+    def bright; end
+
+    sig { returns(NullPresenter) }
+    def faint; end
+
+    sig { returns(NullPresenter) }
+    def italic; end
+
+    sig { returns(NullPresenter) }
+    def underline; end
+
+    sig { returns(NullPresenter) }
+    def blink; end
+
+    sig { returns(NullPresenter) }
+    def inverse; end
+
+    sig { returns(NullPresenter) }
+    def hide; end
+
+    sig { returns(NullPresenter) }
+    def cross_out; end
+
+    sig { returns(NullPresenter) }
+    def black; end
+
+    sig { returns(NullPresenter) }
+    def red; end
+
+    sig { returns(NullPresenter) }
+    def green; end
+
+    sig { returns(NullPresenter) }
+    def yellow; end
+
+    sig { returns(NullPresenter) }
+    def blue; end
+
+    sig { returns(NullPresenter) }
+    def magenta; end
+
+    sig { returns(NullPresenter) }
+    def cyan; end
+
+    sig { returns(NullPresenter) }
+    def white; end
+
+    sig { returns(NullPresenter) }
+    def bold; end
+
+    sig { returns(NullPresenter) }
+    def dark; end
+
+    sig { returns(NullPresenter) }
+    def strike; end
+  end
+
+  class Presenter < String
+    TERM_EFFECTS = T.let(nil, T::Hash[Symbol, Integer])
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def color(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def foreground(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def fg(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def background(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def bg(*values); end
+
+    sig { returns(Presenter) }
+    def reset; end
+
+    sig { returns(Presenter) }
+    def bright; end
+
+    sig { returns(Presenter) }
+    def faint; end
+
+    sig { returns(Presenter) }
+    def italic; end
+
+    sig { returns(Presenter) }
+    def underline; end
+
+    sig { returns(Presenter) }
+    def blink; end
+
+    sig { returns(Presenter) }
+    def inverse; end
+
+    sig { returns(Presenter) }
+    def hide; end
+
+    sig { returns(Presenter) }
+    def cross_out; end
+
+    sig { returns(Presenter) }
+    def black; end
+
+    sig { returns(Presenter) }
+    def red; end
+
+    sig { returns(Presenter) }
+    def green; end
+
+    sig { returns(Presenter) }
+    def yellow; end
+
+    sig { returns(Presenter) }
+    def blue; end
+
+    sig { returns(Presenter) }
+    def magenta; end
+
+    sig { returns(Presenter) }
+    def cyan; end
+
+    sig { returns(Presenter) }
+    def white; end
+
+    sig { returns(Presenter) }
+    def bold; end
+
+    sig { returns(Presenter) }
+    def dark; end
+
+    sig { returns(Presenter) }
+    def strike; end
+  end
+
+  class StringUtils
+    sig { params(string: String, codes: T::Array[Integer]).returns(String) }
+    def self.wrap_with_sgr(string, codes); end
+
+    sig { params(string: String).returns(String) }
+    def self.uncolor(string); end
+  end
+
+  VERSION = T.let(nil, String)
+
+  class Wrapper
+    sig { returns(T::Boolean) }
+    attr_accessor :enabled
+
+    sig { params(enabled: T::Boolean).void }
+    def initialize(enabled = true); end
+
+    sig { params(string: String).returns(T.any(Rainbow::Presenter, Rainbow::NullPresenter)) }
+    def wrap(string); end
+  end
+
+  module X11ColorNames
+    NAMES = T.let(nil, T::Hash[Symbol, [Integer, Integer, Integer]])
+  end
+end
+
+sig { params(string: String).returns(Rainbow::Presenter) }
+def Rainbow(string); end

data/sorbet/rbi/gems/.gitattributes

@@ -0,0 +1 @@
+**/*.rbi linguist-generated=true