dnsmessage 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b0f9b39a569f631d9aee6c28f8820787ae68a3f62d24ef6d64e0b6275677dbc
-  data.tar.gz: 6d30ad38144d9117c2991439ea274bcfc3594e787583f816638ef87af417e6dc
+  metadata.gz: 8443bcf9f586254aba74f3e64dec4da233e3b379f3e713dd90082de832a7b010
+  data.tar.gz: 8369031d2199b20dd50317fc422f9f6124fc8e313465effab31d549762fda05a
 SHA512:
-  metadata.gz: f5a5014c67f58edd7f0ce8da1659207fc3e53ebd4167997f0d89beadf6d7c72f203f939f41c8c18f1d87c28c0506aeb6843a892109c83b8006af465b30b76935
-  data.tar.gz: 6fc03487323152b8f51b028c6d009c3818f7a7bdd1e500d4ad4cb8fd430a8239d9c18608e4359ad5ef84b95822e6b160bdd19712735967324640547957acd414
+  metadata.gz: 594e07ee15de5c2cfffd76a4134e99b600fbea140584712ce4e103e28d2b97431ee5db6d55d2a7b0e04e2ab138686e35e891cac38d796730dfcb5bbcb41875f2
+  data.tar.gz: ea04b8007c81825812fe20f78d1b62e33046636e3a71a777725d675c07bca68af1008d6fce77d07f06806788203a56dc85aae5f6f559c111354ee04df1e319d2

data/.github/workflows/ruby.yml

@@ -9,9 +9,9 @@ name: Ruby
 
 on:
   push:
-    branches: [ master ]
+    branches: [ main ]
   pull_request:
-    branches: [ master ]
+    branches: [ main ]
 
 jobs:
   test:
@@ -19,7 +19,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby-version: ['2.6', '2.7', '3.0']
+        ruby-version: ['2.7', '3.0']
 
     steps:
     - uses: actions/checkout@v2

data/.rubocop.yml

@@ -0,0 +1,33 @@
+require:
+  - rubocop-rake
+  - rubocop-rspec
+
+# Commonly used screens these days easily fit more than 80 characters.
+Layout/LineLength:
+  Max: 120
+
+# Too short methods lead to extraction of single-use methods, which can make
+# the code easier to read (by naming things), but can also clutter the class
+Metrics/MethodLength:
+  Max: 20
+
+# The guiding principle of classes is SRP, SRP can't be accurately measured by LoC
+Metrics/ClassLength:
+  Max: 1500
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+# Most readable form.
+Layout/HashAlignment:
+  EnforcedHashRocketStyle: table
+  EnforcedColonStyle: table
+
+# Rspec kind of breaks without this
+Metrics/BlockLength:
+  IgnoredMethods: ['describe', 'context']

data/Gemfile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 source "https://rubygems.org"
 
 # Specify your gem's dependencies in dnsmessage.gemspec
@@ -5,3 +7,6 @@ gemspec
 
 gem "rake", "~> 12.0"
 gem "rspec", "~> 3.0"
+gem "rubocop", "~> 1.0"
+gem "rubocop-rake", require: false
+gem "rubocop-rspec", require: false

data/README.md

@@ -72,9 +72,9 @@ Currently implemented types are:
 * OPT
 * TXT
 
-Other records should be easy to add on a per-need basis as they should
-be based on the building blocks of already existing. Look at
-contributing for details on adding RR types.
+Other records should be easy to add on a per-need basis as they can be
+based on the building blocks of already existing parsers and builders.
+Look at contributing for details on adding RR types.
 
 ## Development
 

data/Rakefile

@@ -1,6 +1,12 @@
+# frozen_string_literal: true
+
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
 
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/bin/console

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require "bundler/setup"
 require "dnsmessage"

data/dnsmessage.gemspec

@@ -1,4 +1,6 @@
-require_relative 'lib/dnsmessage/version'
+# frozen_string_literal: true
+
+require_relative "lib/dnsmessage/version"
 
 Gem::Specification.new do |spec|
   spec.name          = "dnsmessage"
@@ -6,13 +8,13 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Claus Lensbøl"]
   spec.email         = ["cmol@cmol.dk"]
 
-  spec.summary       = %q{Ruby library to build and parse DNS messages}
-  spec.description   = %q{A full featured DNS parser. The library supports DNS
+  spec.summary       = "Ruby library to build and parse DNS messages"
+  spec.description   = 'A full featured DNS parser. The library supports DNS
 name compression and gives access to parse, build, and manipulate all aspects
-of the DNS queries and replies.}
+of the DNS queries and replies.'
   spec.homepage      = "https://github.com/cmol/dnsmessage"
   spec.license       = "MIT"
-  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.7.0")
 
   spec.metadata["allowed_push_host"] = "https://rubygems.org"
 
@@ -22,10 +24,16 @@ of the DNS queries and replies.}
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+
+  # For more information and examples about making a new gem, checkout our
+  # guide at: https://bundler.io/guides/creating_gem.html
 end

data/examples/server.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # This example implements an IP discover mechanism for IPv4 and IPv6.
 # Run server with `ruby server.rb` and query with something like
 # `dig my.ip @[address_of_server]`
@@ -8,7 +10,7 @@ require "socket"
 require "dnsmessage"
 
 LISTEN_ADDR = "::"
-LISTEN_PORT = 12345
+LISTEN_PORT = 12_345
 MSG_LENGTH  = 1400
 FLAGS       = 0
 
@@ -23,10 +25,10 @@ loop do
 
   # Extract client information given as array and log connection
   addr_info = Addrinfo.new(client)
-  puts "Client connected from #{addr_info.ip_address} using " +
-    "#{addr_info.ipv6_v4mapped? ? "IPv4" : "IPv6"}"
+  puts "Client connected from #{addr_info.ip_address} using " \
+       "#{addr_info.ipv6_v4mapped? ? "IPv4" : "IPv6"}"
 
-  response = DNSMessage::Message::reply_to(msg)
+  response = DNSMessage::Message.reply_to(msg)
   opt = DNSMessage::RR.default_opt(512)
 
   # Set IPv6 defaults
@@ -39,10 +41,11 @@ loop do
     ip = addr_info.ipv6_to_ipv4.ip_address
   end
   response.answers << DNSMessage::RR.new(
-    name: "your.ip",
-    type: type,
-    ttl: 10,
-    rdata: IPAddr.new(ip))
+    name:  "your.ip",
+    type:  type,
+    ttl:   10,
+    rdata: IPAddr.new(ip)
+  )
 
   # Be nice and add an EDNS record
   response.additionals << opt

data/lib/dnsmessage.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "dnsmessage/version"
 require "dnsmessage/enums"
 require "dnsmessage/message"

data/lib/dnsmessage/enums.rb

@@ -1,64 +1,68 @@
+# frozen_string_literal: true
+
+# Generel DNS enum definitions
 module DNSMessage
+  # Enums for ResourceRecord types
   module Type
     TYPE_STRINGS = {
-      1     => :A,
-      28    => :AAAA,
-      18    => :AFSDB,
-      42    => :APL,
-      257   => :CAA,
-      60    => :CDNSKEY,
-      59    => :CDS,
-      37    => :CERT,
-      5     => :CNAME,
-      62    => :CSYNC,
-      49    => :DHCID,
-      32769 => :DLV,
-      39    => :DNAME,
-      48    => :DNSKEY,
-      43    => :DS,
-      108   => :EUI48,
-      109   => :EUI64,
-      13    => :HINFO,
-      55    => :HIP,
-      45    => :IPSECKEY,
-      25    => :KEY,
-      36    => :KX,
-      29    => :LOC,
-      15    => :MX,
-      35    => :NAPTR,
-      2     => :NS,
-      47    => :NSE,
-      50    => :NSEC3,
-      51    => :NSEC3PARAM,
-      61    => :OPENPGPKEY,
-      12    => :PTR,
-      46    => :RRSIG,
-      17    => :RP,
-      24    => :SIG,
-      53    => :SMIMEA,
-      6     => :SOA,
-      33    => :SRV,
-      44    => :SSHFP,
-      32768 => :TA,
-      249   => :TKEY,
-      52    => :TLSA,
-      250   => :TSIG,
-      16    => :TXT,
-      256   => :URI,
-      63    => :ZONEMD,
-      64    => :SVCB,
-      65    => :HTTPS,
-      252   => :AXFR,
-      251   => :IXFR,
-      41    => :OPT
-    }
+      1      => :A,
+      28     => :AAAA,
+      18     => :AFSDB,
+      42     => :APL,
+      257    => :CAA,
+      60     => :CDNSKEY,
+      59     => :CDS,
+      37     => :CERT,
+      5      => :CNAME,
+      62     => :CSYNC,
+      49     => :DHCID,
+      32_769 => :DLV,
+      39     => :DNAME,
+      48     => :DNSKEY,
+      43     => :DS,
+      108    => :EUI48,
+      109    => :EUI64,
+      13     => :HINFO,
+      55     => :HIP,
+      45     => :IPSECKEY,
+      25     => :KEY,
+      36     => :KX,
+      29     => :LOC,
+      15     => :MX,
+      35     => :NAPTR,
+      2      => :NS,
+      47     => :NSE,
+      50     => :NSEC3,
+      51     => :NSEC3PARAM,
+      61     => :OPENPGPKEY,
+      12     => :PTR,
+      46     => :RRSIG,
+      17     => :RP,
+      24     => :SIG,
+      53     => :SMIMEA,
+      6      => :SOA,
+      33     => :SRV,
+      44     => :SSHFP,
+      32_768 => :TA,
+      249    => :TKEY,
+      52     => :TLSA,
+      250    => :TSIG,
+      16     => :TXT,
+      256    => :URI,
+      63     => :ZONEMD,
+      64     => :SVCB,
+      65     => :HTTPS,
+      252    => :AXFR,
+      251    => :IXFR,
+      41     => :OPT
+    }.freeze
 
-    TYPE_STRINGS.each do |num,name|
+    TYPE_STRINGS.each do |num, name|
       const_set(name, num)
     end
-
   end
 
+  # The supported DNS classes
   module Class
     IN = 1
   end

data/lib/dnsmessage/message.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module DNSMessage
+  # Message is the central class that most users of the API will use
   class Message
-
     NAME_POINTER = 0xc0
     POINTER_MASK = 0x3fff
     QUERY        = 0
@@ -8,46 +10,54 @@ module DNSMessage
     HEADER_SIZE  = 12
 
     attr_accessor :questions, :answers, :authority, :additionals,
-                  :id, :qr, :opcode, :aa, :tc, :rd, :ra, :z, :rcode,
-                  :qdcount, :ancount, :nscount, :arcount
+                  :id, :qr, :opcode, :aa, :tc, :rd, :ra, :z, :rcode
+    attr_reader :qdcount, :ancount, :nscount, :arcount
 
-    def initialize()
+    def initialize
       @questions   = []
       @answers     = []
       @additionals = []
       @authority   = []
-      @id = @qr = @opcode = @aa = @tc = @rd = @ra = @z = $rcode = 0
+      @qdcount     = 0
+      @ancount     = 0
+      @nscount     = 0
+      @arcount     = 0
+      @id = @qr = @opcode = @aa = @tc = @rd = @ra = @z = @rcode = 0
     end
 
     def parse(input)
-      ptr = Pointer.new()
+      ptr = Pointer.new
       parse_header(input)
-      idx               = parse_questions(input, @qdcount, ptr)
-      @answers, idx     = parse_records(input, @ancount, idx, ptr)
-      @authority, idx   = parse_records(input, @nscount, idx, ptr)
-      @additionals, idx = parse_records(input, @arcount, idx, ptr)
+      idx = parse_questions(input, @qdcount, ptr)
+      @answers, idx = parse_records(input, @ancount, idx, ptr)
+      @authority, idx = parse_records(input, @nscount, idx, ptr)
+      @additionals, = parse_records(input, @arcount, idx, ptr)
     end
 
     def self.parse(input)
-      self.new().tap do | m |
+      new.tap do |m|
         m.parse(input)
       end
     end
 
-    def self.reply_to(q)
-      self.new().tap do | r |
-        r.id = q.id
+    def self.reply_to(query)
+      new.tap do |r|
+        r.id = query.id
         r.qr = REPLY
-        r.questions = q.questions
-        r.qdcount = q.qdcount
+        r.questions = query.questions
       end
     end
 
-
     def parse_header(message)
       return nil if message.nil? || message.empty?
+
       @id, opts, @qdcount, @ancount, @nscount, @arcount =
         message[0...12].unpack("n6")
+
+      parse_opts(opts)
+    end
+
+    def parse_opts(opts)
       @qr     = (opts >> 15) & 0x1
       @opcode = (opts >> 11) & 0xf
       @aa     = (opts >> 10) & 0x1
@@ -61,7 +71,7 @@ module DNSMessage
     def parse_questions(message, num_questions, ptr)
       idx = HEADER_SIZE # Header takes up the first 12 bytes
       @questions = (0...num_questions).map do
-        Question.parse(message, ptr, idx).tap do | q |
+        Question.parse(message, ptr, idx).tap do |q|
           idx += q.size
         end
       end
@@ -70,42 +80,71 @@ module DNSMessage
 
     def parse_records(message, num_records, idx, ptr)
       [num_records.times.map do
-        ResourceRecord.parse(message[idx..-1],ptr).tap do | rr |
-          ptr.add_arr(rr.add_to_hash,idx)
+        ResourceRecord.parse(message[idx..], ptr).tap do |rr|
+          ptr.add_arr(rr.add_to_hash, idx)
           idx += rr.size
         end
       end,
-      idx]
+       idx]
     end
 
     def build
-      ptr = Pointer.new()
-      packet  = build_header
+      ptr = Pointer.new
+      packet = build_header
       packet << build_questions(ptr, packet.size)
       packet << build_answers(ptr, packet.size)
       packet << build_authority(ptr, packet.size)
-      packet << build_additionals(ptr,packet.size)
+      packet << build_additionals(ptr, packet.size)
     end
 
     def build_header
-      opts = (@qr     & 0x1) << 15 |
-             (@opcode & 0xf) << 11 |
-             (@aa     & 0x1) << 10 |
-             (@tc     & 0x1) << 9  |
-             (@rd     & 0x1) << 8  |
-             (@ra     & 0x1) << 7  |
-             (@z      & 0x7) << 4  |
-             (@z      & 0xf)
-      [@id, opts,
+      [@id, build_opts,
        @questions.length,
        @answers.length,
        @authority.length,
        @additionals.length].pack("n6")
     end
 
+    def build_opts
+      build_qr | build_opcode | build_aa | build_tc | build_rd | build_ra |
+        build_z | build_rcode
+    end
+
+    def build_qr
+      (@qr & 0x1) << 15
+    end
+
+    def build_opcode
+      (@opcode & 0xf) << 11
+    end
+
+    def build_aa
+      (@aa & 0x1) << 10
+    end
+
+    def build_tc
+      (@tc & 0x1) << 9
+    end
+
+    def build_rd
+      (@rd & 0x1) << 8
+    end
+
+    def build_ra
+      (@ra & 0x1) << 7
+    end
+
+    def build_z
+      (@z & 0x1) << 7
+    end
+
+    def build_rcode
+      (@rcode & 0xf)
+    end
+
     def build_questions(ptr, idx)
-      @questions.map do | q |
-        q.build(ptr,idx).tap do | bytes |
+      @questions.map do |q|
+        q.build(ptr, idx).tap do |bytes|
           idx += bytes.length
         end
       end.join("")
@@ -124,8 +163,8 @@ module DNSMessage
     end
 
     def build_record(ptr, idx, records)
-      records.map do | rr |
-        rr.build(ptr,idx).tap do | r |
+      records.map do |rr|
+        rr.build(ptr, idx).tap do |r|
           idx += r.length
         end
       end.join("")
@@ -136,6 +175,5 @@ module DNSMessage
       raise(StandardError, "No questions in query") if @qdcount < 1
       raise(StandardError, "Empty domain")  if @domain_name.empty?
     end
-
   end
 end

data/lib/dnsmessage/name.rb

@@ -1,39 +1,43 @@
+# frozen_string_literal: true
+
 module DNSMessage
+  # Parsing DNS names directly or using pointers
   module Name
-
-  NAME_POINTER = 0xc0
-  POINTER_MASK = 0x3fff
+    NAME_POINTER = 0xc0
+    POINTER_MASK = 0x3fff
 
     def self.parse(record, ptr)
       # Read name loop
       idx = 0
       name = []
       loop do
-        length = record[idx].unpack("c").first
+        length = record[idx].unpack1("c")
         idx += 1
-        if length & NAME_POINTER == NAME_POINTER
-          pointer = ((length << 8) | record[idx].unpack("c").first) & POINTER_MASK
-          return [ptr.find(pointer),idx+1,false]
-        elsif length == 0
-          break
-        else
-          name << record[idx...idx+length]
-          idx += length
-        end
+        break if length.zero?
+
+        return parse_from_pointer(ptr, record, length, idx) \
+          if length & NAME_POINTER == NAME_POINTER
+
+        name << record[idx...idx + length]
+        idx += length
       end
       [name.join("."), idx, true]
     end
 
-    def self.build(name,ptr)
+    def self.build(name, ptr)
       if ptr.find(name)
-        [[(ptr.find(name) | NAME_POINTER << 8)].pack("n"),false]
+        [[(ptr.find(name) | NAME_POINTER << 8)].pack("n"), false]
       else
-        [name_bytes = name.split(".").map do | section |
+        [name.split(".").map do |section|
           section.length.chr + section
-        end.join("") + "\x0", # Terminate will nullptr
-        true]
+        end.join("") << "\x0", # Terminate will nullptr
+         true]
       end
     end
 
+    def self.parse_from_pointer(ptr, record, length, idx)
+      [ptr.find(((length << 8) | record[idx].unpack1("c")) & POINTER_MASK),
+       idx + 1, false]
+    end
   end
 end

data/lib/dnsmessage/pointer.rb

@@ -1,24 +1,27 @@
+# frozen_string_literal: true
+
 module DNSMessage
+  # Handle DNS pointers
   class Pointer
-
     def initialize(hash = {})
       @hash = hash
     end
 
     def add_arr(arr, offset)
       return unless arr
-      arr.each do |k,v|
-        k += offset if k.class == Integer
-        v += offset if v.class == Integer
-        add(k,v)
+
+      arr.each do |k, v|
+        k += offset if k.instance_of?(Integer)
+        v += offset if v.instance_of?(Integer)
+        add(k, v)
       end
     end
 
-    def add(key,value)
-      if key.class == Integer
-        add_name(key,value)
+    def add(key, value)
+      if key.instance_of?(Integer)
+        add_name(key, value)
       else
-        add_ptr(key,value)
+        add_ptr(key, value)
       end
     end
 
@@ -32,23 +35,24 @@ module DNSMessage
 
     private
 
-    def add_name(key,value)
+    def add_name(key, value)
       value = value.split(".")
       loop do
         return unless value.length > 1
+
         @hash[key] = value.join(".")
         key += value.shift.length + 1
       end
     end
 
-    def add_ptr(key,value)
+    def add_ptr(key, value)
       key = key.split(".")
       loop do
         return unless key.length > 1
+
         @hash[key.join(".")] = value
         value += key.shift.length + 1
       end
     end
-
   end
 end

data/lib/dnsmessage/question.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module DNSMessage
+  # Parse and build DNS questions
   class Question
-
     attr_accessor :name, :type, :klass
     attr_reader :size, :add_to_hash
 
@@ -11,25 +13,24 @@ module DNSMessage
     end
 
     def self.parse(question, ptr, idx)
-      self.new().tap do | q |
+      new.tap do |q|
         q.parse(question, ptr, idx)
       end
     end
 
     def parse(question, ptr, idx)
-        @name, @size, add = Name.parse(question[idx..-1], ptr)
-        ptr.add(idx, @name) if add
+      @name, @size, add = Name.parse(question[idx..], ptr)
+      ptr.add(idx, @name) if add
 
-        # take last four bytes
-        @type, @klass = question[(idx+@size)..-1].unpack("n2")
-        @size += 4
+      # take last four bytes
+      @type, @klass = question[(idx + @size)..].unpack("n2")
+      @size += 4
     end
 
-    def build(ptr,idx)
-        name_bytes, add = Name.build(@name,ptr)
-        ptr.add(@name, idx) if add
-        name_bytes + [type,klass].pack("n2")
+    def build(ptr, idx)
+      name_bytes, add = Name.build(@name, ptr)
+      ptr.add(@name, idx) if add
+      name_bytes + [type, klass].pack("n2")
     end
-
   end
 end

data/lib/dnsmessage/resource_record.rb

@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
 module DNSMessage
+  # Parse and build Resource Records
   class ResourceRecord
-
     PARSERS = {
       Type::A     => :parse_ip,
       Type::AAAA  => :parse_ip,
       Type::CNAME => :parse_name,
       Type::OPT   => :parse_opt,
       Type::TXT   => :parse_text
-    }
+    }.freeze
 
     BUILDERS = {
       Type::A     => :build_ip,
@@ -15,10 +17,10 @@ module DNSMessage
       Type::CNAME => :build_name,
       Type::OPT   => :build_opt,
       Type::TXT   => :build_text
-    }
+    }.freeze
 
     attr_accessor :name, :type, :klass, :ttl, :rdata,
-      :opt_udp, :opt_rcode, :opt_edns0_version, :opt_z_dnssec
+                  :opt_udp, :opt_rcode, :opt_edns0_version, :opt_z_dnssec
     attr_reader :size, :add_to_hash
 
     def initialize(name: nil, type: nil, klass: Class::IN, ttl: 0,
@@ -31,36 +33,32 @@ module DNSMessage
       @add_to_hash = []
     end
 
-    def add_to_hash
-      @add_to_hash
-    end
-
     def self.parse(record, ptr)
-      self.new().tap do |rr|
+      new.tap do |rr|
         rr.parse(record, ptr)
       end
     end
 
     def parse(record, ptr)
-      @name, idx, add = Name.parse(record,ptr)
+      @name, idx, add = Name.parse(record, ptr)
       @add_to_hash << [idx, @name] if add
-      @type, @klass, @ttl, rdata_length = record[idx...idx+10].unpack("nnNn")
-      @rdata = send(parser(@type), record, idx+10, rdata_length, ptr)
+      @type, @klass, @ttl, rdata_length = record[idx...idx + 10].unpack("nnNn")
+      @rdata = send(parser(@type), record, idx + 10, rdata_length, ptr)
       @size = idx + 10 + rdata_length
     end
 
-    def build(ptr,idx)
+    def build(ptr, idx)
       return "" unless BUILDERS[type]
 
       name_bytes, add = Name.build(@name, ptr)
       ptr.add(@name, idx) if add
-      data = send(builder(@type),ptr, idx + name_bytes.length)
+      data = send(builder(@type), ptr, idx + name_bytes.length)
       @rdata_length = data.length
       name_bytes + [@type, @klass, @ttl, @rdata_length].pack("nnNn") + data
     end
 
     def self.default_opt(size)
-      self.new().tap do | opt |
+      new.tap do |opt|
         opt.name = ""
         opt.type = Type::OPT
         opt.opt_udp = size
@@ -84,25 +82,25 @@ module DNSMessage
     ## Parsers
     ##
 
-    def parse_ip(rdata, start, length, ptr)
-      IPAddr.new_ntoh(rdata[start...start+length])
+    def parse_ip(rdata, start, length, _ptr)
+      IPAddr.new_ntoh(rdata[start...start + length])
     end
 
-    def parse_opt(rdata, start, length, ptr)
-      @opt_udp           = @klass
+    def parse_opt(_rdata, _start, _length, _ptr)
+      @opt_udp = @klass
       @opt_rcode, @opt_edns0_version, @opt_z_dnssec =
         [@ttl].pack("N").unpack("CCn")
       @opt_z_dnssec = @opt_z_dnssec >> 15
     end
 
-    def parse_text(rdata, start, length, ptr)
+    def parse_text(rdata, start, _length, _ptr)
       txt_length = rdata[start].ord
-      rdata[start+1..start+txt_length]
+      rdata[start + 1..start + txt_length]
     end
 
     def parse_name(rdata, start, length, ptr)
       name, idx, add = Name.parse(rdata[0...length], ptr)
-      @add_to_hash << [start+idx, name] if add
+      @add_to_hash << [start + idx, name] if add
       name
     end
 
@@ -110,29 +108,28 @@ module DNSMessage
     ## Builders
     ##
 
-    def build_ip(ptr, _)
+    def build_ip(_ptr, _)
       @rdata.hton
     end
 
-    def build_opt(ptr, _)
+    def build_opt(_ptr, _)
       @klass = @opt_udp
       @ttl = [@opt_rcode,
               @opt_edns0_version,
-              @opt_z_dnssec << 15].pack("CCn").unpack("N").first
+              @opt_z_dnssec << 15].pack("CCn").unpack1("N")
       "" # Set RDATA to nothing
     end
 
-    def build_text(ptr, _)
+    def build_text(_ptr, _)
       @rdata.length.chr + rdata
     end
 
     def build_name(ptr, idx)
-      Name.build(@rdata, ptr).tap do | bytes, add |
-        ptr.add(@rdata,idx) if add
+      Name.build(@rdata, ptr).tap do |bytes, add|
+        ptr.add(@rdata, idx) if add
         return bytes
       end
     end
-
   end
 
   # Add "alias"

data/lib/dnsmessage/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DNSMessage
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dnsmessage
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Claus Lensbøl
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-02-15 00:00:00.000000000 Z
+date: 2021-02-23 00:00:00.000000000 Z
 dependencies: []
 description: |-
   A full featured DNS parser. The library supports DNS
@@ -23,6 +23,7 @@ files:
 - ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".rspec"
+- ".rubocop.yml"
 - ".travis.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
@@ -49,7 +50,7 @@ metadata:
   homepage_uri: https://github.com/cmol/dnsmessage
   source_code_uri: https://github.com/cmol/dnsmessage
   changelog_uri: https://github.com/cmol/dnsmessage
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -57,16 +58,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
-signing_key: 
+rubygems_version: 3.2.3
+signing_key:
 specification_version: 4
 summary: Ruby library to build and parse DNS messages
 test_files: []