net-dns 0.6.1 → 0.7.0

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

@@ -1,87 +1,103 @@
-require 'ipaddr'
-
-
-module Net 
-  module DNS 
-    
-    class RR 
+module Net
+  module DNS
+    class RR
 
       #
-      # RR type AAAA
+      # = IPv6 Address Record (AAAA)
+      #
+      # Class for DNS IPv6 Address (AAAA) resource records.
       #
       class AAAA < RR
-        attr_reader :address
 
-        # Assign to the RR::AAAA object a new IPv6 address, which can be in the
-        # form of a string or an IPAddr object
+        # Gets the current IPv6 address for this record.
+        #
+        # Returns an instance of IPAddr.
+        def address
+          @address
+        end
+
+        # 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.
         #
-        #   a.address = "::1"
-        #   a.address = IPAddr.new("::1")
+        # Examples
         #
-        def address=(addr)
-          @address = check_address addr
+        #   a.address = "192.168.0.1"
+        #   a.address = IPAddr.new("10.0.0.1")
+        #
+        # Returns the new allocated instance of IPAddr.
+        def address=(string_or_ipaddr)
+          @address = check_address(string_or_ipaddr)
           build_pack
-        end # address=
-        
-        private
-        
-        def check_address(addr)
-          address = ""
-          case addr
-          when String 
-            address = IPAddr.new addr
-          when IPAddr
-            address = addr
-          else
-            raise ArgumentError, "Unknown address type: #{addr.inspect}"
-          end
-          raise ArgumentError, "Must specify an IPv6 address" unless address.ipv6?
-          address
-        rescue ArgumentError
-          raise ArgumentError, "Invalid address #{addr.inspect}"
-        end
-          
-        def build_pack
-          @address_pack = @address.hton
-          @rdlength = @address_pack.size
-        end
-        
-        def get_data
-          @address_pack
+          @address
         end
 
-        def get_inspect
-          "#@address"
-        end
-        
-        def subclass_new_from_hash(args)
-          if args.has_key? :address 
-            @address = check_address args[:address]
-          else
-            raise ArgumentError, ":address field is mandatory but missing"
-          end
-        end
-        
-        def subclass_new_from_string(str)
-          @address = check_address(str)
-        end
-        
-        def subclass_new_from_binary(data,offset)
-          arr = data.unpack("@#{offset} n8")
-          @address = IPAddr.new sprintf("%x:%x:%x:%x:%x:%x:%x:%x",*arr)
-          return offset + 16
+        # Gets the standardized value for this record,
+        # represented by the value of <tt>address</tt>.
+        #
+        # Returns a String.
+        def value
+          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 set_type
             @type = Net::DNS::RR::Types.new("AAAA")
           end
-        
+
+          def get_inspect
+            value
+          end
+
+
+          def check_address(input)
+            address = case input
+              when IPAddr
+                input
+              when String
+                IPAddr.new(input)
+              else
+                raise ArgumentError, "Invalid IP address `#{input}'"
+            end
+
+            if !address.ipv6?
+              raise(ArgumentError, "Must specify an IPv6 address")
+            end
+
+            address
+          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,148 +1,133 @@
-module Net # :nodoc:
-  module DNS 
-    
+module Net
+  module DNS
+
     class RR
-      
+
       #
-      # This is an auxiliary class to hadle RR class field in a DNS packet. 
+      # = Net::DNS::Classes
+      #
+      # This is an auxiliary class to handle <tt>Net::DNS::RR</tt>
+      # class field in a DNS packet.
       #
       class Classes
-        
-        # An hash with the values of each RR class stored with the 
-        # respective id number
-        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
         }
-        
-        # The default value when class is nil in Resource Records
-        @@default = Classes["IN"]
 
-        # Be able to control the default class to assign when
-        # cls argument is +nil+. Default to +IN+
-        def self.default=(str)
-          if Classes.has_key? str
-            @@default = Classes[str]
-          else
-            raise ClassArgumentError, "Unknown class #{str}"
-          end
-        end
-
-        # Checks whether +cls+ is a valid RR class.  
-        def self.valid?(cls)
-          case cls
-          when String
-            return Classes.has_key?(cls)
-          when Fixnum
-            return Classes.invert.has_key?(cls)
-          else
-            raise ClassArgumentError, "Wrong cls class: #{cls.class}"
-          end
-        end
-        
-        # Returns the class in string format, as "IN" or "CH",
-        # given the numeric value
-        def self.to_str(cls)
-          case cls
-          when Fixnum
-            if Classes.invert.has_key? cls
-              return Classes.invert[cls]
-            else
-              raise ClassArgumentError, "Unknown class number #{cls}"
-            end
-          else
-            raise ClassArgumentError, "Wrong cls class: #{cls.class}"
-          end
-        end
+        # The default value when class is nil in Resource Records
+        @@default = CLASSES["IN"]
 
-        # Gives in output the keys from the +Classes+ hash
-        # in a format suited for regexps
-        def self.regexp
-          Classes.keys.sort.join("|")
-        end
 
         # 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
-            # type in the form "A" or "NS"
-            new_from_string(cls.upcase) 
-          when Fixnum
-            # type in numeric form
-            new_from_num(cls) 
-          when nil
-            # default type, control with Classes.default=
-            @str = Classes.invert[@@default] 
-            @num = @@default
-          else
-            raise ClassArgumentError, "Wrong cls class: #{cls.class}"
+            when String
+              initialize_from_str(cls)
+            when Fixnum
+              initialize_from_num(cls)
+            when nil
+              initialize_from_num(@@default)
           end
-        end
 
-        # Constructor for string data class,
-        # *PRIVATE* method
-        def new_from_string(cls)
-          case cls
-          when /^CLASS\\d+/
-            # TODO!!!
-          else 
-            # String with name of class
-            if Classes.has_key? cls
-              @str = cls
-              @num = Classes[cls]
-            else
-              raise ClassesArgumentError, "Unknown cls #{cls}"
-            end
+          if @str.nil? || @num.nil?
+            raise ArgumentError, "Unable to create a `Classes' from `#{cls}'"
           end
         end
 
-        # Contructor for numeric data class
-        # *PRIVATE* method
-        def new_from_num(cls)
-          if Classes.invert.has_key? cls
-            @num = cls
-            @str = Classes.invert[cls]
-          else
-            raise ClassesArgumentError, "Unkown cls number #{cls}"
-          end
-        end
-        
-        # Returns the class in number format 
+        # Returns the class in number format
         # (default for normal use)
+        #
+        # FIXME: inspect must return a String.
+        #
         def inspect
           @num
         end
 
         # Returns the class in string format,
-        # i.d. "IN" or "CH" or such a string.
+        # ex. "IN" or "CH" or such a string.
         def to_s
-          @str
+          @str.to_s
         end
-        
+
         # Returns the class in numeric format,
-        # usable by the pack methods for data transfers
+        # usable by the pack methods for data transfers.
         def to_i
           @num.to_i
         end
 
 
-        # Should be used only for testing purpouses
-        def to_str
-          @num.to_s
+
+        # 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
+        end
+
+        # Returns whether <tt>cls</tt> is a valid RR class.
+        #
+        #   Net::DNS::RR::Classes.valid?("IN")
+        #   # => true
+        #   Net::DNS::RR::Classes.valid?(1)
+        #   # => true
+        #   Net::DNS::RR::Classes.valid?("Q")
+        #   # => false
+        #   Net::DNS::RR::Classes.valid?(256)
+        #   # => false
+        #   Net::DNS::RR::Classes.valid?(Hash.new)
+        #   # => ArgumentError
+        #
+        # FIXME: valid? should never raise.
+        #
+        # ==== Raises
+        # ArgumentError:: if <tt>cls</tt> isn't either a String or a Fixnum
+        #
+        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}"
+          end
+        end
+
+        # Gives in output the keys from the +Classes+ hash
+        # in a format suited for regexps
+        def self.regexp
+          CLASSES.keys.sort.join("|")
+        end
+
+
+      private
+
+        # Initialize a new instance from a Class name.
+        def initialize_from_str(str)
+          key = str.to_s.upcase
+          @num, @str = CLASSES[key], key
         end
 
-        private :new_from_num, :new_from_string
+        # Initialize a new instance from the Class value.
+        def initialize_from_num(num)
+          key = num.to_i
+          @num, @str = key, CLASSES.invert[key]
+        end
 
-      end # class Classes
-    
-    end # class RR
-  end # module DNS
-end # module Net
+      end
 
-class ClassArgumentError < ArgumentError # :nodoc:
+    end
+  end
 end

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

@@ -1,63 +1,82 @@
-module Net
+module Net # :nodoc:
   module DNS
-
     class RR
-      
-      #------------------------------------------------------------
-      # RR type CNAME
-      #------------------------------------------------------------
+
+      #
+      # = Canonical Name Record (CNAME)
+      #
+      # Class for DNS CNAME resource records.
+      #
+      # A CNAME record maps an alias or nickname to the real or Canonical name
+      # which may lie outside the current zone.
+      # Canonical means expected or real name.
+      #
       class CNAME < RR
-        attr_reader :cname
 
-        private
-        
-        def check_name(name)
-          unless name =~ /(\w\.?)+\s*$/ and name =~ /[a-zA-Z]/
-            raise ArgumentError, "Canonical Name not valid: #{name}"
-          end
-          name
+        # Gets the canonical name value.
+        #
+        # Returns a String.
+        def cname
+          @cname
         end
 
-        def build_pack
-          @cname_pack = pack_name(@cname)
-          @rdlength = @cname_pack.size
+        # Gets the standardized value for this record,
+        # represented by the value of <tt>cname</tt>.
+        #
+        # Returns a String.
+        def value
+          cname.to_s
         end
 
-        def get_data
-          @cname_pack
-        end
 
-        def get_inspect
-          "#@cname"
-        end
+        private
 
-        def subclass_new_from_hash(args)
-          if args.has_key? :cname
-            @cname = check_name args[:cname]
-          else
-            raise ArgumentError, ":cname field is mandatory but missing"
+          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_string(str)
+            @cname = check_name(str)
+          end
+
+          def subclass_new_from_binary(data, offset)
+            @cname, offset = dn_expand(data, offset)
+            offset
           end
-        end
 
-        def subclass_new_from_string(str)
-          @cname = check_name(str)
-        end
 
-        def subclass_new_from_binary(data,offset)
-          @cname,offset = dn_expand(data,offset)
-          return offset
-        end
-        
-        private
-        
           def set_type
             @type = Net::DNS::RR::Types.new("CNAME")
           end
-        
-      end # class CNAME
-       
-    end # class RR
-  end # module DNS
-end # module Net
 
+          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
+          end
+
+          def build_pack
+            @cname_pack = pack_name(@cname)
+            @rdlength = @cname_pack.size
+          end
+
+          def get_data
+            @cname_pack
+          end
+
+      end
 
+    end
+  end
+end