rrs 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c0d9733af6339a12ce11ff22d41f27142c86f16b46755c9b12c671f9a851fa6e
+  data.tar.gz: a3df3377fa1a8f10e93281536fb4ccdcfc1cdd2bf19ab3bf5ce8e2840f575a60
+SHA512:
+  metadata.gz: f8ab7a7e7b4d8046101570b92a1ac8e7e07fd55100a3d43f4287b6c48ad317e5f13c07ccd80c743a6cd46a624d21dd82f5f27c993ea90430f79ace1e0b790f21
+  data.tar.gz: 6e2479f8d855d39afb625f61699501ec4d2d00c7d177d2f950d63dc845c260e0a6a02b6daf37e8f1e5fdb9b73b51357d9e58f735ddc3b35599025674b4688317

data/.standard.yml

@@ -0,0 +1,3 @@
+# For available configuration options, see:
+#   https://github.com/standardrb/standard
+ruby_version: 3.0

data/README.md

@@ -0,0 +1,31 @@
+# RRs
+
+TODO: Delete this and the text below, and describe your gem
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/rrs`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+## Installation
+
+TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. 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/[USERNAME]/rrs.

data/Rakefile

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "standard/rake"
+
+task default: :standard

data/lib/rrs/a.rb

@@ -0,0 +1,26 @@
+module RRs
+  class A
+    TypeValue = 1
+    ClassValue = 1
+  
+    ##
+    # Creates a new A for +address+.
+  
+    def initialize(address)
+      @address = IPv4.create(address)
+    end
+  
+    ##
+    # The IPv4 address for this A.
+  
+    attr_reader :address
+  
+    def encode_rdata(msg) # :nodoc:
+      msg.put_bytes(@address.address)
+    end
+  
+    def self.decode_rdata(msg) # :nodoc:
+      return self.new(IPv4.new(msg.get_bytes(4)))
+    end
+  end
+end

data/lib/rrs/inflector.rb

@@ -0,0 +1,13 @@
+module RRs
+  class Inflector < Zeitwerk::Inflector
+    def camelize(basename, abspath)
+      if basename =~ /\Arrs(.*)/
+        "RRs" + super($1, abspath)
+      elsif basename =~ /\Aipv(.*)/
+        "IPv" + super($1, abspath)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/rrs/ipv4.rb

@@ -0,0 +1,69 @@
+module RRs
+  class IPv4
+
+    ##
+    # Regular expression IPv4 addresses must match.
+
+    Regex256 = /0
+                |1(?:[0-9][0-9]?)?
+                |2(?:[0-4][0-9]?|5[0-5]?|[6-9])?
+                |[3-9][0-9]?/x
+    Regex = /\A(#{Regex256})\.(#{Regex256})\.(#{Regex256})\.(#{Regex256})\z/
+
+    def self.create(arg)
+      case arg
+      when IPv4
+        return arg
+      when Regex
+        if (0..255) === (a = $1.to_i) &&
+            (0..255) === (b = $2.to_i) &&
+            (0..255) === (c = $3.to_i) &&
+            (0..255) === (d = $4.to_i)
+          return self.new([a, b, c, d].pack("CCCC"))
+        else
+          raise ArgumentError.new("IPv4 address with invalid value: " + arg)
+        end
+      else
+        raise ArgumentError.new("cannot interpret as IPv4 address: #{arg.inspect}")
+      end
+    end
+
+    def initialize(address) # :nodoc:
+      unless address.kind_of?(String)
+        raise ArgumentError, 'IPv4 address must be a string'
+      end
+      unless address.length == 4
+        raise ArgumentError, "IPv4 address expects 4 bytes but #{address.length} bytes"
+      end
+      @address = address
+    end
+
+    ##
+    # A String representation of this IPv4 address.
+
+    ##
+    # The raw IPv4 address as a String.
+
+    attr_reader :address
+
+    def to_s # :nodoc:
+      return sprintf("%d.%d.%d.%d", *@address.unpack("CCCC"))
+    end
+
+    def inspect # :nodoc:
+      return "#<#{self.class} #{self}>"
+    end
+
+    def ==(other) # :nodoc:
+      return @address == other.address
+    end
+
+    def eql?(other) # :nodoc:
+      return self == other
+    end
+
+    def hash # :nodoc:
+      return @address.hash
+    end
+  end
+end

data/lib/rrs/ipv6.rb

@@ -0,0 +1,154 @@
+module RRs
+  class IPv6
+
+    ##
+    # IPv6 address format a:b:c:d:e:f:g:h
+    Regex_8Hex = /\A
+      (?:[0-9A-Fa-f]{1,4}:){7}
+          [0-9A-Fa-f]{1,4}
+      \z/x
+
+    ##
+    # Compressed IPv6 address format a::b
+
+    Regex_CompressedHex = /\A
+      ((?:[0-9A-Fa-f]{1,4}(?::[0-9A-Fa-f]{1,4})*)?) ::
+      ((?:[0-9A-Fa-f]{1,4}(?::[0-9A-Fa-f]{1,4})*)?)
+      \z/x
+
+    ##
+    # IPv4 mapped IPv6 address format a:b:c:d:e:f:w.x.y.z
+
+    Regex_6Hex4Dec = /\A
+      ((?:[0-9A-Fa-f]{1,4}:){6,6})
+      (\d+)\.(\d+)\.(\d+)\.(\d+)
+      \z/x
+
+    ##
+    # Compressed IPv4 mapped IPv6 address format a::b:w.x.y.z
+
+    Regex_CompressedHex4Dec = /\A
+      ((?:[0-9A-Fa-f]{1,4}(?::[0-9A-Fa-f]{1,4})*)?) ::
+      ((?:[0-9A-Fa-f]{1,4}:)*)
+      (\d+)\.(\d+)\.(\d+)\.(\d+)
+      \z/x
+
+    ##
+    # IPv6 link local address format fe80:b:c:d:e:f:g:h%em1
+    Regex_8HexLinkLocal = /\A
+      [Ff][Ee]80
+      (?::[0-9A-Fa-f]{1,4}){7}
+      %[-0-9A-Za-z._~]+
+      \z/x
+
+    ##
+    # Compressed IPv6 link local address format fe80::b%em1
+
+    Regex_CompressedHexLinkLocal = /\A
+      [Ff][Ee]80:
+      (?:
+        ((?:[0-9A-Fa-f]{1,4}(?::[0-9A-Fa-f]{1,4})*)?) ::
+        ((?:[0-9A-Fa-f]{1,4}(?::[0-9A-Fa-f]{1,4})*)?)
+        |
+        :((?:[0-9A-Fa-f]{1,4}(?::[0-9A-Fa-f]{1,4})*)?)
+      )?
+      :[0-9A-Fa-f]{1,4}%[-0-9A-Za-z._~]+
+      \z/x
+
+    ##
+    # A composite IPv6 address Regexp.
+
+    Regex = /
+      (?:#{Regex_8Hex}) |
+      (?:#{Regex_CompressedHex}) |
+      (?:#{Regex_6Hex4Dec}) |
+      (?:#{Regex_CompressedHex4Dec}) |
+      (?:#{Regex_8HexLinkLocal}) |
+      (?:#{Regex_CompressedHexLinkLocal})
+      /x
+
+    ##
+    # Creates a new IPv6 address from +arg+ which may be:
+    #
+    # IPv6:: returns +arg+.
+    # String:: +arg+ must match one of the IPv6::Regex* constants
+
+    def self.create(arg)
+      case arg
+      when IPv6
+        return arg
+      when String
+        address = ''.b
+        if Regex_8Hex =~ arg
+          arg.scan(/[0-9A-Fa-f]+/) {|hex| address << [hex.hex].pack('n')}
+        elsif Regex_CompressedHex =~ arg
+          prefix = $1
+          suffix = $2
+          a1 = ''.b
+          a2 = ''.b
+          prefix.scan(/[0-9A-Fa-f]+/) {|hex| a1 << [hex.hex].pack('n')}
+          suffix.scan(/[0-9A-Fa-f]+/) {|hex| a2 << [hex.hex].pack('n')}
+          omitlen = 16 - a1.length - a2.length
+          address << a1 << "\0" * omitlen << a2
+        elsif Regex_6Hex4Dec =~ arg
+          prefix, a, b, c, d = $1, $2.to_i, $3.to_i, $4.to_i, $5.to_i
+          if (0..255) === a && (0..255) === b && (0..255) === c && (0..255) === d
+            prefix.scan(/[0-9A-Fa-f]+/) {|hex| address << [hex.hex].pack('n')}
+            address << [a, b, c, d].pack('CCCC')
+          else
+            raise ArgumentError.new("not numeric IPv6 address: " + arg)
+          end
+        elsif Regex_CompressedHex4Dec =~ arg
+          prefix, suffix, a, b, c, d = $1, $2, $3.to_i, $4.to_i, $5.to_i, $6.to_i
+          if (0..255) === a && (0..255) === b && (0..255) === c && (0..255) === d
+            a1 = ''.b
+            a2 = ''.b
+            prefix.scan(/[0-9A-Fa-f]+/) {|hex| a1 << [hex.hex].pack('n')}
+            suffix.scan(/[0-9A-Fa-f]+/) {|hex| a2 << [hex.hex].pack('n')}
+            omitlen = 12 - a1.length - a2.length
+            address << a1 << "\0" * omitlen << a2 << [a, b, c, d].pack('CCCC')
+          else
+            raise ArgumentError.new("not numeric IPv6 address: " + arg)
+          end
+        else
+          raise ArgumentError.new("not numeric IPv6 address: " + arg)
+        end
+        return IPv6.new(address)
+      else
+        raise ArgumentError.new("cannot interpret as IPv6 address: #{arg.inspect}")
+      end
+    end
+
+    def initialize(address) # :nodoc:
+      unless address.kind_of?(String) && address.length == 16
+        raise ArgumentError.new('IPv6 address must be 16 bytes')
+      end
+      @address = address
+    end
+
+    ##
+    # The raw IPv6 address as a String.
+
+    attr_reader :address
+
+    def to_s # :nodoc:
+      sprintf("%x:%x:%x:%x:%x:%x:%x:%x", *@address.unpack("nnnnnnnn")).sub(/(^|:)0(:0)+(:|$)/, '::')
+    end
+
+    def inspect # :nodoc:
+      return "#<#{self.class} #{self}>"
+    end
+
+    def ==(other) # :nodoc:
+      return @address == other.address
+    end
+
+    def eql?(other) # :nodoc:
+      return self == other
+    end
+
+    def hash # :nodoc:
+      return @address.hash
+    end
+  end
+end

data/lib/rrs.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+require "zeitwerk"
+require_relative "rrs/inflector"
+
+loader = Zeitwerk::Loader.for_gem
+loader.inflector = RRs::Inflector.new
+loader.setup
+
+module RRs
+  VERSION = "0.1.0"
+
+  class Error < StandardError; end
+end
+
+loader.eager_load

data/sig/rrs.rbs

@@ -0,0 +1,4 @@
+module RRs
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: rrs
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- reesericci
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-08-17 00:00:00.000000000 Z
+dependencies: []
+description: "RRs is a set of self-contained DNS primitives that do not share state,
+  which makes them suitable for use in Ractors. \n\nThis is a contrast to the Resolv::DNS
+  and Dnsruby primitives which use a ClassHash."
+email:
+- me@reeseric.ci
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".standard.yml"
+- README.md
+- Rakefile
+- lib/rrs.rb
+- lib/rrs/a.rb
+- lib/rrs/inflector.rb
+- lib/rrs/ipv4.rb
+- lib/rrs/ipv6.rb
+- sig/rrs.rbs
+homepage: https://codeberg.org/reesericci/rrs
+licenses: []
+metadata:
+  homepage_uri: https://codeberg.org/reesericci/rrs
+  source_code_uri: https://codeberg.org/reesericci/rrs
+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.5.17
+signing_key:
+specification_version: 4
+summary: RRs is a set of self-contained DNS primitives
+test_files: []