ipadmin 0.2.0 → 0.2.1

data/README

@@ -1,9 +1,9 @@
 
- Copyright (c) 2006 Dustin Spinhirne <dspinhir at yahoo.com>
+ Copyright (c) 2006 Dustin Spinhirne
  Licensed under the same terms as Ruby, No Warranty is provided.
 
 
- Comments are welcome. Please include 'Ruby - IPAdmin' in the title of
+ Comments are welcome. Please include 'IPAdmin' in the title of
  any emails. 
  
  Dustin Spinhirne
@@ -50,17 +50,17 @@
  puts "cidr6 netmask in bits #{cidr6.bits()}"
  print "\n"
  
- # contains
+ # contains?
  puts "contains"
- puts "#{cidr4.desc} contains #{cidr4_2.desc}" if ( cidr4.contains(cidr4_2) )
- puts "#{cidr6.desc} contains #{cidr6_2.desc}" if ( cidr6.contains(cidr6_2) )
+ puts "#{cidr4.desc} contains #{cidr4_2.desc}" if ( cidr4.contains?(cidr4_2) )
+ puts "#{cidr6.desc} contains #{cidr6_2.desc}" if ( cidr6.contains?(cidr6_2) )
  print "\n"
 
  # desc
  puts "desc"
  puts "cidr4 description #{cidr4.desc()}"
  puts "cidr6 description #{cidr6.desc()}"
- puts "cidr6 short-hand description #{cidr6.desc(:Short => 1)}"
+ puts "cidr6 short-hand description #{cidr6.desc(:Short => true)}"
  print "\n"
 
  # enumerate
@@ -69,7 +69,7 @@
  cidr4.enumerate(:Limit => 4, :Bitstep => 32).each {|x| puts "  #{x}"}
  
  puts "first 4 cidr6 addresses (bitstep 32)"
- cidr6.enumerate(:Limit => 4, :Bitstep => 32, :Objectify => 1).each {|x| puts "  #{x.desc}"}
+ cidr6.enumerate(:Limit => 4, :Bitstep => 32, :Objectify => true).each {|x| puts "  #{x.desc}"}
  print "\n"
 
  # hostmask_ext
@@ -80,13 +80,13 @@
  # ip
  puts "ip"
  puts "cidr4 ip #{cidr4.ip()}"
- puts "cidr6 short-hand ip #{cidr6.ip(:Short => 1)}"
+ puts "cidr6 short-hand ip #{cidr6.ip(:Short => true)}"
  print "\n"
  
  # last
  puts "last"
  puts "cidr4 last ip #{cidr4.last()}"
- puts "cidr6 last ip #{cidr6.last(:Short => 1)}"
+ puts "cidr6 last ip #{cidr6.last(:Short => true)}"
  print "\n"
 
  # netmask
@@ -103,25 +103,25 @@
  # network
  puts "network"
  puts "cidr4 network address #{cidr4.network()}"
- puts "cidr6 network address #{cidr6.network(:Short => 1)}"
+ puts "cidr6 network address #{cidr6.network(:Short => true)}"
  print "\n"
  
  # next_ip
  puts "next_ip"
  puts "cidr4 next ip #{cidr4.next_ip()}"
- puts "cidr6 next ip #{cidr6.next_ip(:Short => 1)}"
+ puts "cidr6 next ip #{cidr6.next_ip(:Short => true)}"
  print "\n"
  
  # next_subnet
  puts "next_subnet"
  puts "cidr4 next subnet #{cidr4.next_subnet()}"
- puts "cidr6 next subnet #{cidr6.next_subnet(:Short => 1)}"
+ puts "cidr6 next subnet #{cidr6.next_subnet(:Short => true)}"
  print "\n"
 
  # nth
  puts "nth"
  puts "cidr4 1st ip is #{cidr4.nth(:Index => 1)}"
- puts "cidr6 1st ip is #{(cidr6.nth(:Index => 1, :Objectify => 1)).base}"
+ puts "cidr6 1st ip is #{(cidr6.nth(:Index => 1, :Objectify => true)).base}"
  print "\n"
  
  # packed_hostmask
@@ -173,8 +173,8 @@
  puts "#{cidr4.desc} subnetted into at least 3 /28 ranges"
  cidr4.subnet(:Subnet => 28, :MinCount => 3).each {|x| puts "  #{x}"} 
  
- puts "#{cidr6.desc(:Short => 1)} subnetted into at least 4 /67 ranges"
- cidr6.subnet(:Subnet => 67, :MinCount => 4, :Short => 1).each {|x| puts "  #{x}"}
+ puts "#{cidr6.desc(:Short => true)} subnetted into at least 4 /67 ranges"
+ cidr6.subnet(:Subnet => 67, :MinCount => 4, :Short => true).each {|x| puts "  #{x}"}
 
  print "\n\n\n"
  #=====================================#

data/lib/ip_admin.rb

@@ -1,5 +1,5 @@
 =begin rdoc
- Copyright (c) 2006 Dustin Spinhirne <dspinhir at yahoo.com> -  
+ Copyright (c) 2006 Dustin Spinhirne <http://www.spinhirne.com> -  
  Licensed under the same terms as Ruby, No Warranty is provided.
 =end
 
@@ -220,9 +220,9 @@ module_function :create_net_struct
 # - Arguments:
 #   * Hash with the following fields:
 #       - :List -- Array of IPAdmin::CIDR or NetStruct objects
-#       - :NetStruct -- if non-nil, return IPAdmin::NetStruct objects (optional)
-#       - :Objectify -- if non-nil, return IPAdmin::CIDR objects (optional)
-#       - :Short -- if non-nil, return IPv6 addresses in short-hand notation (optional)
+#       - :NetStruct -- if true, return IPAdmin::NetStruct objects (optional)
+#       - :Objectify -- if true, return IPAdmin::CIDR objects (optional)
+#       - :Short -- if true, return IPv6 addresses in short-hand notation (optional)
 #
 # - Returns:
 #   * Array of IPAdmin::CIDR or IPAdmin::NetStruct objects
@@ -232,8 +232,8 @@ module_function :create_net_struct
 #
 def merge(options)
     version = nil
-    short = nil
-    objectify = nil
+    short = false
+    objectify = false
 
     # validate options
     unless ( options.kind_of?(Hash) )
@@ -245,11 +245,11 @@ def merge(options)
     end
     
     if (options[:Short])
-        short = 1
+        short = true
     end
     
     if (options[:Objectify])
-        objectify = 1
+        objectify = true
     end
 
     list = options[:List]
@@ -448,7 +448,7 @@ module_function :merge
 # pack_ipv4_addr()
 #==============================================================================#
 
-# Convert IPv4 addresses into single a byte-packed field. No attempt at
+# Convert IPv4 addresses into an integer. No attempt at
 # validation is performed.
 #
 # - Arguments:
@@ -490,7 +490,7 @@ module_function :pack_ipv4_addr
 # pack_ipv4_netmask()
 #==============================================================================#
 
-# Convert IPv4 netmask into a single byte-packed field.  Only very basic
+# Convert IPv4 netmask into an integer.  Only very basic
 # validation is performed.
 #
 # - Arguments:
@@ -549,7 +549,7 @@ module_function :pack_ipv4_netmask
 # pack_ipv6_addr()
 #==============================================================================#
 
-# Convert IPv6 addresses into a single byte-packed field. No attempt at 
+# Convert IPv6 addresses into an integer. No attempt at 
 # validation is performed.
 #
 # - Arguments:
@@ -619,7 +619,7 @@ module_function :pack_ipv6_addr
 # pack_ipv6_netmask()
 #==============================================================================#
 
-# Convert IPv6 netmask into a single byte-packed field. Only very basic 
+# Convert IPv6 netmask into an integer. Only very basic 
 # validation is performed.
 #
 # - Arguments:
@@ -676,7 +676,8 @@ module_function :pack_ipv6_netmask
 #       - :Bitstep -- enumerate in X sized steps (optional)
 #       - :Boundaries -- array of (2) IPAdmin::CIDR objects
 #       - :Limit -- limit returned list to X number of items (optional)
-#       - :Objectify -- return IPAdmin::CIDR objects (optional)
+#       - :Objectify -- if true, return IPAdmin::CIDR objects (optional)
+#       - :Short -- if true, return IPv6 addresses in short-hand notation (optional)
 #
 # - Returns:
 #   * Array of IP addresses or IPAdmin::CIDR objects
@@ -691,7 +692,9 @@ module_function :pack_ipv6_netmask
 def range(options)
     list = []
     bitstep = 1
-    objectify,limit = nil,nil
+    objectify = false
+    short = false
+    limit = nil
 
     # check options
     if (options)
@@ -711,7 +714,11 @@ def range(options)
         end
 
         if( options.has_key?(:Objectify) )
-            objectify = 1
+            objectify = true
+        end
+        
+        if( options.has_key?(:Short) )
+            short = true
         end
 
         if( options.has_key?(:Limit) )
@@ -758,7 +765,10 @@ def range(options)
 
         until (my_ip == boundaries[1])
             if (!objectify)
-                list.push( IPAdmin.unpack_ipv6_addr(my_ip) )
+                my_ips = IPAdmin.unpack_ipv6_addr(my_ip)
+                my_ips = IPAdmin.shorten(my_ips) if (short)
+                list.push(my_ips)
+                
             else
                 my_ip_s = IPAdmin.unpack_ipv6_addr(my_ip)
                 list.push( IPAdmin::CIDR.new(:CIDR => my_ip_s) )
@@ -808,45 +818,58 @@ def shorten(addr)
 
     # make sure this isnt already shorthand
     if (addr =~ /::/)
-        raise "#{addr} already appears to be in IPv6 shorthand notation."
+        return(addr)
     end
 
-    # look for most 0 fields
-    found_zero = nil
-    pattern = ""
-    zero_fields = []
-    fields = addr.split(":")  
-
+    # look for most consecutive '0' fields
+    start_field,end_field = nil,nil
+    start_end = []
+    consecutive,longest = 0,0
+    fields = addr.split(":")
+    
     (0..(fields.length-1)).each do |x|
         fields[x] = fields[x].to_i(16)
 
         if (fields[x] == 0)
-            if (!found_zero)
-                found_zero = 1
+            if (!start_field)
+                start_field = x
+                end_field = x
+            else
+                end_field = x
             end
-            pattern << ":0"
+            consecutive += 1
         else
-            if (found_zero)
-                found_zero = nil
-                pattern << ":"
-                zero_fields.push(pattern)
-                pattern = ""
+            if (start_field)
+                if (consecutive > longest)
+                    longest = consecutive
+                    start_end = [start_field,end_field]
+                    start_field,end_field = nil,nil                    
+                end
+                consecutive = 0
             end
         end
 
         fields[x] = fields[x].to_s(16)
     end
-
-    # pattern should be the longest set of 0's in a row
-    zero_fields.push(pattern) if (pattern != "")
-    pattern = ""
-    zero_fields.each do |x|
-        pattern = x if (x.length > pattern.length)
+    
+    # if our longest set of 0's is at the end, then start & end fields
+    # are already set. if not, then make start & end fields the ones we've
+    # stored away in start_end
+    if (consecutive > longest) 
+        longest = consecutive
+    else
+        start_field = start_end[0]
+        end_field = start_end[1]
     end
 
-    short = fields.join(":")
-    short.sub!(pattern,"::")
-
+    if (longest > 1)        
+        fields[start_field] = ''
+        start_field += 1
+        fields.slice!(start_field..end_field)
+    end
+    short = fields.join(':')
+    short << ':' if (short =~ /:$/)
+    
     return(short)
 end
 module_function :shorten
@@ -941,8 +964,8 @@ module_function :sort
 # unpack_ipv4_addr()
 #==============================================================================#
 
-# Unack IPv4 address back into a printable string. No attempt at validation
-# is performed.
+# Unack a packed IPv4 address back into a printable string. No attempt at
+# validation is performed.
 #
 # - Arguments:
 #   * Byte-packed IPv4 address
@@ -977,7 +1000,7 @@ module_function :unpack_ipv4_addr
 # unpack_ipv4_netmask()
 #==============================================================================#
 
-# Unack IPv4 netmask into a integer representing the number of
+# Unack a packed IPv4 netmask into a integer representing the number of
 # bits in the CIDR mask. No attempt at validation is performed.
 #
 # - Arguments:
@@ -1012,8 +1035,8 @@ module_function :unpack_ipv4_netmask
 # unpack_ipv6_addr()
 #==============================================================================#
 
-# Unack IPv6 address back into a printable string. No attempt at validation
-# is performed.
+# Unack a packed IPv6 address back into a printable string. No attempt at 
+# validation is performed.
 #
 # - Arguments:
 #   * Byte-packed IPv6 address
@@ -1053,7 +1076,7 @@ module_function :unpack_ipv6_addr
 # unpack_ipv6_netmask()
 #==============================================================================#
 
-# Unack IPv6 netmask into a integer representing the number of
+# Unack a packed IPv6 netmask into a integer representing the number of
 # bits in the CIDR mask. No attempt at validation is performed.
 #
 # - Arguments:
@@ -1130,7 +1153,7 @@ module_function :unshorten
 #   * IPv4 address
 #
 # - Returns:
-#   * byte-packed IP on valid, or exception on error.
+#   * packed IP on valid, or exception on error.
 #
 # Example:
 #   IPAdmin.validate_ipv4_addr('192.168.1.1')
@@ -1189,7 +1212,7 @@ module_function :validate_ipv4_addr
 #   * IPv4 netmask in cidr or extended notation
 #
 # - Returns:
-#   * byte-packed netmask on valid, or exception on error.
+#   * packed netmask on valid, or exception on error.
 #
 # Example:
 #   IPAdmin.validate_ipv4_netmask('255.255.255.0')
@@ -1276,7 +1299,7 @@ module_function :validate_ipv4_netmask
 #   * IPv6 address
 #
 # - Returns:
-#   * byte-packed IP on valid, or exception on error.
+#   * packed IP on valid, or exception on error.
 #
 # Example:
 #   IPAdmin.validate_ipv6_addr('fec0::')
@@ -1352,7 +1375,7 @@ module_function :validate_ipv6_addr
 #   * IPv6 netmask in cidr notation
 #
 # - Returns:
-#   * byte-packed netmask on valid, or exception on error.
+#   * packed netmask on valid, or exception on error.
 #
 # Example:
 #   IPAdmin.validate_ipv6_netmask('64')
@@ -1602,7 +1625,7 @@ class CIDR
 
 
 #==============================================================================#
-# contains()
+# contains?()
 #==============================================================================#
 
 # Determines if this object contains (is supernet of)
@@ -1612,14 +1635,14 @@ class CIDR
 #   * IPAdmin:CIDR object
 #
 # - Returns:
-#   * 1 on true, nil on false
+#   * true or false
 #
 # Example:
 #   cidr4_2 = IPAdmin::CIDR.new(:CIDR => '192.168.1.0/26')
-#   contains = cidr4.contains(cidr4_2)   --> 1
+#   contains? = cidr4.contains(cidr4_2)   --> true
 #
-    def contains(object)
-        is_contained = nil
+    def contains?(object)
+        is_contained = false
 
         if (object.kind_of?(IPAdmin::CIDR))
             network = object.packed_network 
@@ -1640,11 +1663,11 @@ class CIDR
         # else we can tell by or'ing network and @network by @hostmask
         # and comparing the results
         if (network == @network)
-            is_contained = 1 if (netmask > @netmask)
+            is_contained = true if (netmask > @netmask)
 
         else
             if ( (network | @hostmask) == (@network | @hostmask) )
-                is_contained = 1
+                is_contained = true
             end
         end
 
@@ -1664,8 +1687,8 @@ class CIDR
 #
 # - Arguments:
 #   * Optional hash with the following fields:
-#       - :IP -- if non-nil, return the ip/netmask passed during initialization (optional)
-#       - :Short -- if non-nil, return IPv6 addresses in short-hand notation (optional)
+#       - :IP -- true, return the ip/netmask passed during initialization (optional)
+#       - :Short -- if true, return IPv6 addresses in short-hand notation (optional)
 #
 # - Returns:
 #   * Description in network/netmask format
@@ -1675,8 +1698,8 @@ class CIDR
 #   puts cidr4.desc(:IP => 1)   --> 192.168.1.1/24
 #
     def desc(options=nil)
-        short = nil
-        orig_ip = nil
+        short = false
+        orig_ip = false
 
         if (options)
             unless (options.kind_of? Hash)
@@ -1684,11 +1707,11 @@ class CIDR
             end
             
             if (options.has_key?(:Short))
-                short = 1
+                short = true
             end
             
             if (options.has_key?(:IP))
-                orig_ip = 1
+                orig_ip = true
             end
         end
         
@@ -1729,8 +1752,8 @@ class CIDR
 #   * Optional Hash with the following fields:
 #       - :Bitstep -- enumerate in X sized steps (optional)
 #       - :Limit -- limit returned list to X number of items (optional)
-#       - :Objectify -- if non-nil, return IPAdmin::CIDR objects (optional)
-#       - :Short -- if non-nil, return IPv6 addresses in short-hand notation (optional)
+#       - :Objectify -- if true, return IPAdmin::CIDR objects (optional)
+#       - :Short -- if true, return IPv6 addresses in short-hand notation (optional)
 #
 # - Returns:
 #   * Array of IP addresses or IPAdmin::CIDR objects
@@ -1740,9 +1763,9 @@ class CIDR
 #
     def enumerate(options=nil)
         bitstep = 1
-        objectify = nil
+        objectify = false
         limit = nil
-        short = nil
+        short = false
 
         if (options)
             if( options.has_key?(:Bitstep) )
@@ -1750,7 +1773,7 @@ class CIDR
             end
 
             if( options.has_key?(:Objectify) )
-                objectify = 1
+                objectify = true
             end
 
             if( options.has_key?(:Limit) )
@@ -1758,7 +1781,7 @@ class CIDR
             end
             
             if( options.has_key?(:Short) )
-                short = 1
+                short = true
             end
         end
 
@@ -1854,8 +1877,8 @@ class CIDR
 #
 # - Arguments:
 #   * Optional Hash with the following fields:
-#       - :Objectify -- if non-nil, return IPAdmin::CIDR object (optional)
-#       - :Short -- if non-nil, return IPv6 addresses in short-hand notation (optional)
+#       - :Objectify -- if true, return IPAdmin::CIDR object (optional)
+#       - :Short -- if true, return IPv6 addresses in short-hand notation (optional)
 #
 # - Returns:
 #   * IP address or IPAdmin::CIDR object.
@@ -1864,8 +1887,8 @@ class CIDR
 #   puts cidr4.ip()   --> 192.168.1.1
 #
     def ip(options=nil)
-        objectify = nil
-        short =nil
+        objectify = false
+        short = false
         
         if (options)
             unless(options.kind_of?(Hash))
@@ -1874,11 +1897,11 @@ class CIDR
             end
             
             if( options.has_key?(:Short) )
-                short = 1
+                short = true
             end
             
             if( options.has_key?(:Objectify) )
-                objectify = 1
+                objectify = true
             end
         end
 
@@ -1911,8 +1934,8 @@ class CIDR
 #
 # - Arguments:
 #   * Optional Hash with the following fields:
-#       - :Objectify -- if non-nil, return IPAdmin::CIDR object (optional)
-#       - :Short -- if non-nil, return IPv6 addresses in short-hand notation (optional)
+#       - :Objectify -- if true, return IPAdmin::CIDR object (optional)
+#       - :Short -- if true, return IPv6 addresses in short-hand notation (optional)
 #
 # - Returns:
 #   * IP address or IPAdmin::CIDR object.
@@ -1921,8 +1944,8 @@ class CIDR
 #   puts cidr4.last()   --> 192.168.1.255
 #
     def last(options=nil)
-        objectify = nil
-        short = nil
+        objectify = false
+        short = false
         
         if (options)
             unless(options.kind_of?(Hash))
@@ -1931,11 +1954,11 @@ class CIDR
             end
             
             if( options.has_key?(:Short) )
-                short = 1
+                short = true
             end
             
             if( options.has_key?(:Objectify) )
-                objectify = 1
+                objectify = true
             end
 
         end
@@ -2031,8 +2054,8 @@ class CIDR
 #
 # - Arguments:
 #   * Optional Hash with the following fields:
-#       - :Objectify -- if non-nil, return IPAdmin::CIDR object (optional)
-#       - :Short -- if non-nil, return IPv6 addresses in short-hand notation (optional)
+#       - :Objectify -- if true, return IPAdmin::CIDR object (optional)
+#       - :Short -- if true, return IPv6 addresses in short-hand notation (optional)
 #
 # - Returns:
 #   * IP address or IPAdmin::CIDR object.
@@ -2041,8 +2064,8 @@ class CIDR
 #   puts cidr4.network()   --> 192.168.1.0
 #
     def network(options=nil)
-        objectify = nil
-        short =nil
+        objectify = false
+        short = false
         
         if (options)
             unless(options.kind_of?(Hash))
@@ -2051,11 +2074,11 @@ class CIDR
             end
             
             if( options.has_key?(:Short) )
-                short = 1
+                short = true
             end
             
             if( options.has_key?(:Objectify) )
-                objectify = 1
+                objectify = true
             end
         end
 
@@ -2091,8 +2114,8 @@ class CIDR
 # - Arguments:
 #   * Optional Hash with the following fields:
 #       - :Bitstep -- step in X sized steps (optional)
-#       - :Objectify -- if non-nil, return IPAdmin::CIDR object (optional)
-#       - :Short -- if non-nil, return IPv6 addresses in short-hand notation (optional)
+#       - :Objectify -- if true, return IPAdmin::CIDR object (optional)
+#       - :Short -- if true, return IPv6 addresses in short-hand notation (optional)
 #
 # - Returns:
 #   * IP address or IPAdmin::CIDR object.
@@ -2102,8 +2125,8 @@ class CIDR
 #
     def next_ip(options=nil)
         bitstep = 1
-        objectify = nil
-        short = nil
+        objectify = false
+        short = false
         
         if (options)
             unless(options.kind_of?(Hash))
@@ -2116,11 +2139,11 @@ class CIDR
             end
             
             if( options.has_key?(:Short) )
-                short = 1
+                short = true
             end
         
             if( options.has_key?(:Objectify) )
-                objectify = 1
+                objectify = true
             end
         end
         
@@ -2159,8 +2182,8 @@ class CIDR
 # - Arguments:
 #   * Optional Hash with the following fields:
 #       - :Bitstep -- step in X sized steps. (optional)
-#       - :Objectify -- if non-nil, return IPAdmin::CIDR object (optional)
-#       - :Short -- if non-nil, return IPv6 addresses in short-hand notation (optional)
+#       - :Objectify -- if true, return IPAdmin::CIDR object (optional)
+#       - :Short -- if true, return IPv6 addresses in short-hand notation (optional)
 #
 # - Returns:
 #   * CIDR address or IPAdmin::CIDR object.
@@ -2170,8 +2193,8 @@ class CIDR
 #
     def next_subnet(options=nil)
         bitstep = 1
-        objectify = nil
-        short = nil
+        objectify = false
+        short = false
         
         if (options)
             unless(options.kind_of?(Hash))
@@ -2184,11 +2207,11 @@ class CIDR
             end
             
             if( options.has_key?(:Short) )
-                short = 1
+                short = true
             end
         
             if( options.has_key?(:Objectify) )
-                objectify = 1
+                objectify = true
             end
         end
         
@@ -2228,8 +2251,8 @@ class CIDR
 # - Arguments:
 #   * Hash with the following fields:
 #       - :Index -- index number of the IP address to return
-#       - :Objectify -- if non-nil, return IPAdmin::CIDR objects (optional)
-#       - :Short -- if non-nil, return IPv6 addresses in short-hand notation (optional)
+#       - :Objectify -- if true, return IPAdmin::CIDR objects (optional)
+#       - :Short -- if true, return IPv6 addresses in short-hand notation (optional)
 #
 # - Returns:
 #   * IP address or IPAdmin::CIDR object.
@@ -2238,8 +2261,8 @@ class CIDR
 #   puts cidr4.nth(:Index => 1)   --> 192.168.1.1
 #
     def nth(options)
-        objectify = nil
-        short = nil
+        objectify = false
+        short = false
 
         unless(options.kind_of?(Hash))
             raise Argumenterror, "Expected Hash, but " +
@@ -2252,11 +2275,11 @@ class CIDR
         index = options[:Index]
 
         if( options.has_key?(:Short) )
-            short = 1
+            short = true
         end
         
         if( options.has_key?(:Objectify) )
-                objectify = 1
+                objectify = true
         end
 
         my_ip = @network + index
@@ -2292,7 +2315,7 @@ class CIDR
 # packed_hostmask()
 #==============================================================================#
 
-# Provide byte-packed Hostmask of this object.
+# Provide an integer representing the packed Hostmask of this object.
 #
 # - Arguments:
 #   * none
@@ -2316,7 +2339,7 @@ class CIDR
 # packed_ip()
 #==============================================================================#
 
-# Provide byte-packed IP of this object.
+# Provide an integer representing the packed IP of this object.
 #
 # - Arguments:
 #   * none
@@ -2340,7 +2363,7 @@ class CIDR
 # packed_netmask()
 #==============================================================================#
 
-# Provide byte-packed Netmask of this object.
+# Provide an integer representing the packed Netmask of this object.
 #
 # - Arguments:
 #   * none
@@ -2364,7 +2387,7 @@ class CIDR
 # packed_network()
 #==============================================================================#
 
-# Provide byte-packed Network address of this object.
+# Provide an integer representing the packed Network address of this object.
 #
 # - Arguments:
 #   * none
@@ -2395,8 +2418,8 @@ class CIDR
 #   * Hash with the following fields:
 #       - :Bitstep -- enumerate in X sized steps (optional)
 #       - :Indexes -- array of (2) index numbers of the addresses to use as boundaries
-#       - :Objectify -- if non-nil, return IPAdmin::CIDR objects (optional)
-#       - :Short -- if non-nil, return IPv6 addresses in short-hand notation (optional)
+#       - :Objectify -- if true, return IPAdmin::CIDR objects (optional)
+#       - :Short -- if true, return IPv6 addresses in short-hand notation (optional)
 #
 # - Returns:
 #   * Array of IP addresses or IPAdmin::CIDR objects
@@ -2405,8 +2428,8 @@ class CIDR
 #   list = cidr4.range(:Indexes => [0,1]) --> ['192.168.1.0','192.168.1.1']
 #
     def range(options)
-        objectify = nil
-        short = nil
+        objectify = false
+        short = false
         bitstep = 1
 
         unless(options.kind_of?(Hash))
@@ -2432,11 +2455,11 @@ class CIDR
         end
         
         if( options.has_key?(:Short) )
-            short = 1
+            short = true
         end
         
         if( options.has_key?(:Objectify) )
-            objectify = 1
+            objectify = true
         end
         
         if( options.has_key?(:Bitstep) )
@@ -2475,14 +2498,14 @@ class CIDR
 # remainder()
 #==============================================================================#
 
-# Given a subnet of the current CIDR, provide the remainder of
-# the current CIDR.
+# Given a subnet of the current CIDR, provide the remaining subnets of
+# the CIDR.
 #
 # - Arguments:
 #   * Optional hash with the following fields:
 #       - :Exclude -- IPAdmin::CIDR object to use in calculating the remainder.
-#       - :Objectify -- if non-nil, return IPAdmin::CIDR objects (optional)
-#       - :Short -- if non-nil, return IPv6 addresses in short-hand notation (optional)
+#       - :Objectify -- if true, return IPAdmin::CIDR objects (optional)
+#       - :Short -- if true, return IPv6 addresses in short-hand notation (optional)
 #
 # - Returns:
 #   * Array of CIDR addresses or IPAdmin::CIDR objects
@@ -2511,23 +2534,23 @@ class CIDR
         end
         
         if( options.has_key?(:Short) )
-            short = 1
+            short = true
         end
         
         if( options.has_key?(:Objectify) )
-            objectify = 1
+            objectify = true
         end
         
         # make sure 'to_exclude' is the same ip version
         unless ( to_exclude.version == @version )
-            raise "#{to_exclude.desc(:Short => 1)} is of a different " +
-                  "IP version than #{self.desc(:Short => 1)}."
+            raise "#{to_exclude.desc(:Short => true)} is of a different " +
+                  "IP version than #{self.desc(:Short => true)}."
         end    
 
         # make sure we contain 'to_exclude'
-        unless ( self.contains(to_exclude) == 1 )
-            raise "#{to_exclude.desc(:Short => 1)} does not fit " +
-                  "within the bounds of #{self.desc(:Short => 1)}."
+        unless ( self.contains?(to_exclude) == true )
+            raise "#{to_exclude.desc(:Short => true)} does not fit " +
+                  "within the bounds of #{self.desc(:Short => true)}."
         end
 
         # split this cidr in half & see which half 'to_exclude'
@@ -2712,8 +2735,8 @@ class CIDR
 #   * Optional hash with the following fields:
 #       - :IPCount -- Minimum number of IP's that new subnets should contain (optional)
 #       - :MinCount -- Minimum number of X sized subnets to return (optional)
-#       - :Objectify -- if non-nil, return IPAdmin::CIDR objects (optional)
-#       - :Short -- if non-nil, return IPv6 addresses in short-hand notation (optional)
+#       - :Objectify -- if true, return IPAdmin::CIDR objects (optional)
+#       - :Short -- if true, return IPv6 addresses in short-hand notation (optional)
 #       - :Subnet --  Netmask (in bits) of new subnets (optional)
 #
 # - Returns:
@@ -2732,8 +2755,8 @@ class CIDR
         my_mask = self.bits
         subnet_bits = my_mask + 1
         min_count = nil 
-        objectify = nil
-        short = nil       
+        objectify = false
+        short = false       
         
         if (options)
             unless (options.kind_of? Hash)
@@ -2758,11 +2781,11 @@ class CIDR
             end
             
             if( options.has_key?(:Short) )
-                short = 1
+                short = true
             end
         
             if( options.has_key?(:Objectify) )
-                objectify = 1
+                objectify = true
             end
             
         end
@@ -3126,7 +3149,7 @@ class Tree
 #   * Two NetStruct objects
 #
 # - Returns:
-#   * 1 if struct1 contains or is equal to struct2, or nil if not.
+#   * true if struct1 contains or is equal to struct2, or false if not.
 #
 # Example:
 #   is_contained = contains(struct1,struct2)
@@ -3149,14 +3172,14 @@ class Tree
         # if network1 == network2, then we have to go by netmask length
         # else we can tell by or'ing network1 and network2 by hostmask1
         # and comparing the results
-        is_contained = nil
+        is_contained = false
         if (network1 == network2)
             if (netmask2 >= netmask1)
-                is_contained = 1
+                is_contained = true
             end
         else
             if ( (network1 | hostmask1) == (network2 | hostmask1) )
-                is_contained = 1
+                is_contained = true
             end
         end
 
@@ -3250,7 +3273,7 @@ class Tree
 #   * IPAdmin::CIDR object
 #
 # - Returns:
-#   * 1 if exists, nil if not
+#   * true or false
 #
 # Example:
 #   added = tree.exists?(cidr)
@@ -3272,10 +3295,11 @@ class Tree
         home_struct,home_branch = find_home(net_struct, @root)
 
         # check for match
+        found = false
         if (home_struct)  
             if ( (net_struct.network == home_struct.network) && 
                  (net_struct.netmask == home_struct.netmask) )
-                found = 1
+                found = true
             end
         end
 
@@ -3389,12 +3413,12 @@ class Tree
 #       - :Limit -- Maximum entries to return (optional)
 #       - :Subnet -- Netmask (in bits) of space to find(optional)
 #
-# Note:
-#    :Subnet always takes precedence over :IPCount.
-#
 # - Returns:
 #   * ordered array of IPAdmin::CIDR objects
 #
+# Note:
+#    :Subnet always takes precedence over :IPCount.
+#
 # Example:
 #   list = tree.find_space(:Subnet => 27)
 #   list = tree.find_space(:IPCount => 33, :Limit => 2)
@@ -3482,7 +3506,7 @@ class Tree
 #   * IPAdmin::CIDR object
 #
 # - Returns:
-#   * 1 on success, or nil
+#   * true on success, or false
 #
 # Example:
 #   did_prune = tree.prune(ip)
@@ -3506,9 +3530,10 @@ class Tree
         end
         
         # remove if home_struct.object = object
+        pruned = false
         if (home_struct.object = object)
             home_branch.delete(home_struct)
-            pruned = 1
+            pruned = true
         end
 
         return(pruned)
@@ -3529,7 +3554,7 @@ class Tree
 #   * IPAdmin::CIDR object
 #
 # - Returns:
-#   * 1 on success, or nil
+#   * true on success, or false
 #
 # Example:
 #   did_remove = tree.remove(ip)
@@ -3549,6 +3574,7 @@ class Tree
         home_struct,home_branch = find_home(net_struct, @root)
 
         # remove if home_struct.object = object
+        removed = false
         if (home_struct.object = object)
 
             # if we have children subnets, move them up one level
@@ -3566,7 +3592,7 @@ class Tree
             end
 
             home_branch.delete(home_struct)
-            removed = 1
+            removed = true
         end
 
         return(removed)

data/tests/cidr_test.rb

@@ -16,7 +16,7 @@ class TestCIDR < Test::Unit::TestCase
         assert_not_nil(IPAdmin::CIDR.new(:CIDR => 'fec0::1/64') )
     end
     
-    def test_contains
+    def test_contains?
 
         cidr4 = IPAdmin::CIDR.new(:CIDR => '192.168.1.0/24')
         cidr4_2 = IPAdmin::CIDR.new(:CIDR => '192.168.1.0/26')
@@ -25,10 +25,10 @@ class TestCIDR < Test::Unit::TestCase
         cidr6_2 = IPAdmin::CIDR.new(:CIDR => 'fec0::/96')
         cidr6_3 = IPAdmin::CIDR.new(:CIDR => 'fe80::/96')
         
-        assert_equal(1,cidr4.contains(cidr4_2) )
-        assert_equal(1,cidr6.contains(cidr6_2) )
-        assert_nil(cidr4.contains(cidr4_3) )
-        assert_nil(cidr6.contains(cidr6_3) )       
+        assert_equal(true,cidr4.contains?(cidr4_2) )
+        assert_equal(true,cidr6.contains?(cidr6_2) )
+        assert_equal(false,cidr4.contains?(cidr4_3) )
+        assert_equal(false,cidr6.contains?(cidr6_3) )       
     end
     
     def test_nth
@@ -36,12 +36,12 @@ class TestCIDR < Test::Unit::TestCase
         cidr6 = IPAdmin::CIDR.new(:CIDR => 'fec0::/126')
         
         assert_equal('192.168.1.1',cidr4.nth(:Index => 1) )
-        assert_kind_of(IPAdmin::CIDR,cidr4.nth(:Index => 1, :Objectify => 1) )
+        assert_kind_of(IPAdmin::CIDR,cidr4.nth(:Index => 1, :Objectify => true) )
         assert_raise(RuntimeError){ cidr4.nth(:Index => 256) }
         assert_raise(ArgumentError){ cidr4.nth() }
         
         assert_equal('fec0:0000:0000:0000:0000:0000:0000:0001',cidr6.nth(:Index => 1) )
-        assert_equal('fec0::1',cidr6.nth(:Index => 1, :Short => 1) )
+        assert_equal('fec0::1',cidr6.nth(:Index => 1, :Short => true) )
         assert_raise(RuntimeError){ cidr6.nth(:Index => 10) }
     end
     
@@ -51,7 +51,7 @@ class TestCIDR < Test::Unit::TestCase
         
         assert_equal(['192.168.1.0'],cidr4.enumerate(:Limit => 1) )
         assert_equal(['fec0:0000:0000:0000:0000:0000:0000:0000'],cidr6.enumerate(:Limit => 1) )
-        assert_equal(['fec0::'],cidr6.enumerate(:Limit => 1, :Short => 1) )
+        assert_equal(['fec0::'],cidr6.enumerate(:Limit => 1, :Short => true) )
         
         
         enums4 = cidr4.enumerate(:Limit => 2, :Bitstep => 5)
@@ -59,7 +59,7 @@ class TestCIDR < Test::Unit::TestCase
         assert_equal('192.168.1.5', enums4[1] )
         assert_equal('fec0:0000:0000:0000:0000:0000:0000:0005', enums6[1] )
         
-        enums4 = cidr4.enumerate(:Objectify => 1,:Limit => 1)
+        enums4 = cidr4.enumerate(:Objectify => true,:Limit => 1)
         assert_kind_of(IPAdmin::CIDR, enums4[0] )
         
     end
@@ -73,7 +73,7 @@ class TestCIDR < Test::Unit::TestCase
         assert_equal('192.168.2.0',next4 )
         assert_equal('fec0:0000:0000:0001:0000:0000:0000:0000',next6 )
         
-        next6 = cidr6.next_ip(:Short => 1)
+        next6 = cidr6.next_ip(:Short => true)
         assert_equal('fec0:0:0:1::',next6 )
         
         next4 = cidr4.next_ip(:Bitstep => 2)
@@ -81,8 +81,8 @@ class TestCIDR < Test::Unit::TestCase
         assert_equal('192.168.2.1',next4 )
         assert_equal('fec0:0000:0000:0001:0000:0000:0000:0001',next6 )
         
-        next4 = cidr4.next_ip(:Objectify => 1)
-        next6 = cidr6.next_ip(:Objectify => 1)
+        next4 = cidr4.next_ip(:Objectify => true)
+        next6 = cidr6.next_ip(:Objectify => true)
         assert_equal('192.168.2.0/32',next4.desc )
         assert_equal('fec0:0000:0000:0001:0000:0000:0000:0000/128',next6.desc )
         
@@ -97,7 +97,7 @@ class TestCIDR < Test::Unit::TestCase
         assert_equal('192.168.2.0/24',next4 )
         assert_equal('fec0:0000:0000:0001:0000:0000:0000:0000/64',next6 )
         
-        next6 = cidr6.next_subnet(:Short => 1)
+        next6 = cidr6.next_subnet(:Short => true)
         assert_equal('fec0:0:0:1::/64',next6 )
         
         next4 = cidr4.next_subnet(:Bitstep => 2)
@@ -105,8 +105,8 @@ class TestCIDR < Test::Unit::TestCase
         assert_equal('192.168.3.0/24',next4 )
         assert_equal('fec0:0000:0000:0002:0000:0000:0000:0000/64',next6 )
         
-        next4 = cidr4.next_subnet(:Objectify => 1)
-        next6 = cidr6.next_subnet(:Objectify => 1)
+        next4 = cidr4.next_subnet(:Objectify => true)
+        next6 = cidr6.next_subnet(:Objectify => true)
         assert_equal('192.168.2.0/24',next4.desc )
         assert_equal('fec0:0000:0000:0001:0000:0000:0000:0000/64',next6.desc )
         
@@ -117,7 +117,7 @@ class TestCIDR < Test::Unit::TestCase
         cidr6 = IPAdmin::CIDR.new(:CIDR => 'fec0::/64')
         
         range4 = cidr4.range(:Indexes => [25,0], :Bitstep => 5)
-        range6 = cidr6.range(:Indexes => [25,0], :Bitstep => 5, :Short => 1)
+        range6 = cidr6.range(:Indexes => [25,0], :Bitstep => 5, :Short => true)
         
         assert_equal(6,range4.length)
         assert_equal(6,range6.length)
@@ -135,7 +135,7 @@ class TestCIDR < Test::Unit::TestCase
         assert_equal(2,remainder.length)
         assert_equal('192.168.1.0/26',remainder[0])
         
-        remainder = cidr4.remainder(:Exclude => cidr4_2, :Objectify => 1)
+        remainder = cidr4.remainder(:Exclude => cidr4_2, :Objectify => true)
         assert_equal('192.168.1.128/25',remainder[1].desc)
     end
     
@@ -146,7 +146,7 @@ class TestCIDR < Test::Unit::TestCase
         new4 = cidr4.resize(:Subnet => 23)
         new6 = cidr6.resize(:Subnet => 63)
         assert_equal('192.168.0.0/23',new4.desc )
-        assert_equal('fec0::/63',new6.desc(:Short => 1) )
+        assert_equal('fec0::/63',new6.desc(:Short => true) )
         
         cidr4.resize!(:Subnet => 25)
         cidr6.resize!(:Subnet => 67)
@@ -164,7 +164,7 @@ class TestCIDR < Test::Unit::TestCase
         assert_equal('192.168.1.0/24',cidr4.desc() )
         assert_equal('fec0:0000:0000:0000:0000:0000:0000:0000/64',cidr6.desc() )
         
-        assert_equal('fec0::/64',cidr6.desc(:Short => 1) )
+        assert_equal('fec0::/64',cidr6.desc(:Short => true) )
         
         assert_equal('0.0.0.255',cidr4.hostmask_ext() )        
         
@@ -173,11 +173,11 @@ class TestCIDR < Test::Unit::TestCase
         
         assert_equal('192.168.1.1',cidr4.ip() )
         assert_equal('fec0:0000:0000:0000:0000:0000:0000:0001',cidr6.ip() )
-        assert_equal('fec0::1',cidr6.ip(:Short => 1) )
+        assert_equal('fec0::1',cidr6.ip(:Short => true) )
         
         assert_equal('192.168.1.255',cidr4.last() )
         assert_equal('fec0:0000:0000:0000:ffff:ffff:ffff:ffff',cidr6.last() )
-        assert_equal('fec0::ffff:ffff:ffff:ffff',cidr6.last(:Short => 1) )
+        assert_equal('fec0::ffff:ffff:ffff:ffff',cidr6.last(:Short => true) )
         
         assert_equal('/24',cidr4.netmask() )
         assert_equal('/64',cidr6.netmask() )
@@ -186,7 +186,7 @@ class TestCIDR < Test::Unit::TestCase
         
         assert_equal('192.168.1.0',cidr4.network() )
         assert_equal('fec0:0000:0000:0000:0000:0000:0000:0000',cidr6.network() )
-        assert_equal('fec0::',cidr6.network(:Short => 1) )
+        assert_equal('fec0::',cidr6.network(:Short => true) )
         
         assert_equal(256,cidr4.size() )
         assert_equal(2**64,cidr6.size() )       
@@ -206,7 +206,7 @@ class TestCIDR < Test::Unit::TestCase
         assert_equal('192.168.1.64/26', subnet4[1])
         assert_equal('192.168.1.128/25', subnet4[2])
         
-        subnet4 = cidr4.subnet(:Subnet => 28, :MinCount => 3, :Objectify => 1)
+        subnet4 = cidr4.subnet(:Subnet => 28, :MinCount => 3, :Objectify => true)
         assert_equal('192.168.1.0/28', subnet4[0].desc)
         assert_equal('192.168.1.16/28', subnet4[1].desc)
         assert_equal('192.168.1.32/28', subnet4[2].desc)

data/tests/{functions_test.rb → methods_test.rb}

@@ -5,7 +5,7 @@ require 'test/unit'
 
 
 
-class TestFunct < Test::Unit::TestCase
+class TestMethods < Test::Unit::TestCase
 
     def test_pack_ipv4_addr
         assert_equal(2**32-1, IPAdmin.pack_ipv4_addr('255.255.255.255') )
@@ -184,7 +184,12 @@ class TestFunct < Test::Unit::TestCase
         assert_equal('fec0::', IPAdmin.shorten('fec0:0000:0000:0000:0000:0000:0000:0000') )
         assert_equal('fec0::2:0:0:1', IPAdmin.shorten('fec0:0000:0000:0000:0002:0000:0000:0001') )
         assert_equal('fec0::2:0:0:1', IPAdmin.shorten('fec0:00:0000:0:02:0000:0:1') )
-        assert_raise(RuntimeError){ IPAdmin.shorten('fec0::') }   
+        assert_equal('fec0::2:2:0:0:1', IPAdmin.shorten('fec0:0000:0000:0002:0002:0000:0000:0001') )
+        assert_equal('fec0:0:0:1::', IPAdmin.shorten('fec0:0000:0000:0001:0000:0000:0000:0000') )
+        assert_equal('fec0:1:1:1:1:1:1:1', IPAdmin.shorten('fec0:0001:0001:0001:0001:0001:0001:0001') )
+        assert_equal('fec0:ffff:ffff:0:ffff:ffff:ffff:ffff', IPAdmin.shorten('fec0:ffff:ffff:0000:ffff:ffff:ffff:ffff') )
+        assert_equal('fec0:ffff:ffff:ffff:ffff:ffff:ffff:ffff', IPAdmin.shorten('fec0:ffff:ffff:ffff:ffff:ffff:ffff:ffff') )
+        assert_equal('fec0::', IPAdmin.shorten('fec0::') )   
     end
     
     def test_unshorten        
@@ -246,7 +251,7 @@ class TestFunct < Test::Unit::TestCase
                  IPAdmin::CIDR.new(:CIDR => 'fec0::2/127')]
         
         merge4 = IPAdmin.merge(:List => cidr4)
-        merge4_2 = IPAdmin.merge(:List => cidr4_2, :Objectify => 1)
+        merge4_2 = IPAdmin.merge(:List => cidr4_2, :Objectify => true)
         merge6 = IPAdmin.merge(:List => cidr6)
 
         assert_equal(5, merge4.length)

data/tests/tree_test.rb

@@ -182,9 +182,9 @@ class TestTree < Test::Unit::TestCase
         tree6.add(cidr6_1)
         tree6.add(cidr6_2)
         
-        assert_equal(1, tree4.exists?(cidr4_1))
-        assert_equal(1, tree6.exists?(cidr6_2))
-        assert_nil(tree4.exists?(cidr4_3))      
+        assert_equal(true, tree4.exists?(cidr4_1))
+        assert_equal(true, tree6.exists?(cidr6_2))
+        assert_equal(false, tree4.exists?(cidr4_3))      
         
     end    
     

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: ipadmin
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
-date: 2006-02-21 00:00:00 -06:00
+  version: 0.2.1
+date: 2006-03-08 00:00:00 -06:00
 summary: A package for manipulating IPv4/IPv6 address space.
 require_paths: 
   - lib
@@ -32,9 +32,9 @@ files:
   - lib/ip_admin.rb
   - README
 test_files: 
-  - tests/functions_test.rb
-  - tests/cidr_test.rb
+  - tests/methods_test.rb
   - tests/tree_test.rb
+  - tests/cidr_test.rb
 rdoc_options: []
 extra_rdoc_files: 
   - README