ipaddress 0.6.0 → 0.7.0

data/CHANGELOG.rdoc

@@ -1,3 +1,10 @@
+== master
+
+NEW:: IPAddress::IPv6#include?
+NEW:: IPAddress::IPv6#network_u128
+NEW:: Modified IPAddress::IPv6::Mapped to accept IPv4 mapped addresses in IPv6 format
+NEW:: IPAddress::IPv4#private?
+NEW:: IPAddress::IPv4::parse_classful
 
 == ipaddress 0.6.0
 

data/README.rdoc

@@ -43,8 +43,12 @@ Some quick examples of things you can't do with IPAddr:
 * iterate over hosts 
 * perform subnetting or network aggregation
 
-Moreover, many methods and procedures are so old that they have been 
-declared deprecated by the IETF.
+Many methods and procedures are so old that they have been 
+declared deprecated by the IETF, and some others have bugs in their 
+implementation.  
+
+Moreover, IPAddress is more robust and is already around 50% faster than IPAddr,
+in addition to provide an organic API with logical separation and OO structure.
 
 We hope that IPAddress will address all these issues and meet all your
 needs in network programming.
@@ -77,20 +81,15 @@ documentation with Rake:
   ipaddress$ rake rdoc
 
 The latest documentation can be found online at 
-{this address}[http://marcoceresa.com/ipaddress]
-
-== Usage
-
-In this section I will illustrate how to use the IPAddress library
-through some examples of common tasks.
-
-=== IPv4
+{this address}[http://rubydoc.info/github/bluemonk/ipaddress/master/frames]
+ 
+== IPv4
 
 Class IPAddress::IPv4 is used to handle IPv4 type addresses. IPAddress
 is similar to other IP Addresses libraries, like Ruby's own
 IPAddr. However it works slightly different, as we will see.
 
-==== Create a new IPv4 address
+=== Create a new IPv4 address
 
 The usual way to express an IP Address is using its dotted decimal
 form, such as 172.16.10.1, and a prefix, such as 24, separated by a
@@ -102,7 +101,15 @@ To create a new IPv4 object, you can use IPv4 own class
 
   ip = IPAddress::IPv4.new "172.16.10.1/24"
 
-or, in a easier way, using the IPAddress wrapper method
+or, in a easier way, using the IPAddress parse method
+
+  ip = IPAddress.parse "172.16.10.1/24"
+
+which accepts and parses any kind of IP (IPv4, IPV6 and 
+IPv4 IPv6 Mapped addresses).
+
+If you like sintactic sugar, you can use the wrapper method
+IPAddress(), which is built around IPAddress::parse:
 
   ip = IPAddress "172.16.10.1/24"
 
@@ -114,40 +121,20 @@ You can specify an IPv4 address in any of two ways:
 In this example, prefix /24 and netmask 255.255.255.0 are the same and
 you have the flexibility to use either one of them.
 
-==== Classful networks
-
-If you don't specify a prefix (or a subnet mask), then the library
-will create an object base on the CLASSFUL network from the given
-IP. Remember the CLASSFUL network are the following (RFC 791)
-
-* Class A, from 0.0.0.0 to 127.255.255.255
-* Class B, from 128.0.0.0 to 191.255.255.255
-* Class C, from 192.0.0.0 to 255.255.255.255
-
-Since classful networks here are only considered to calculate the default
-prefix number, classes D and E are not considered. 
-
-You can easily check which CLASSFUL network the IP belongs:
+If you don't explicitly specify the prefix (or the subnet mask), 
+IPAddress thinks you're dealing with host addresses and not with 
+networks. Therefore, the default prefix will be /32, or
+255.255.255.255. For example:
 
-  ip = IPAddress("10.0.0.1/24")
-  ip.a?
-    #=> true
-  
-  ip = IPAddress("172.16.10.1/24")
-  ip.b?
-    #=> true
+  # let's declare an host address
+  host = IPAddress::IPv4.new "10.1.1.1."
   
-  ip = IPAddress("192.168.1.1/30")
-  ip.c?
-    #=> true
-
-These methods are only checking the address portion of an IP, and are
-indipendent from its prefix.
+The new created object will have prefix /32, which is the same 
+as we created the following:
 
-For more information on CLASSFUL networks visit the 
-{Wikipedia page}[http://en.wikipedia.org/wiki/Classful_network]
-
-==== Handling the IPv4 address
+  host = IPAddress::IPv4.new "10.1.1.1/32"
+  
+=== Handling the IPv4 address
 
 Once created, you can obtain the attributes for an IPv4 object:
 
@@ -182,7 +169,7 @@ use IPv4#to_string
   ip.to_string
     #=> "172.16.10.l/24"
 
-==== Changing netmask
+=== Changing netmask
     
 You can set a new prefix (netmask) after creating an IPv4 
 object. For example:
@@ -200,7 +187,7 @@ using the IPv4#netmask= method
   ip.to_string
     #=> "172.16.10.1/30"
 
-==== Working with networks, broadcasts and addresses
+=== Working with networks, broadcasts and addresses
 
 Some very important topics in dealing with IP addresses are the
 concepts of +network+ and +broadcast+, as well as the addresses
@@ -221,7 +208,7 @@ This is very important because, for instance, IP "172.16.10.1/16" is
 very different to the previous one, belonging to the very different
 network "172.16.0.0/16".
 
-===== Networks
+==== Networks
 
 With IPAddress it's very easy to calculate the network for an IP
 address:
@@ -251,7 +238,7 @@ network or not:
   ip2.network?
     #=> true
 
-===== Broadcast
+==== Broadcast
 
 The broadcast address is the contrary than the network number: where
 the network number has all zeroes in the host portion, the broadcast
@@ -272,7 +259,7 @@ address:
   bcast.to_string
     #=> "172.16.10.255/24"
 
-===== Addresses, ranges and iterators
+==== Addresses, ranges and iterators
 
 So we see that the netmask essentially specifies a range for IP
 addresses that are included in a network: all the addresses between
@@ -310,7 +297,7 @@ respectively the first and the last host address in the range
   ip.last.to_string
     #=> "172.16.10.254/24"
 
-==== IP special formats    
+=== IP special formats    
 
 The IPAddress library provides a complete set of methods to access an
 IPv4 address in special formats, such as binary, 32 bits unsigned int,
@@ -352,6 +339,53 @@ suitable to use in IPv4-IPv6 mapped addresses:
   ip.to_ipv6
     #=> "ac10:0a01"
 
+=== Classful networks
+
+IPAddress allows you to create and manipulate objects using the old 
+and deprecated (but apparently still popular) classful networks concept.
+
+Classful networks and addresses don't have a prefix: their subnet mask
+is univocally identified by their address, and therefore diveded in classes.
+As per RFC 791, these classes are:
+
+* Class A, from 0.0.0.0 to 127.255.255.255
+* Class B, from 128.0.0.0 to 191.255.255.255
+* Class C, from 192.0.0.0 to 255.255.255.255
+
+Since classful networks here are only considered to calculate the default
+prefix number, classes D and E are not considered. 
+
+To create a classful IP and prefix from an IP address, use the 
+IPv4::parse_classful method:
+
+  # classful ip 
+  ip = IPAddress::IPv4::parse_classful "10.1.1.1"
+
+  ip.prefix
+    #=> 8
+
+The method automatically created a new IPv4 object and assigned it
+the correct prefix.
+
+You can easily check which CLASSFUL network an IPv4 object belongs:
+
+  ip = IPAddress("10.0.0.1/24")
+  ip.a?
+    #=> true
+  
+  ip = IPAddress("172.16.10.1/24")
+  ip.b?
+    #=> true
+  
+  ip = IPAddress("192.168.1.1/30")
+  ip.c?
+    #=> true
+
+Remember that these methods are only checking the address portion of an IP, and are
+indipendent from its prefix, as classful networks have no concept of prefix.
+
+For more information on CLASSFUL networks visit the 
+{Wikipedia page}[http://en.wikipedia.org/wiki/Classful_network]
 
 === Network design with IPAddress
 

data/Rakefile

@@ -61,7 +61,7 @@ end
 
 desc "Open an irb session preloaded with this library"
 task :console do
-  sh "irb1.9 -rubygems -I lib -r ipaddress.rb"
+  sh "irb -rubygems -I lib -r ipaddress.rb"
 end
 
 desc "Look for TODO and FIXME tags in the code"

data/VERSION

@@ -1 +1 @@
-0.6.0
+0.7.0

data/lib/ipaddress.rb

@@ -46,11 +46,7 @@ module IPAddress
     when /:.+\./
       IPAddress::IPv6::Mapped.new(str)
     else
-      begin
-        IPAddress::IPv4.new(str)
-      rescue ArgumentError
-        IPAddress::IPv6.new(str)
-      end
+      IPAddress::IPv4.new(str) rescue IPAddress::IPv6.new(str)
     end
   end
 

data/lib/ipaddress/extensions/extensions.rb

@@ -1,14 +1,14 @@
-class << Math
+class << Math # :nodoc:
   def log2(n); log(n) / log(2); end
 end
 
 if RUBY_VERSION =~ /1\.8/
-    class Hash
+    class Hash # :nodoc:
         alias :key :index
     end
 end
 
-class Integer
+class Integer # :nodoc:
   def power_of_2?
     Math::log2(self).to_i == Math::log2(self)
   end

data/lib/ipaddress/ipv4.rb

@@ -42,30 +42,23 @@ module IPAddress;
     #
     # An IPv4 address can be expressed in any of the following forms:
     # 
-    # * "10.1.1.1/24": ip address and prefix. This is the common and
-    #     suggested way to create an object                  .
-    # * "10.1.1.1/255.255.255.0": ip address and netmask. Although
-    #     convenient sometimes, this format is less clear than the previous
-    #     one.             
-    # * "10.1.1.1": if the address alone is specified, the prefix will be 
-    #     assigned using the classful boundaries. In this case, the 
-    #     prefix would be /8, a 255.0.0.0 netmask.
-    # 
-    # It is advisable to use the syntactic shortcut provided with the
-    # IPAddress() method, as in all the examples below.
-    # 
+    # * "10.1.1.1/24": ip +address+ and +prefix+. This is the common and
+    # suggested way to create an object                  .
+    # * "10.1.1.1/255.255.255.0": ip +address+ and +netmask+. Although
+    # convenient sometimes, this format is less clear than the previous
+    # one.             
+    # * "10.1.1.1": if the address alone is specified, the prefix will be
+    # set as default 32, also known as the host prefix    
+    #
     # Examples:
     #
-    #   # These two methods return the same object
+    #   # These two are the same
     #   ip = IPAddress::IPv4.new("10.0.0.1/24")
     #   ip = IPAddress("10.0.0.1/24")
     #   
-    #   # These three are the same
-    #   IPAddress("10.0.0.1/8")
-    #   IPAddress("10.0.0.1/255.0.0.0")
-    #   IPAddress("10.0.0.1")
-    #   #=> #<IPAddress::IPv4:0xb7b1a438 
-    #         @octets=[10, 0, 0, 1], @address="10.0.0.1", @prefix=8>
+    #   # These two are the same
+    #   IPAddress::IPv4.new "10.0.0.1/8"
+    #   IPAddress::IPv4.new "10.0.0.1/255.0.0.0"
     #
     def initialize(str)
       ip, netmask = str.split("/")
@@ -88,12 +81,14 @@ module IPAddress;
           raise ArgumentError, "Invalid netmask #{netmask}"
         end
       else  # netmask is nil, reverting to defaul classful mask
-        @prefix = prefix_from_ip(@address)
+        @prefix = Prefix32.new(32)
       end
 
       # Array formed with the IP octets
       @octets = @address.split(".").map{|i| i.to_i}
-
+      # 32 bits interger containing the address
+      @u32 = (@octets[0]<< 24) + (@octets[1]<< 16) + (@octets[2]<< 8) + (@octets[3])
+      
     end # def initialize
 
     #
@@ -185,7 +180,6 @@ module IPAddress;
       "#@address/#@prefix"
     end
 
-
     # 
     # Returns the prefix as a string in IP format
     #
@@ -227,14 +221,15 @@ module IPAddress;
     #
     #   ip = IPAddress("10.0.0.0/8")
     #
-    #   ip.to_u32
+    #   ip.to_i
     #     #=> 167772160
     #
-    def to_u32
-      data.unpack("N").first
+    def u32
+      @u32
     end
-    alias_method :to_i, :to_u32
-
+    alias_method :to_i, :u32
+    alias_method :to_u32, :u32
+    
     #
     # Returns the address portion of an IPv4 object
     # in a network byte order format.
@@ -255,7 +250,7 @@ module IPAddress;
     #   a.puts binary_data
     #
     def data
-      @octets.pack("C4")
+      [@u32].pack("N")
     end
 
     #
@@ -316,7 +311,7 @@ module IPAddress;
     #     #=> true
     #
     def network?
-      to_u32 | @prefix.to_u32 == @prefix.to_u32
+      @u32 | @prefix.to_u32 == @prefix.to_u32
     end
 
     #
@@ -477,7 +472,7 @@ module IPAddress;
     #     #=> 8
     #
     def size
-      broadcast_u32 - network_u32 + 1
+      2 ** @prefix.host_prefix
     end
 
     #
@@ -507,7 +502,7 @@ module IPAddress;
     #     #=> 167772160
     #
     def network_u32
-      to_u32 & @prefix.to_u32
+      @u32 & @prefix.to_u32
     end
 
     #
@@ -519,7 +514,7 @@ module IPAddress;
     #     #=> 167772167
     #
     def broadcast_u32
-      [to_u32 | ~@prefix.to_u32].pack("N").unpack("N").first
+      network_u32 + size - 1
     end
 
     #
@@ -539,7 +534,23 @@ module IPAddress;
     #     #=> false
     #
     def include?(oth)
-      @prefix <= oth.prefix and network_u32 == self.class.new(oth.address+"/#@prefix").network_u32
+      @prefix <= oth.prefix and network_u32 == (oth.to_u32 & @prefix.to_u32)
+    end
+
+    #
+    # Checks if an IPv4 address objects belongs
+    # to a private network RFC1918
+    #
+    # Example:
+    #
+    #   ip = IPAddress "10.1.1.1/24"
+    #   ip.private?
+    #     #=> true
+    #
+    def private?
+      [self.class.new("10.0.0.0/8"),
+       self.class.new("172.16.0.0/12"),
+       self.class.new("192.168.0.0/16")].any? {|i| i.include? self}
     end
 
     #
@@ -589,7 +600,7 @@ module IPAddress;
     # Returns an array of IPAddress objects
     #
     def subnet(subnets=2)
-      unless (1..(2**(32-prefix.to_i))).include? subnets
+      unless (1..(2**@prefix.host_prefix)).include? subnets
         raise ArgumentError, "Value #{subnets} out of range" 
       end
       calculate_subnets(subnets)
@@ -746,13 +757,8 @@ module IPAddress;
     #   ip.to_string
     #     #=> "10.0.0.0/8"
     #
-    def self.parse_u32(u32, prefix=nil)
-      ip = [u32].pack("N").unpack("C4").join(".")
-      if prefix
-        self.new(ip+"/#{prefix}")
-      else
-        self.new(ip)
-      end
+    def self.parse_u32(u32, prefix=32)
+      self.new([u32].pack("N").unpack("C4").join(".")+"/#{prefix}")
     end
 
     #
@@ -768,12 +774,12 @@ module IPAddress;
     #   ip.to_string
     #     #=> "172.16.10.1/24"
     #
-    def self.parse_data(str)
-      self.new str.unpack("C4").join(".")
+    def self.parse_data(str, prefix=32)
+      self.new(str.unpack("C4").join(".")+"/#{prefix}")
     end
 
     #
-    # Exctract an IPv4 address from a string and 
+    # Extract an IPv4 address from a string and 
     # returns a new object
     #
     # Example:
@@ -872,20 +878,44 @@ module IPAddress;
       end
     end
 
+    #
+    # Creates a new IPv4 address object by parsing the 
+    # address in a classful way.
+    #
+    # Classful addresses have a fixed netmask based on the 
+    # class they belong to:
+    #
+    # * Class A, from 0.0.0.0 to 127.255.255.255
+    # * Class B, from 128.0.0.0 to 191.255.255.255
+    # * Class C, D and E, from 192.0.0.0 to 255.255.255.254
+    #
+    # Note that classes C, D and E will all have a default
+    # prefix of /24 or 255.255.255.0
+    #
+    # Example:
+    #
+    #   ip = IPAddress::IPv4.parse_classful "10.0.0.1"
+    #
+    #   ip.netmask 
+    #     #=> "255.0.0.0"
+    #   ip.a?
+    #     #=> true
+    #
+    def self.parse_classful(ip)
+      if IPAddress.valid_ipv4?(ip)
+        address = ip.strip
+      else
+        raise ArgumentError, "Invalid IP #{ip.inspect}"
+      end
+      prefix = CLASSFUL.find{|h,k| h === ("%.8b" % address.to_i)}.last
+      self.new "#{address}/#{prefix}"
+    end
+
     #
     # private methods
     #
     private
     
-    def bits_from_address(ip)
-      ip.split(".").map{|i| i.to_i}.pack("C4").unpack("B*").first
-    end
-    
-    def prefix_from_ip(ip)
-      bits = bits_from_address(ip)
-      CLASSFUL.each {|reg,prefix| return Prefix32.new(prefix) if bits =~ reg}
-    end
-
     def calculate_subnets(subnets)
       po2 = subnets.closest_power_of_2
       new_prefix = @prefix + Math::log2(po2).to_i

data/lib/ipaddress/ipv6.rb

@@ -88,6 +88,10 @@ module IPAddress;
     #
     def initialize(str)
       ip, netmask = str.split("/")
+
+      if str =~ /:.+\./
+        raise ArgumentError, "Please use #{self.class}::Mapped for IPv4 mapped addresses"
+      end
       
       if IPAddress.valid_ipv6?(ip)
         @groups = self.class.groups(ip)
@@ -101,7 +105,6 @@ module IPAddress;
 
     end # def initialize
 
-
     #
     # Returns the IPv6 address in uncompressed form:
     #
@@ -303,7 +306,7 @@ module IPAddress;
     # Returns the IPv6 address in a DNS reverse lookup
     # string, as per RFC3172 and RFC2874.
     #   
-    #   ip6 = IPAddress "3ffe:505:2::f")
+    #   ip6 = IPAddress "3ffe:505:2::f"
     #   
     #   ip6.reverse
     #     #=> "f.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.2.0.0.0.5.0.5.0.e.f.f.3.ip6.arpa"
@@ -312,7 +315,36 @@ module IPAddress;
       to_hex.reverse.gsub(/./){|c| c+"."} + "ip6.arpa"
     end
     alias_method :arpa, :reverse
-    
+
+    #
+    # Returns the network number in Unsigned 128bits format
+    #
+    #   ip6 = IPAddress "2001:db8::8:800:200c:417a/64"
+    #
+    #   ip6.network_u128
+    #     #=> 42540766411282592856903984951653826560
+    #
+    def network_u128
+      to_u128 & @prefix.to_u128
+    end
+
+    #
+    # Checks whether a subnet includes the given IP address.
+    #
+    # Example:
+    #
+    #   ip6 = IPAddress "2001:db8::8:800:200c:417a/64"
+    #   addr = IPAddress "2001:db8::8:800:200c:1/128"
+    #
+    #   ip6.include? addr
+    #     #=> true
+    #
+    #   ip6.include? IPAddress("2001:db8:1::8:800:200c:417a/76")
+    #     #=> false
+    #
+    def include?(oth)
+      @prefix <= oth.prefix and network_u128 == self.class.new(oth.address+"/#@prefix").network_u128
+    end
 
     #
     # Compressed form of the IPv6 address
@@ -350,7 +382,7 @@ module IPAddress;
     # See IPAddress::IPv6::Mapped for more information
     #
     def mapped?
-      false
+      to_u128 >> 32 == 0xffff
     end
     
     #
@@ -674,13 +706,29 @@ module IPAddress;
     attr_reader :ipv4
 
     #
-    # Creates a new IPv6 unspecified address
+    # Creates a new IPv6 IPv4-mapped address
     #
     #   ip6 = IPAddress::IPv6::Mapped.new "::ffff:172.16.10.1/128"
     #
+    #   ipv6.ipv4.class
+    #     #=> IPAddress::IPv4
+    #
+    # An IPv6 IPv4-mapped address can also be created using the 
+    # IPv6 only format of the address:
+    #
+    #   ip6 = IPAddress::IPv6::Mapped.new "::0d01:4403"
+    #
+    #   ip6.to_s
+    #     #=> "::ffff:13.1.68.3"
+    #
     def initialize(str)
       string, netmask = str.split("/")
-      @ipv4 = IPAddress::IPv4.extract(string)
+      if string =~ /\./ # IPv4 in dotted decimal form
+        @ipv4 = IPAddress::IPv4.extract(string)
+      else # IPv4 in hex form
+        groups = IPAddress::IPv6.groups(string)
+        @ipv4 = IPAddress::IPv4.parse_u32((groups[-2]<< 16)+groups[-1])
+      end
       super("::ffff:#{@ipv4.to_ipv6}/#{netmask}")
     end
 
@@ -688,11 +736,10 @@ module IPAddress;
     # Similar to IPv6#to_s, but prints out the IPv4 address 
     # in dotted decimal format
     #
-    #
     #   ip6 = IPAddress "::ffff:172.16.10.1/128"
     #
     #   ip6.to_s
-    #     #=> "::FFFF:172.16.10.1"
+    #     #=> "::ffff:172.16.10.1"
     #
     def to_s
       "::ffff:#{@ipv4.address}"
@@ -705,8 +752,8 @@ module IPAddress;
     #
     #   ip6 = IPAddress "::ffff:172.16.10.1/128"
     #
-    #   ip6.to_s
-    #     #=> "::FFFF:172.16.10.1/128"
+    #   ip6.to_string
+    #     #=> "::ffff:172.16.10.1/128"
     #
     def to_string
       "::ffff:#{@ipv4.address}/#@prefix"

data/lib/ipaddress/prefix.rb

@@ -83,6 +83,8 @@ module IPAddress
 
   class Prefix32 < Prefix
 
+    IN4MASK = 0xffffffff
+    
     #
     # Creates a new prefix object for 32 bits IPv4 addresses
     #
@@ -91,11 +93,24 @@ module IPAddress
     #
     def initialize(num)
       unless (1..32).include? num
-        raise ArgumentError, "Prefix must be in range 1..128, got: #{num}"
+        raise ArgumentError, "Prefix must be in range 1..32, got: #{num}"
       end
       super(num)
     end
 
+    #
+    # Returns the length of the host portion
+    # of a netmask. 
+    #
+    #   prefix = Prefix32.new 24
+    #
+    #   prefix.host_prefix
+    #     #=> 8
+    #
+    def host_prefix
+      32 - @prefix
+    end
+    
     #
     # Transforms the prefix into a string of bits
     # representing the netmask
@@ -106,7 +121,7 @@ module IPAddress
     #     #=> "11111111111111111111111100000000"
     #
     def bits
-      "1" * @prefix + "0" * (32 - @prefix)
+      to_u32.to_s(2)
     end
 
     #
@@ -145,7 +160,7 @@ module IPAddress
     #     #=> 4294967040
     #
     def to_u32
-      [bits].pack("B*").unpack("N").first
+      (IN4MASK >> host_prefix) << host_prefix
     end
     
     #
@@ -185,7 +200,7 @@ module IPAddress
     def self.parse_netmask(netmask)
       octets = netmask.split(".").map{|i| i.to_i}
       num = octets.pack("C"*octets.size).unpack("B*").first.count "1"
-      return IPAddress::Prefix.new(num)
+      return self.new(num)
     end
     
   end # class Prefix32 < Prefix
@@ -229,7 +244,7 @@ module IPAddress
     #     #=> 340282366920938463444927863358058659840
     #
     def to_u128
-      eval "0b#{bits}.to_i"
+      bits.to_i(2)
     end
 
   end # class Prefix123 < Prefix

data/test/ipaddress/ipv4_test.rb

@@ -6,8 +6,8 @@ class IPv4Test < Test::Unit::TestCase
     @klass = IPAddress::IPv4
 
     @valid_ipv4 = {
-      "10.0.0.0" => ["10.0.0.0", 8],
-      "10.0.0.1" => ["10.0.0.1", 8],
+      "10.0.0.0" => ["10.0.0.0", 32],
+      "10.0.0.1" => ["10.0.0.1", 32],
       "10.0.0.1/24" => ["10.0.0.1", 24],
       "10.0.0.1/255.255.255.0" => ["10.0.0.1", 24]}
     
@@ -50,6 +50,11 @@ class IPv4Test < Test::Unit::TestCase
     @class_a = @klass.new("10.0.0.1/8")
     @class_b = @klass.new("172.16.0.1/16")
     @class_c = @klass.new("192.168.0.1/24")
+
+    @classful = {
+      "10.1.1.1"  => 8,
+      "150.1.1.1" => 16,
+      "200.1.1.1" => 24 }
     
   end
 
@@ -80,6 +85,7 @@ class IPv4Test < Test::Unit::TestCase
     end
     ip = @klass.new("10.10.0.0")
     assert_instance_of IPAddress::Prefix32, ip.prefix
+    assert_equal 32, ip.prefix.to_i
   end
 
   def test_attributes
@@ -231,6 +237,21 @@ class IPv4Test < Test::Unit::TestCase
     assert_equal false, ip.include?(@klass.new("13.16.0.0/32"))    
   end
 
+  def test_method_private?
+    assert_equal true, @klass.new("192.168.10.50/24").private?
+    assert_equal true, @klass.new("192.168.10.50/16").private?
+    assert_equal true, @klass.new("172.16.77.40/24").private?
+    assert_equal true, @klass.new("172.16.10.50/14").private?
+    assert_equal true, @klass.new("10.10.10.10/10").private?
+    assert_equal true, @klass.new("10.0.0.0/8").private?
+    assert_equal false, @klass.new("192.168.10.50/12").private?
+    assert_equal false, @klass.new("3.3.3.3").private?
+    assert_equal false, @klass.new("10.0.0.0/7").private?
+    assert_equal false, @klass.new("172.32.0.0/12").private?
+    assert_equal false, @klass.new("172.16.0.0/11").private?
+    assert_equal false, @klass.new("192.0.0.2/24").private?
+  end
+
   def test_method_octet
     assert_equal 172, @ip[0]
     assert_equal 16, @ip[1]
@@ -438,7 +459,16 @@ class IPv4Test < Test::Unit::TestCase
     ip = @klass.parse_data "\254\020\n\001"
     assert_instance_of @klass, ip
     assert_equal "172.16.10.1", ip.address
-    assert_equal "172.16.10.1/16", ip.to_string
+    assert_equal "172.16.10.1/32", ip.to_string
+  end
+
+  def test_classmethod_parse_classful
+    @classful.each do |ip,prefix|
+      res = @klass.parse_classful(ip)
+      assert_equal prefix, res.prefix
+      assert_equal "#{ip}/#{prefix}", res.to_string
+    end
+    assert_raise(ArgumentError){ @klass.parse_classful("192.168.256.257") }
   end
   
 end # class IPv4Test

data/test/ipaddress/ipv6_test.rb

@@ -39,7 +39,6 @@ class IPv6Test < Test::Unit::TestCase
     @hex = "20010db80000000000080800200c417a"
   end
   
-  
   def test_attribute_address
     addr = "2001:0db8:0000:0000:0008:0800:200c:417a"
     assert_equal addr, @ip.address
@@ -54,6 +53,10 @@ class IPv6Test < Test::Unit::TestCase
       assert_raise(ArgumentError) {@klass.new ip}
     end
     assert_equal 64, @ip.prefix
+
+    assert_raise(ArgumentError) {
+      @klass.new "::10.1.1.1"
+    }
   end
   
   def test_attribute_groups
@@ -88,6 +91,8 @@ class IPv6Test < Test::Unit::TestCase
 
   def test_method_mapped?
     assert_equal false, @ip.mapped?
+    ip6 = @klass.new "::ffff:1234:5678"
+    assert_equal true, ip6.mapped?
   end
 
   def test_method_literal
@@ -106,6 +111,29 @@ class IPv6Test < Test::Unit::TestCase
     assert_equal false, @ip.network?
   end
 
+  def test_method_network_u128
+    assert_equal 42540766411282592856903984951653826560, @ip.network_u128
+  end
+  
+  def test_method_include?
+    assert_equal true, @ip.include?(@ip)
+    # test prefix on same address
+    included = @klass.new "2001:db8::8:800:200c:417a/128"
+    not_included = @klass.new "2001:db8::8:800:200c:417a/46"
+    assert_equal true, @ip.include?(included)
+    assert_equal false, @ip.include?(not_included)
+    # test address on same prefix 
+    included = @klass.new "2001:db8::8:800:200c:0/64"
+    not_included = @klass.new "2001:db8:1::8:800:200c:417a/64"
+    assert_equal true, @ip.include?(included)
+    assert_equal false, @ip.include?(not_included)
+    # general test
+    included = @klass.new "2001:db8::8:800:200c:1/128"
+    not_included = @klass.new "2001:db8:1::8:800:200c:417a/76"
+    assert_equal true, @ip.include?(included)
+    assert_equal false, @ip.include?(not_included)
+  end
+  
   def test_method_to_hex
     assert_equal @hex, @ip.to_hex
   end
@@ -128,20 +156,11 @@ class IPv6Test < Test::Unit::TestCase
     assert_equal str, @ip.data
   end
 
-
   def test_method_reverse
     str = "f.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.2.0.0.0.5.0.5.0.e.f.f.3.ip6.arpa"
     assert_equal str, @klass.new("3ffe:505:2::f").reverse
   end
 
-#   def test_ip6_int
-#     assert_equal("f.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.2.0.0.0.5.0.5.0.e.f.f.3.ip6.int", IPAddress("3ffe:505:2::f").ip6_int)
-  #     assert_raises(ArgumentError) {
-#       IPAddress("192.168.2.1").ip6_int
-  #     }
-#   end
-
-  
   def test_method_compressed
     assert_equal "1:1:1::1", @klass.new("1:1:1:0:0:0:0:1").compressed
     assert_equal "1:0:1::1", @klass.new("1:0:1:0:0:0:0:1").compressed
@@ -287,6 +306,15 @@ class IPv6MappedTest < Test::Unit::TestCase
     @valid_mapped = {'::13.1.68.3' => 281470899930115,
       '0:0:0:0:0:ffff:129.144.52.38' => 281472855454758,
       '::ffff:129.144.52.38' => 281472855454758}
+
+    @valid_mapped_ipv6 = {'::0d01:4403' => 281470899930115,
+      '0:0:0:0:0:ffff:8190:3426' => 281472855454758,
+      '::ffff:8190:3426' => 281472855454758}
+
+    @valid_mapped_ipv6_conversion = {'::0d01:4403' => "13.1.68.3",
+      '0:0:0:0:0:ffff:8190:3426' => "129.144.52.38",
+      '::ffff:8190:3426' => "129.144.52.38"}
+
   end
 
   def test_initialize
@@ -296,6 +324,16 @@ class IPv6MappedTest < Test::Unit::TestCase
       assert_nothing_raised {@klass.new ip}
       assert_equal u128, @klass.new(ip).to_u128
     end
+    @valid_mapped_ipv6.each do |ip, u128|
+      assert_nothing_raised {@klass.new ip}
+      assert_equal u128, @klass.new(ip).to_u128
+    end
+  end
+
+  def test_mapped_from_ipv6_conversion
+    @valid_mapped_ipv6_conversion.each do |ip6,ip4|
+      assert_equal ip4, @klass.new(ip6).ipv4.to_s
+    end
   end
 
   def test_attributes

data/test/ipaddress/prefix_test.rb

@@ -41,6 +41,7 @@ class Prefix32Test < Test::Unit::TestCase
     @prefix_hash.each do |netmask, num|
       prefix = @klass.parse_netmask(netmask)
       assert_equal num, prefix.prefix
+      assert_instance_of @klass, prefix
     end
   end
 

metadata

@@ -1,7 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ipaddress
 version: !ruby/object:Gem::Version 
-  version: 0.6.0
+  hash: 3
+  prerelease: false
+  segments: 
+  - 0
+  - 7
+  - 0
+  version: 0.7.0
 platform: ruby
 authors: 
 - Marco Ceresa
@@ -9,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-19 00:00:00 +02:00
+date: 2010-09-08 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
@@ -51,21 +57,27 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: IPv4/IPv6 addresses manipulation library