net-dns 0.8.0 → 0.20.0

data/lib/net/dns/rr/a.rb

@@ -1,7 +1,6 @@
 module Net
   module DNS
     class RR
-
       #
       # = IPv4 Address Record (A)
       #
@@ -23,13 +22,10 @@ module Net
       # without any embedded space (e.g. "10.2.0.52" or "192.0.5.6").
       #
       class A < RR
-
         # Gets the current IPv4 address for this record.
         #
         # Returns an instance of IPAddr.
-        def address
-          @address
-        end
+        attr_reader :address
 
         # Assigns a new IPv4 address to this record, which can be in the
         # form of a <tt>String</tt> or an <tt>IPAddr</tt> object.
@@ -54,71 +50,65 @@ module Net
           address.to_s
         end
 
-
         private
 
-          def subclass_new_from_hash(options)
-            if options.has_key?(:address)
-              @address = check_address(options[:address])
-            elsif options.has_key?(:rdata)
-              @address = check_address(options[:rdata])
-            else
-              raise ArgumentError, ":address or :rdata field is mandatory"
-            end
+        def subclass_new_from_hash(options)
+          if options.key?(:address)
+            @address = check_address(options[:address])
+          elsif options.key?(:rdata)
+            @address = check_address(options[:rdata])
+          else
+            raise ArgumentError, ":address or :rdata field is mandatory"
           end
+        end
 
-          def subclass_new_from_string(str)
-            @address = check_address(str)
-          end
+        def subclass_new_from_string(str)
+          @address = check_address(str)
+        end
 
-          def subclass_new_from_binary(data, offset)
-            a, b, c, d = data.unpack("@#{offset} CCCC")
-            @address = IPAddr.new("#{a}.#{b}.#{c}.#{d}")
-            offset + 4
-          end
+        def subclass_new_from_binary(data, offset)
+          a, b, c, d = data.unpack("@#{offset} CCCC")
+          @address = IPAddr.new("#{a}.#{b}.#{c}.#{d}")
+          offset + 4
+        end
 
+        def set_type
+          @type = Net::DNS::RR::Types.new("A")
+        end
 
-          def set_type
-            @type = Net::DNS::RR::Types.new("A")
-          end
+        def get_inspect
+          value
+        end
 
-          def get_inspect
-            value
+        def check_address(input)
+          address = case input
+          when IPAddr
+            input
+          # Address in numeric form
+          when Integer
+            IPAddr.new(input, Socket::AF_INET)
+          when String
+            IPAddr.new(input)
+          else
+            raise ArgumentError, "Invalid IP address `#{input}'"
           end
 
-
-          def check_address(input)
-            address = case input
-              when IPAddr
-                input
-              when Integer # Address in numeric form
-                tmp = [(input >> 24), (input >> 16) & 0xFF, (input >> 8) & 0xFF, input & 0xFF]
-                tmp = tmp.collect { |x| x.to_s }.join(".")
-                IPAddr.new(tmp)
-              when String
-                IPAddr.new(input)
-              else
-                raise ArgumentError, "Invalid IP address `#{input}'"
-            end
-
-            if !address.ipv4?
-              raise(ArgumentError, "Must specify an IPv4 address")
-            end
-
-            address
+          unless address.ipv4?
+            raise(ArgumentError, "Must specify an IPv4 address")
           end
 
-          def build_pack
-            @address_pack = @address.hton
-            @rdlength = @address_pack.size
-          end
+          address
+        end
 
-          def get_data
-            @address_pack
-          end
+        def build_pack
+          @address_pack = @address.hton
+          @rdlength = @address_pack.size
+        end
 
+        def get_data
+          @address_pack
+        end
       end
-
     end
   end
 end

data/lib/net/dns/rr/aaaa.rb

@@ -1,20 +1,16 @@
 module Net
   module DNS
     class RR
-
       #
       # = IPv6 Address Record (AAAA)
       #
       # Class for DNS IPv6 Address (AAAA) resource records.
       #
       class AAAA < RR
-
         # Gets the current IPv6 address for this record.
         #
         # Returns an instance of IPAddr.
-        def address
-          @address
-        end
+        attr_reader :address
 
         # Assigns a new IPv6 address to this record, which can be in the
         # form of a <tt>String</tt> or an <tt>IPAddr</tt> object.
@@ -39,65 +35,58 @@ module Net
           address.to_s
         end
 
-
         private
 
-          def subclass_new_from_hash(options)
-            if options.has_key?(:address)
-              @address = check_address(options[:address])
-            else
-              raise ArgumentError, ":address field is mandatory"
-            end
-          end
-
-          def subclass_new_from_string(str)
-            @address = check_address(str)
-          end
-
-          def subclass_new_from_binary(data, offset)
-            tokens = data.unpack("@#{offset} n8")
-            @address = IPAddr.new(sprintf("%x:%x:%x:%x:%x:%x:%x:%x", *tokens))
-            offset + 16
-          end
-
+        def subclass_new_from_hash(options)
+          raise ArgumentError, ":address field is mandatory" unless options.key?(:address)
 
-          def set_type
-            @type = Net::DNS::RR::Types.new("AAAA")
-          end
+          @address = check_address(options[:address])
+        end
 
-          def get_inspect
-            value
-          end
+        def subclass_new_from_string(str)
+          @address = check_address(str)
+        end
 
+        def subclass_new_from_binary(data, offset)
+          tokens = data.unpack("@#{offset} n8")
+          @address = IPAddr.new(format("%x:%x:%x:%x:%x:%x:%x:%x", *tokens))
+          offset + 16
+        end
 
-          def check_address(input)
-            address = case input
-              when IPAddr
-                input
-              when String
-                IPAddr.new(input)
-              else
-                raise ArgumentError, "Invalid IP address `#{input}'"
-            end
+        def set_type
+          @type = Net::DNS::RR::Types.new("AAAA")
+        end
 
-            if !address.ipv6?
-              raise(ArgumentError, "Must specify an IPv6 address")
-            end
+        def get_inspect
+          value
+        end
 
-            address
+        def check_address(input)
+          address = case input
+          when IPAddr
+            input
+          when String
+            IPAddr.new(input)
+          else
+            raise ArgumentError, "Invalid IP address `#{input}'"
           end
 
-          def build_pack
-            @address_pack = @address.hton
-            @rdlength = @address_pack.size
+          unless address.ipv6?
+            raise(ArgumentError, "Must specify an IPv6 address")
           end
 
-          def get_data
-            @address_pack
-          end
+          address
+        end
 
-      end
+        def build_pack
+          @address_pack = @address.hton
+          @rdlength = @address_pack.size
+        end
 
+        def get_data
+          @address_pack
+        end
+      end
     end
   end
 end

data/lib/net/dns/rr/classes.rb

@@ -1,8 +1,6 @@
 module Net
   module DNS
-
     class RR
-
       #
       # = Net::DNS::Classes
       #
@@ -10,37 +8,35 @@ module Net
       # class field in a DNS packet.
       #
       class Classes
-
         # Hash with the values of each RR class stored with the
         # respective id number.
         CLASSES = {
-          'IN'        => 1,       # RFC 1035
-          'CH'        => 3,       # RFC 1035
-          'HS'        => 4,       # RFC 1035
-          'NONE'      => 254,     # RFC 2136
-          'ANY'       => 255,     # RFC 1035
-        }
+          'IN' => 1, # RFC 1035
+          'CH' => 3,       # RFC 1035
+          'HS' => 4,       # RFC 1035
+          'NONE' => 254, # RFC 2136
+          'ANY' => 255, # RFC 1035
+        }.freeze
 
         # The default value when class is nil in Resource Records
         @@default = CLASSES["IN"]
 
-
         # Creates a new object representing an RR class. Performs some
         # checks on the argument validity too. Il +cls+ is +nil+, the
         # default value is +ANY+ or the one set with Classes.default=
         def initialize(cls)
           case cls
-            when String
-              initialize_from_str(cls)
-            when Fixnum
-              initialize_from_num(cls)
-            when nil
-              initialize_from_num(@@default)
+          when String
+            initialize_from_str(cls)
+          when Integer
+            initialize_from_num(cls)
+          when nil
+            initialize_from_num(@@default)
           end
 
-          if @str.nil? || @num.nil?
-            raise ArgumentError, "Unable to create a `Classes' from `#{cls}'"
-          end
+          return unless @str.nil? || @num.nil?
+
+          raise ArgumentError, "Unable to create a `Classes' from `#{cls}'"
         end
 
         # Returns the class in number format
@@ -64,16 +60,16 @@ module Net
           @num.to_i
         end
 
-
+        def self.default
+          @@default
+        end
 
         # Be able to control the default class to assign when
         # cls argument is +nil+. Default to +IN+
         def self.default=(str)
-          if CLASSES[str]
-            @@default = CLASSES[str]
-          else
-            raise ArgumentError, "Unknown class `#{str}'"
-          end
+          raise ArgumentError, "Unknown class `#{str}'" unless CLASSES[str]
+
+          @@default = CLASSES[str]
         end
 
         # Returns whether <tt>cls</tt> is a valid RR class.
@@ -96,12 +92,12 @@ module Net
         #
         def self.valid?(cls)
           case cls
-            when String
-              CLASSES.has_key?(cls)
-            when Fixnum
-              CLASSES.invert.has_key?(cls)
-            else
-              raise ArgumentError, "Wrong cls class: #{cls.class}"
+          when String
+            CLASSES.key?(cls)
+          when Integer
+            CLASSES.invert.key?(cls)
+          else
+            raise ArgumentError, "Wrong cls class: #{cls.class}"
           end
         end
 
@@ -111,23 +107,22 @@ module Net
           CLASSES.keys.sort.join("|")
         end
 
-
-      private
+        private
 
         # Initialize a new instance from a Class name.
         def initialize_from_str(str)
           key = str.to_s.upcase
-          @num, @str = CLASSES[key], key
+          @num = CLASSES[key]
+          @str = key
         end
 
         # Initialize a new instance from the Class value.
         def initialize_from_num(num)
           key = num.to_i
-          @num, @str = key, CLASSES.invert[key]
+          @num = key
+          @str = CLASSES.invert[key]
         end
-
       end
-
     end
   end
 end

data/lib/net/dns/rr/cname.rb

@@ -1,7 +1,6 @@
 module Net # :nodoc:
   module DNS
     class RR
-
       #
       # = Canonical Name Record (CNAME)
       #
@@ -12,13 +11,10 @@ module Net # :nodoc:
       # Canonical means expected or real name.
       #
       class CNAME < RR
-
         # Gets the canonical name value.
         #
         # Returns a String.
-        def cname
-          @cname
-        end
+        attr_reader :cname
 
         # Gets the standardized value for this record,
         # represented by the value of <tt>cname</tt>.
@@ -28,55 +24,49 @@ module Net # :nodoc:
           cname.to_s
         end
 
-
         private
 
-          def subclass_new_from_hash(options)
-            if options.has_key?(:cname)
-              @cname = check_name(options[:cname])
-            else
-              raise ArgumentError, ":cname field is mandatory"
-            end
-          end
+        def subclass_new_from_hash(options)
+          raise ArgumentError, ":cname field is mandatory" unless options.key?(:cname)
 
-          def subclass_new_from_string(str)
-            @cname = check_name(str)
-          end
-
-          def subclass_new_from_binary(data, offset)
-            @cname, offset = dn_expand(data, offset)
-            offset
-          end
+          @cname = check_name(options[:cname])
+        end
 
+        def subclass_new_from_string(str)
+          @cname = check_name(str)
+        end
 
-          def set_type
-            @type = Net::DNS::RR::Types.new("CNAME")
-          end
+        def subclass_new_from_binary(data, offset)
+          @cname, offset = dn_expand(data, offset)
+          offset
+        end
 
-          def get_inspect
-            value
-          end
+        def set_type
+          @type = Net::DNS::RR::Types.new("CNAME")
+        end
 
+        def get_inspect
+          value
+        end
 
-          def check_name(input)
-            name = input.to_s
-            unless name =~ /(\w\.?)+\s*$/ and name =~ /[a-zA-Z]/
-              raise ArgumentError, "Invalid Canonical Name `#{name}'"
-            end
-            name
+        def check_name(input)
+          name = input.to_s
+          unless name =~ /(\w\.?)+\s*$/ && name =~ /[a-zA-Z]/
+            raise ArgumentError, "Invalid Canonical Name `#{name}'"
           end
 
-          def build_pack
-            @cname_pack = pack_name(@cname)
-            @rdlength = @cname_pack.size
-          end
+          name
+        end
 
-          def get_data
-            @cname_pack
-          end
+        def build_pack
+          @cname_pack = pack_name(@cname)
+          @rdlength = @cname_pack.size
+        end
 
+        def get_data
+          @cname_pack
+        end
       end
-
     end
   end
 end

data/lib/net/dns/rr/hinfo.rb

@@ -1,7 +1,6 @@
 module Net # :nodoc:
   module DNS
     class RR
-
       #
       # = System Information Record (HINFO)
       #
@@ -13,30 +12,24 @@ module Net # :nodoc:
       # Single space between CPU and OS parameters.
       #
       class HINFO < RR
-
         # Gets the CPU value.
         #
         # Returns a String.
-        def cpu
-          @cpu
-        end
+        attr_reader :cpu
 
         # Gets the OS value.
         #
         # Returns a String.
-        def os
-          @os
-        end
+        attr_reader :os
 
         # Gets the standardized value for this record,
         # represented by the value of <tt>cpu</tt> and <tt>os</tt>.
         #
         # Returns a String.
         def value
-          %Q{"#{cpu}" "#{os}"}
+          %Q("#{cpu}" "#{os}")
         end
 
-
         # Gets a list of all the attributes for this record.
         #
         # Returns an Array of values.
@@ -44,65 +37,56 @@ module Net # :nodoc:
           [nil, nil, cls.to_s, type.to_s, value]
         end
 
-
         private
 
-          def subclass_new_from_hash(options)
-            if options.has_key?(:cpu) && options.has_key?(:os)
-              @cpu = options[:cpu]
-              @os  = options[:os]
-            else
-              raise ArgumentError, ":cpu and :os fields are mandatory"
-            end
-          end
+        def subclass_new_from_hash(options)
+          raise ArgumentError, ":cpu and :os fields are mandatory" unless options.key?(:cpu) && options.key?(:os)
 
-          def subclass_new_from_string(str)
-            @cpu, @os = check_hinfo(str)
-          end
+          @cpu = options[:cpu]
+          @os  = options[:os]
+        end
 
-          def subclass_new_from_binary(data, offset)
-            len  = data.unpack("@#{offset} C").first
-            offset += 1
-            @cpu = data[offset..(offset + len)]
-            offset += len
-            
-            len  = data.unpack("@#{offset} C").first
-            offset += 1
-            @os  = data[offset..(offset + len)]
-            offset += len
-          end
+        def subclass_new_from_string(str)
+          @cpu, @os = check_hinfo(str)
+        end
 
+        def subclass_new_from_binary(data, offset)
+          len = data.unpack1("@#{offset} C")
+          offset += 1
+          @cpu = data[offset..(offset + len)]
+          offset += len
 
-          def set_type
-            @type = Net::DNS::RR::Types.new("HINFO")
-          end
+          len = data.unpack1("@#{offset} C")
+          offset += 1
+          @os = data[offset..(offset + len)]
+          offset += len
+        end
 
-          def get_inspect
-            value
-          end
+        def set_type
+          @type = Net::DNS::RR::Types.new("HINFO")
+        end
 
+        def get_inspect
+          value
+        end
 
-          def check_hinfo(input)
-            if input.to_s.strip =~ /^(?:["']?(.*?)["']?)\s+(?:["']?(.*?)["']?)$/
-              [$1, $2]
-            else
-              raise ArgumentError, "Invalid HINFO Section `#{input}'"
-            end
-          end
+        def check_hinfo(input)
+          raise ArgumentError, "Invalid HINFO Section `#{input}'" unless input.to_s.strip =~ /^(?:["']?(.*?)["']?)\s+(?:["']?(.*?)["']?)$/
 
-          def build_pack
-            @hinfo_pack  = ""
-            @hinfo_pack += [cpu.size].pack("C") + cpu
-            @hinfo_pack += [os.size ].pack("C") + os
-            @rdlength = @hinfo_pack.size
-          end
+          [Regexp.last_match(1), Regexp.last_match(2)]
+        end
 
-          def get_data
-            @hinfo_pack
-          end
+        def build_pack
+          @hinfo_pack  = ""
+          @hinfo_pack += [cpu.size].pack("C") + cpu
+          @hinfo_pack += [os.size].pack("C") + os
+          @rdlength = @hinfo_pack.size
+        end
 
+        def get_data
+          @hinfo_pack
+        end
       end
-
     end
   end
 end