bitint 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5b4702d20c7d5f3523dda0748265809d4d581ba33a217ac33ca116c82062fed5
+  data.tar.gz: c710ff424901df06d602dc2f29b5860664583320289ea19a10cdf752eaba5980
+SHA512:
+  metadata.gz: 34c75a6b2b3ddfbdd910ffba7273a657a6d4486af4d7535325446fa430ac5acce4c9bf7e6475d2b53b31d4c194eabd46a58dfb6860b855cd6728d96ba32cace7
+  data.tar.gz: e396e8080ef6ebef611d5c300863b9771e97d1552f8d690e48569756090c7c865edcf86e8721dad0e6bbb3b0108933becbbe5b7300a834008eaa65c87148d582

data/.rdoc_options

@@ -0,0 +1 @@
+markup: markdown

data/Gemfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in bitint.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "minitest", "~> 5.0"

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Sam Westerman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,41 @@
+# BitInt
+
+This gem lets you emulate 2's complement integers in ruby.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'bitint'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install bitint
+
+## Usage
+
+```ruby
+num = BitInt::U8.new(0xfe)
+num += 2
+puts num #=> 1
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/sampersand/bitint.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+task default: :test

data/Steepfile

@@ -0,0 +1,28 @@
+D = Steep::Diagnostic
+
+target :lib do
+  signature "sig"
+
+  # check "lib"                       # Directory name
+  check "lib/bitint/bitint.rb"
+  # check "Gemfile"                   # File name
+  check "app/models/**/*.rb"        # Glob
+  # ignore "lib/templates/*.rb"
+
+  # library "pathname", "set"       # Standard libraries
+  # library "strong_json"           # Gems
+  
+  # configure_code_diagnostics(D::Ruby.strict)       # `strict` diagnostics setting
+  # configure_code_diagnostics(D::Ruby.lenient)      # `lenient` diagnostics setting
+  configure_code_diagnostics do |hash|             # You can setup everything yourself
+    hash[D::Ruby::UnknownConstant] = :hint
+  end
+end
+
+# target :test do
+#   signature "sig", "sig-private"
+#
+#   check "test"
+#
+#   # library "pathname", "set"       # Standard libraries
+# end

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "bitint"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/bitint/bitint.rb

@@ -0,0 +1,305 @@
+# frozen_string_literal: true
+
+class BitInt < Numeric
+  # Indicates that +BitInt::new+ was called with an integer that was too large.
+  class OverflowError < RuntimeError
+    attr_reader :integer, :range
+
+    def initialize(integer, range)
+      super "#{integer} is out of bounds (range=#{range})"
+      @integer = integer
+      @range = range
+    end
+  end
+
+  @classes = {}
+
+  class << self
+    private :new
+
+    # Creates a new unsigned +BitInt+ class.
+    #
+    # === Example
+    #   puts BitInt::U(16)::MAX #=> 65535
+    def U(bits) = self[bits, signed: false]
+    alias unsigned U
+
+    # Creates a new signed +BitInt+ class.
+    #
+    # === Example
+    #   puts BitInt::I(16)::MAX #=> 32767
+    def I(bits) = self[bits, signed: true]
+    alias signed I
+    alias S I
+
+    # Creates a new +BitInt+. Raises an ArgumentError if bits is negative.
+    #
+    # === Example
+    #   puts BitInt[8]::MAX #=> 255
+    #   puts BitInt[8, signed: false]::MAX #=> 255
+    #   puts BitInt[8, signed: true]::MAX #=> 127
+    def [](bits, signed: false) = create(bits: bits, signed: signed)
+
+    def create(bits: nil, bytes: nil, signed:)
+      if bits.nil? == bytes.nil?
+        raise ArgumentError, 'exactly one of `bits` or `bytes` must be supplied'
+      end
+
+      bits ||= bytes * 8
+
+      raise ArgumentError, 'bit count must be at least 1' unless bits.positive?
+
+      @classes[[bits, signed].freeze] ||= Class.new(self) do |cls|
+        cls.setup!(bits, signed)
+      end
+    end
+
+    # Returns whether this class represents a signed integer.
+    #
+    # === Example
+    #   puts BitInt::U(8).signed? #=> false
+    #   puts BitInt::I(8).signed? #=> true
+    def signed? = @signed
+
+    # Returns whether this class represents an unsigned integer.
+    #
+    # === Example
+    #   puts BitInt::U(8).unsigned? #=> false
+    #   puts BitInt::I(8).unsigned? #=> true
+    def unsigned? = !signed?
+
+    def inspect = name || "#{signed? ? 'I' : 'U'}#@bits"
+    alias to_s inspect
+
+    # :stopdoc:
+    protected def setup!(bits, signed)
+      @bits = bits
+      @signed = signed
+
+      create = ->(int) {
+        allocate.tap { |x| x.instance_variable_set :@int, int }
+      }
+
+      class << self
+        public :new
+      end
+
+      const_set :BITS, @bits
+      const_set :BYTES, (@bits / 8.0).ceil
+      const_set :MASK, (1 << @bits).pred
+      const_set :ZERO, create[0]
+      const_set :ONE, create[1]
+      const_set :MIN, create[signed? ? -(1 << @bits.pred) : 0]
+      const_set :MAX, create[signed? ? (1 << @bits.pred).pred : (1 << @bits).pred]
+      const_set :BOUNDS, self::MIN .. self::MAX
+    end
+
+    def pack_char
+
+    end
+    # :startdoc:
+  end
+
+  # Creates a new BitInt by masking +int+.
+  #
+  # If +int+ is not rdoc-ref:in_bounds? and +wrap+ is false, then an
+  # OverflowError is raised.
+  #
+  # === Example
+  #   puts BitInt::U(8).new(27) #=> 27
+  #   puts BitInt::U(8).new(-1) #=> 255
+  #   puts BitInt::U(8).new(-1, wrap: false) #=> OverflowError
+  #   puts BitInt::I(8).new(255) #=> -1
+  def initialize(int, wrap: true)
+    unless wrap || (bounds = self.class::BOUNDS).include?(int)
+      raise OverflowError.new(int, bounds)
+    end
+
+    @int = ((int - self.class::MIN.to_i) & self.class::MASK) + self.class::MIN.to_i
+  end
+
+  # Checks to see if +rhs.to_i+ is equal to this class
+  #
+  # === Example
+  #   U64 = BitInt::U(64)
+  #   twelve = U64.new(12)
+  # 
+  #   # Behaves as you'd expect.
+  #   puts twelve == U64.new(12) #=> true
+  #   puts twelve == U64.new(13) #=> false
+  #   puts twelve == 12   #=> true
+  #   puts twelve == 12.0 #=> true
+  #   puts twelve == 13   #=> false
+  #   puts twelve == Object.new #=> false
+  def ==(rhs) = rhs.respond_to?(:to_i) && @int == rhs.to_i
+
+  # Overwite rdoc-ref:Numeric#integer? as we're an integer.
+  def integer? = true
+
+  # :section: Conversions
+
+  # Returns the underlying integer.
+  def to_i = @int
+  alias to_int to_i
+
+  # Converts self to a Float.
+  def to_f = @int.to_f
+
+  # Converts self to a String.
+  #
+  # If no base is given, it just returns a normal string in base 10.
+  # If a base is given, a string padded with `0`s will be returned.
+  def to_s(base = nil)
+    return @int.to_s if base.nil?
+
+    adjusted = negative? ? (-2*self.class::MIN + self).to_i : @int
+    adjusted.to_s(base).rjust(self.class::BITS / Math.log2(base), negative? ? '1' : '0')
+  end
+
+  alias inspect to_s
+
+  # Returns a base-16 string of +self+. Equivalent to +to_s(16)+.
+  #
+  # If +upper: true+ is passed, returns an upper-case version.
+  #
+  # === Example
+  #   puts BitInt::U16.new(1234).hex #=> 04d2
+  #   puts BitInt::U16.new(1234, upper: true).hex #=> 04D2
+  def hex(upper: false)
+    to_s(16).tap { _1.upcase! if upper }
+  end
+
+  # Returns a base-8 string of +self+. Equivalent to +to_s(8)+.
+  #
+  # === Example
+  #   puts BitInt::U16.new(1234).oct #=> 02322
+  def oct
+    to_s(8)
+  end
+
+  # Returns a base-2 string of +self+. Equivalent to +to_s(2)+.
+  #
+  # === Example
+  #   puts BitInt::U16.new(54321).bin #=> 0000010011010010
+  def bin
+    to_s(2)
+  end
+
+  # :section: Math
+
+  # Numerically negates +self+.
+  def -@ = self.class.new(-@int)
+
+  # Bitwise negates +self+.
+  def ~ = self.class.new(~@int)
+
+  # Compares +self+ to +rhs+.
+  def <=>(rhs) = rhs.respond_to?(:to_i) ? @int <=> (_ = rhs).to_i : nil
+
+  # Adds +self+ to +rhs+.
+  def +(rhs) = self.class.new(@int + rhs.to_i)
+
+  # Subtracts +rhs+ from +self+.
+  def -(rhs) = self.class.new(@int - rhs.to_i)
+
+  # Multiplies +self+ by +rhs+.
+  def *(rhs) = self.class.new(@int * rhs.to_i)
+
+  # Divides +self+ by +rhs+.
+  def /(rhs) = self.class.new(@int / rhs.to_i)
+
+  # Modulos +self+ by +rhs+.
+  def %(rhs) = self.class.new(@int % rhs.to_i)
+
+  # Raises +self+ to the +rhs+th power.
+  # Note that `Numeric` only defines `.to_int` (not `.to_i`)
+  def **(rhs) = self.class.new((@int ** rhs.to_i).to_int)
+
+  # Shifts +self+ left by +rhs+ bits.
+  def <<(rhs) = self.class.new(@int << rhs.to_i)
+
+  # Shifts +self+ right by +rhs+ bits.
+  def >>(rhs) = self.class.new(@int >> rhs.to_i)
+
+  # Bitwise ANDs +self+ and +rhs+.
+  def &(rhs) = self.class.new(@int & rhs.to_i)
+
+  # Bitwise ORs +self+ and +rhs+.
+  def |(rhs) = self.class.new(@int | rhs.to_i)
+
+  # Bitwise XORs +self+ and +rhs+.
+  def ^(rhs) = self.class.new(@int ^ rhs.to_i)
+
+  # :section:
+
+  # Returns whether +self+ is a positive integer. Zero is not positive.
+  def positive? = @int.positive?
+
+  # Return whether +self+ is a negative integer. Zero is not negative.
+  def negative? = @int.negative?
+
+  # Returns whether +self+ is zero.
+  def zero? = @int.zero?
+
+  # Returns a falsey value if zero, otherwise returns +self+.
+  def nonzero? = @int.nonzero? && self
+
+  # Checks to see if +self+ is even.
+  def even? = @int.even?
+
+  # Checks to see if +self+ is odd.
+  def odd? = @int.odd?
+
+  ##################################
+  # :section: Bit-level operations #
+  ##################################
+
+  # Gets the bit at index +idx+ or returns +nil+.
+  #
+  # This is equivalent to +Integer#[]+
+  def [](idx) = @int[idx]
+
+  def anybits?(mask) = @int.anybits?(mask)
+  def allbits?(mask) = @int.allbits?(mask)
+  def nobits?(mask) = @int.nobits?(mask)
+  def bit_length = @int.bit_length
+
+  def size = (self.class::BITS / 8.0).ceil
+
+
+  PACK_FMT = {
+    [:native, 8,  false].freeze => 'C',
+    [:native, 16, false].freeze => 'S',
+    [:native, 32, false].freeze => 'L',
+    [:native, 64, false].freeze => 'Q',
+    [:native, 8,  true].freeze => 'c',
+    [:native, 16, true].freeze => 's',
+    [:native, 32, true].freeze => 'l',
+    [:native, 64, true].freeze => 'q',
+
+  }.freeze
+  private_constant :PACK_FMT
+
+  def bytes(endian = :native)
+    size = {
+      8 => 'C',
+      16 => 'S',
+      32 => 'L',
+      64 => 'Q'
+    }[self.class::BITS] or raise ArgumentError, "bytes only works for 8, 16, 32, or 64 rn." or raise ArgumentError, "endian must be :big, :little, or :native"
+    size = {8=>'C', 16=>}
+    size = case self.class::BITS
+           when 8 then 'C'
+           when 8 then 'C'
+    # sprintf "%0#{self.class::BYTES * 2}x",
+    # mask = self.class::MASK_CHAR or raise ArgumentError, "bytes only works (rn) on "
+    # pack_char = self.class.pack_Char
+    # case endian
+    # when :native then 
+  end
+end
+
+
+(-128..127).each do |n|
+  puts (BitInt::I(8).new(n)).to_s(2)
+end

data/lib/bitint/constants.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class BitInt
+  # An unsigned 8-bit integer
+  U8 = U(8)
+
+  # An unsigned 16-bit integer
+  U16 = U(16)
+
+  # An unsigned 32-bit integer
+  U32 = U(32)
+
+  # An unsigned 64-bit integer
+  U64 = U(64)
+
+  # An unsigned 128-bit integer
+  U128 = U(128)
+
+  # A signed 8-bit integer
+  I8 = I(8)
+
+  # A signed 16-bit integer
+  I16 = I(16)
+
+  # A signed 32-bit integer
+  I32 = I(32)
+
+  # A signed 64-bit integer
+  I64 = I(64)
+
+  # A signed 128-bit integer
+  I128 = I(128)
+end

data/lib/bitint/native.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'fiddle'
+
+class BitInt
+  # `BitInt`s that correspond to underlying C integer sizes.
+  module Native
+    # On big-endian systems, the unpack will equal `0x00AA`.
+    @little_endian = [0xAA00].pack('S').unpack('S<') == [0xAA00]
+
+    module_function
+
+    # Returns either `:little` or `:big` depending on the underlying system's endianness.
+    def endianness
+      @little_endian ? :little : :big
+    end
+    class << self
+      alias endian endianness
+    end
+
+    # Returns `true` when on a little endian system.
+    def little_endian?
+      endianness == :little
+    end
+
+    # Returns `true` when on a big endian system.
+    def big_endian?
+      endianness == :big
+    end
+
+    # A signed `sizeof(char)`-byte BitInt.
+    #
+    # Technically C has a difference between `char`, `unsigned char`, and `signed char`. But there's
+    # no real easy way to tell from within ruby code. So `CHAR` doesn't exist.
+    #
+    SCHAR = BitInt.create(bytes: Fiddle::SIZEOF_CHAR, signed: true)
+
+    # An unsigned `sizeof(char)`-byte BitInt.
+    UCHAR = BitInt.create(bytes: Fiddle::SIZEOF_CHAR, signed: false)
+
+    # A signed `sizeof(short)`-byte BitInt.
+    SHORT = BitInt.create(bytes: Fiddle::SIZEOF_SHORT, signed: true)
+
+    # An unsigned `sizeof(short)`-byte BitInt.
+    USHORT = BitInt.create(bytes: Fiddle::SIZEOF_SHORT, signed: false)
+
+    # A signed `sizeof(int)`-byte BitInt.
+    INT = BitInt.create(bytes: Fiddle::SIZEOF_INT, signed: true)
+
+    # An unsigned `sizeof(short)`-byte BitInt.
+    UINT = BitInt.create(bytes: Fiddle::SIZEOF_INT, signed: false)
+
+    # A signed `sizeof(long)`-byte BitInt.
+    LONG = BitInt.create(bytes: Fiddle::SIZEOF_LONG, signed: true)
+
+    # An unsigned `sizeof(short)`-byte BitInt.
+    ULONG = BitInt.create(bytes: Fiddle::SIZEOF_LONG, signed: false)
+
+    # Some platforms Ruby supports don't actually support `long long`s (in this day and age...)
+    if defined? Fiddle::SIZEOF_LONG_LONG
+      # A signed `sizeof(long long)`-byte BitInt. Only enabled if the platform supports `long long`.
+      LONG_LONG = BitInt.create(bytes: Fiddle::SIZEOF_LONG_LONG, signed: true)
+
+      # An unsigned `sizeof(long long)`-byte BitInt. Only enabled if the platform supports `long long`.
+      ULONG_LONG = BitInt.create(bytes: Fiddle::SIZEOF_LONG_LONG, signed: false)
+    end
+
+    # An unsigned `sizeof(void *)`-byte BitInt.
+    VOIDP = BitInt.create(bytes: Fiddle::SIZEOF_VOIDP, signed: false)
+
+    # An unsigned `sizeof(size_t)`-byte BitInt.
+    SIZE_T = BitInt.create(bytes: Fiddle::SIZEOF_SIZE_T, signed: false)
+
+    # A signed `sizeof(ssize_t)`-byte BitInt.
+    SSIZE_T = BitInt.create(bytes: Fiddle::SIZEOF_SSIZE_T, signed: true)
+
+    # A signed `sizeof(ptrdiff_t)`-byte BitInt.
+    PTRDIFF_T = BitInt.create(bytes: Fiddle::SIZEOF_PTRDIFF_T, signed: true)
+
+    # A signed `sizeof(intptr_t)`-byte BitInt.
+    INTPTR_T = BitInt.create(bytes: Fiddle::SIZEOF_INTPTR_T, signed: true)
+
+    # An unsigned `sizeof(uintptr_t)`-byte BitInt.
+    UINTPTR_T = BitInt.create(bytes: Fiddle::SIZEOF_UINTPTR_T, signed: false)
+  end
+end

data/lib/bitint/refinements.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+class BitInt
+  # Refinements to Integer for easy "BitInt literals" (eg `12.u8`)
+  module Refinements
+    refine Integer do
+      # Converts +self+ into an unsigned +bits+-bit integer.
+      #
+      # Any additional arguments are forwarded to +BitInt#new+
+      #
+      # === Examples
+      #   puts BitInt::U(16)::MAX #=> 65535
+      #   
+      def u(bits, ...)
+        BitInt::U(bits, ...).new(self)
+      end
+
+      # Converts +self+ into a signed +bits+-bit integer.
+      #
+      # If no arguments are given, this instead forwards to Numeric#i.
+      #
+      # Any additional arguments are forwarded to +BitInt#new+
+      def i(bits = nil, ...)
+        return super if bits.nil?
+
+        BitInt::i(bits, ...).new(self)
+      end
+
+      # Converts +self+ into an unsigned 8-bit integer.
+      #
+      # Any additional arguments are forwarded to +BitInt#new+
+      def u8(...)
+        u(8, ...)
+      end
+
+      # Converts +self+ into an unsigned 16-bit integer.
+      #
+      # Any additional arguments are forwarded to +BitInt#new+
+      def u16(...)
+        u(16, ...)
+      end
+
+      # Converts +self+ into an unsigned 32-bit integer.
+      #
+      # Any additional arguments are forwarded to +BitInt#new+
+      def u32(...)
+        u(32, ...)
+      end
+
+      # Converts +self+ into an unsigned 64-bit integer.
+      #
+      # Any additional arguments are forwarded to +BitInt#new+
+      def u64(...)
+        u(64, ...)
+      end
+
+      # Converts +self+ into an unsigned 128-bit integer.
+      #
+      # Any additional arguments are forwarded to +BitInt#new+
+      def u128(...)
+        u(128, ...)
+      end
+
+      # Converts +self+ into a signed 8-bit integer.
+      #
+      # Any additional arguments are forwarded to +BitInt#new+
+      def i8(...)
+        i(8, ...)
+      end
+
+      # Converts +self+ into a signed 16-bit integer.
+      #
+      # Any additional arguments are forwarded to +BitInt#new+
+      def i16(...)
+        i(16, ...)
+      end
+
+      # Converts +self+ into a signed 32-bit integer.
+      #
+      # Any additional arguments are forwarded to +BitInt#new+
+      def i32(...)
+        i(32, ...)
+      end
+
+      # Converts +self+ into a signed 64-bit integer.
+      #
+      # Any additional arguments are forwarded to +BitInt#new+
+      def i64(...)
+        i(64, ...)
+      end
+
+      # Converts +self+ into a signed 128-bit integer.
+      #
+      # Any additional arguments are forwarded to +BitInt#new+
+      def i128(...)
+        i(128, ...)
+      end
+    end
+  end
+end

data/lib/bitint/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class BitInt
+  # The current version of BitInt.
+  VERSION = '0.5.0'
+end

data/lib/bitint.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class BitInt < Numeric
+end
+
+require_relative 'bitint/version'
+require_relative 'bitint/bitint'
+require_relative 'bitint/refinements'
+require_relative 'bitint/native'
+require_relative 'bitint/constants'

data/sig/bitint/bitint.rbs

@@ -0,0 +1,62 @@
+module BitInt
+  class OutOfBoundError < Error
+    attr_reader integer: Integer
+
+    attr_reader range: untyped
+
+    def initialize: (untyped integer, untyped range) -> void
+  end
+
+  class BitInt < Numeric
+    self.@bits: Integer
+    self.@signed: bool
+    MIN: instance
+    MAX: instance
+    BITS: Integer
+    MASK: Integer
+    ZERO: instance
+    ONE: instance
+
+    def self.in_bounds?: (Integer integer) -> bool
+    def self.U: (Integer bits) -> class
+    def self.I: (Integer bits) -> class
+    def self.[]: (Integer bits, ?signed: bool) -> class
+    def self.signed?: () -> bool
+    def self.unsigned?: () -> bool
+    def self.mask: (Integer int) -> untyped
+    def self.setup!: (Integer bits, bool signed) -> void
+    def self.inspect: () -> String
+    alias self.to_s self.inspect
+
+    @int: Integer
+    def initialize: (Integer int, ?wrap: bool) -> void
+    def ==: (Object rhs) -> bool
+
+    def to_i: () -> Integer
+    alias to_int to_i
+    def to_f: () -> Float
+    def to_s: (?Integer? base) -> String
+    alias inspect to_s
+
+    def hex: () -> String
+    def oct: () -> String
+    def bin: () -> String
+
+    def -@: () -> BitInt
+    def ~: () -> BitInt
+    def []: (int idx) -> Integer?
+    def <=>: (Object rhs) -> Integer?
+    def +: (_ToI rhs) -> BitInt
+    def -: (_ToI rhs) -> BitInt
+    def /: (_ToI rhs) -> BitInt
+    def *: (_ToI rhs) -> BitInt
+    def %: (_ToI rhs) -> BitInt
+    def **: (_ToI rhs) -> BitInt
+    def <<: (_ToI rhs) -> BitInt
+    def >>: (_ToI rhs) -> BitInt
+    def &: (_ToI rhs) -> BitInt
+    def |: (_ToI rhs) -> BitInt
+    def ^: (_ToI rhs) -> BitInt
+    def integer?: () -> true
+  end
+end

data/sig/bitint/error.rbs

@@ -0,0 +1,4 @@
+module BitInt
+  class Error < RuntimeError
+  end
+end

data/sig/bitint/refinements.rb

@@ -0,0 +1,4 @@
+module BitInt
+  module Refinements
+  end
+end

data/sig/bitint/version.rbs

@@ -0,0 +1,3 @@
+module BitInt
+  VERSION: String
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: bitint
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+platform: ruby
+authors:
+- Sam Westerman
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-05-01 00:00:00.000000000 Z
+dependencies: []
+description:
+email:
+- mail@sampersand.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rdoc_options"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- Steepfile
+- bin/console
+- bin/setup
+- lib/bitint.rb
+- lib/bitint/bitint.rb
+- lib/bitint/constants.rb
+- lib/bitint/native.rb
+- lib/bitint/refinements.rb
+- lib/bitint/version.rb
+- sig/bitint/bitint.rbs
+- sig/bitint/error.rbs
+- sig/bitint/refinements.rb
+- sig/bitint/version.rbs
+homepage: https://github.com/sampersand/bitint
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/sampersand/bitint
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.3
+signing_key:
+specification_version: 4
+summary: A 2's-complement integer of arbitrary length
+test_files: []