netaddr 1.5.0 → 1.5.3

data/lib/cidr_shortcuts.rb

@@ -3,10 +3,6 @@ private
 
 # CIDR METHODS
 
-#==============================================================================#
-# cidr_build()
-#==============================================================================#
-
 # create either a CIDRv4 or CIDRv6 object
 #
 def cidr_build(version, ip, netmask=nil, tag={}, wildcard_mask=nil, wildcard_mask_bit_flipped=false)
@@ -15,9 +11,6 @@ def cidr_build(version, ip, netmask=nil, tag={}, wildcard_mask=nil, wildcard_mas
 end
 module_function :cidr_build
 
-#==============================================================================#
-# cidr_compare()
-#==============================================================================#
 
 # compare 2 CIDR objects
 #
@@ -52,10 +45,6 @@ def cidr_compare(cidr1,cidr2)
 end
 module_function :cidr_compare
 
-#==============================================================================#
-# cidr_gt_lt()
-#==============================================================================#
-
 # given a pair of CIDRs, determine if first is greater than or less than the second
 #
 # return 1 if cidr1 > cidr2
@@ -78,10 +67,6 @@ def cidr_gt_lt(cidr1,cidr2)
 end
 module_function :cidr_gt_lt
 
-#==============================================================================#
-# cidr_fill_in()
-#==============================================================================#
-
 #Given a list of subnets of supernet, return a new list with any
 #holes (missing subnets) filled in.
 #
@@ -120,10 +105,6 @@ def cidr_fill_in(supernet,list)
 end
 module_function :cidr_fill_in
 
-#==============================================================================#
-# cidr_find_in_list()
-#==============================================================================#
-
 # evaluate cidr against list of cidrs.
 #
 # return entry from list if entry is supernet of cidr (first matching entry)
@@ -159,10 +140,6 @@ def cidr_find_in_list(cidr,list)
 end
 module_function :cidr_find_in_list
 
-#==============================================================================#
-# cidr_make_subnets_from_base_and_ip_count()
-#==============================================================================#
-
 # Make CIDR addresses from a base addr and an number of ip's to encapsulate.
 #
 #===Arguments:
@@ -204,10 +181,6 @@ module_function :cidr_find_in_list
     end
 module_function :cidr_make_subnets_from_base_and_ip_count
 
-#==============================================================================#
-# cidr_sort()
-#==============================================================================#
-
 # given a list of NetAddr::CIDRs, return them as a sorted list
 #
 def cidr_sort(list, desc=false)
@@ -258,10 +231,6 @@ def cidr_sort(list, desc=false)
 end
 module_function :cidr_sort
 
-#==============================================================================#
-# cidr_summarize()
-#==============================================================================#
-
 # given a list of NetAddr::CIDRs (of the same version) summarize them
 #
 # return a hash, with the key = summary address and val = array of original cidrs
@@ -322,7 +291,7 @@ def cidr_summarize(subnet_list)
         until (index >= summarized_list.length)
             subnet = summarized_list[index]
             if (subnet &&  cidr_compare(supernet,subnet) == 1 )
-                subnet_list[index] = nil
+                unique_list.delete(subnet.desc)
             end
             index += 1
         end
@@ -347,10 +316,6 @@ def cidr_summarize(subnet_list)
 end
 module_function :cidr_summarize
 
-#==============================================================================#
-# cidr_supernets()
-#==============================================================================#
-
 # given a list of NetAddr::CIDRs (of the same version), return only the 'top level' blocks (i.e. blocks not
 # contained by other blocks
 
@@ -376,10 +341,6 @@ def cidr_supernets(subnet_list)
 end
 module_function :cidr_supernets
 
-#==============================================================================#
-# netmask_sort()
-#==============================================================================#
-
 # given a list of NetAddr::CIDRs, return them as a sorted (by netmask) list
 #
 def netmask_sort(list, desc=false)

data/lib/eui.rb

@@ -1,9 +1,3 @@
-=begin rdoc
- Copyleft (c) 2006 Dustin Spinhirne
-
- Licensed under the same terms as Ruby, No Warranty is provided.
-=end
-
 module NetAddr
 
 #=EUI - Extended Unique Identifier
@@ -27,10 +21,6 @@ class EUI
 
 private_class_method :new
 
-#==============================================================================#
-# initialize()
-#==============================================================================#
-
 #===Synopsis
 # This method performs absolutely no error checking, and is meant to be used only by
 # other internal methods for the sake of the speedier creation of EUI objects.
@@ -71,10 +61,6 @@ private_class_method :new
 
     end
 
-#==============================================================================#
-# create()
-#==============================================================================#
-
 #===Synopsis
 #Create a new EUI48 or EUI64 object.
 #
@@ -95,7 +81,8 @@ private_class_method :new
             raise ArgumentError, "Expected String, but #{eui.class} provided."
         end
 
-        # validate
+        # create local copy & validate
+        eui = eui.dup
         NetAddr.validate_eui(eui)
 
         # remove formatting characters
@@ -110,10 +97,6 @@ private_class_method :new
         return(eui)
     end
 
-#==============================================================================#
-# address()
-#==============================================================================#
-
 #===Synopsis
 # Returns EUI address. The default address format is xxxx.xxxx.xxxx
 #
@@ -148,28 +131,12 @@ private_class_method :new
         if (delimiter == '-' || delimiter == ':')
             addr = octets.join(delimiter)
         elsif (delimiter == '.')
-                toggle = 0
-                octets.each do |x|
-                    if (!addr)
-                        addr = x
-                        toggle = 1
-                    elsif (toggle == 0)
-                        addr = addr  << '.' << x
-                        toggle = 1
-                    else
-                        addr = addr << x
-                        toggle = 0
-                    end
-                end
+            addr = octets.each_slice(2).to_a.map(&:join).join('.')
         end
 
         return(addr)
     end
 
-#==============================================================================#
-# ei()
-#==============================================================================#
-
 #===Synopsis
 #Returns Extended Identifier portion of an EUI address (the vendor assigned ID).
 #The default address format is xx-xx-xx
@@ -211,10 +178,6 @@ private_class_method :new
         return(ei)
     end
 
-#==============================================================================#
-# link_local()
-#==============================================================================#
-
 #===Synopsis
 # Provide an IPv6 Link Local address based on the current EUI address.
 #
@@ -234,10 +197,6 @@ private_class_method :new
         return( self.to_ipv6('fe80::/64', options) )
     end
 
-#==============================================================================#
-# oui()
-#==============================================================================#
-
 #===Synopsis
 #Returns Organizationally Unique Identifier portion of an EUI address (the vendor ID).
 #The default address format is xx-xx-xx.
@@ -274,10 +233,6 @@ private_class_method :new
         return(oui)
     end
 
-#==============================================================================#
-# to_i()
-#==============================================================================#
-
 #===Synopsis
 #Returns the EUI as an Integer.
 #
@@ -295,10 +250,6 @@ private_class_method :new
         return(@eui_i)
     end
 
-#==============================================================================#
-# to_ipv6
-#==============================================================================#
-
 #===Synopsis
 # Given a valid IPv6 subnet, return an IPv6 address based on the current EUI.
 #
@@ -371,10 +322,6 @@ private_class_method :new
         return(ipv6)
     end
 
-#==============================================================================#
-# to_s()
-#==============================================================================#
-
 #===Synopsis
 #Returns the EUI as an unformatted String.
 #
@@ -394,10 +341,6 @@ private_class_method :new
 
 private
 
-#==============================================================================#
-# octets()
-#==============================================================================#
-
 #Returns array with each element representing a single octet of the eui.
 #
     def octets()
@@ -426,10 +369,6 @@ class EUI48 < EUI
 
     public_class_method :new
 
-#==============================================================================#
-# to_eui64()
-#==============================================================================#
-
 #===Synopsis
 #Return an EUI64 address based on the current EUI48 address.
 #

data/lib/ip_math.rb

@@ -4,10 +4,6 @@ private
 
 # IP MATH METHODS
 
-#==============================================================================#
-# binary_mirror()
-#==============================================================================#
-
 # given an integer and number of bits to consider, return its binary mirror
 #
 def binary_mirror(num, bit_count)
@@ -22,10 +18,6 @@ def binary_mirror(num, bit_count)
 end
 module_function :binary_mirror
 
-#==============================================================================#
-# bits_to_mask()
-#==============================================================================#
-
 # convert a netmask (in bits) to an integer mask
 #
 def bits_to_mask(netmask,version)
@@ -36,10 +28,6 @@ def bits_to_mask(netmask,version)
 end
 module_function :bits_to_mask
 
-#==============================================================================#
-# detect_ip_version()
-#==============================================================================#
-
 # determine the ip version from ip address string.
 #
 # return 4, 6, or nil
@@ -57,10 +45,6 @@ def detect_ip_version(ip)
 end
 module_function :detect_ip_version
 
-#==============================================================================#
-# ip_count_to_size()
-#==============================================================================#
-
 # given an ip count, determine the most appropriate mask (in bits)
 #
 def ip_count_to_size(ipcount,version,extended=false)
@@ -83,10 +67,6 @@ def ip_count_to_size(ipcount,version,extended=false)
 end
 module_function :ip_count_to_size
 
-#==============================================================================#
-# ip_int_to_str()
-#==============================================================================#
-
 # unpack an int into an ip address string
 #
 def ip_int_to_str(ip_int, version, ipv4_mapped=nil)
@@ -129,10 +109,6 @@ def ip_int_to_str(ip_int, version, ipv4_mapped=nil)
 end
 module_function :ip_int_to_str
 
-#==============================================================================#
-# ip_str_to_int()
-#==============================================================================#
-
 # convert an ip string into an int
 #
 def ip_str_to_int(ip,version)
@@ -197,10 +173,6 @@ def ip_str_to_int(ip,version)
 end
 module_function :ip_str_to_int
 
-#==============================================================================#
-# mask_to_bits()
-#==============================================================================#
-
 # convert integer into a cidr formatted netmask (bits)
 #
 def mask_to_bits(netmask_int)
@@ -226,10 +198,6 @@ def mask_to_bits(netmask_int)
 end
 module_function :mask_to_bits
 
-#==============================================================================#
-# netmask_str_to_int()
-#==============================================================================#
-
 # convert string into integer mask
 #
 def netmask_str_to_int(netmask,version)

data/lib/methods.rb

@@ -1,15 +1,5 @@
-=begin rdoc
- Copyleft (c) 2006 Dustin Spinhirne
-
- Licensed under the same terms as Ruby, No Warranty is provided.
-=end
-
 module NetAddr
 
-#==============================================================================#
-# i_to_bits()
-#==============================================================================#
-
 #===Synopsis
 #Convert an Integer representing a binary netmask into an Integer representing
 #the number of bits in that netmask.
@@ -35,10 +25,6 @@ def i_to_bits(netmask_int)
 end
 module_function :i_to_bits
 
-#==============================================================================#
-# i_to_ip()
-#==============================================================================#
-
 #===Synopsis
 #Convert an Integer into an IP address. This method will attempt to auto-detect the IP version
 #if not provided, however, a slight speed increase is realized if version is provided.
@@ -88,10 +74,6 @@ def i_to_ip(ip_int, options=nil)
 end
 module_function :i_to_ip
 
-#==============================================================================#
-# ip_to_i()
-#==============================================================================#
-
 #===Synopsis
 #Convert IP addresses into an Integer. This method will attempt to auto-detect the IP version
 #if not provided, however a slight speed increase is realized if version is provided.
@@ -141,10 +123,6 @@ def ip_to_i(ip, options=nil)
 end
 module_function :ip_to_i
 
-#==============================================================================#
-# merge()
-#==============================================================================#
-
 #===Synopsis
 #Given a list of CIDR addresses or NetAddr::CIDR objects,
 #merge (summarize) them in the most efficient way possible. Summarization 
@@ -253,10 +231,6 @@ def merge(list,options=nil)
 end
 module_function :merge
 
-#==============================================================================#
-# minimum_size()
-#==============================================================================#
-
 #===Synopsis
 #Given the number of IP addresses required in a subnet, return the minimum
 #netmask (bits by default) required for that subnet. IP version is assumed to be 4 unless specified otherwise.
@@ -301,10 +275,6 @@ def minimum_size(ipcount, options=nil)
 end
 module_function :minimum_size
 
-#==============================================================================#
-# netmask_to_i()
-#==============================================================================#
-
 #===Synopsis
 #Convert IP netmask into an Integer. Netmask may be in either CIDR (/yy) or
 #extended (y.y.y.y) format. CIDR formatted netmasks may either
@@ -361,10 +331,6 @@ def netmask_to_i(netmask, options=nil)
 end
 module_function :netmask_to_i
 
-#==============================================================================#
-# range()
-#==============================================================================#
-
 #===Synopsis
 #Given two CIDR addresses or NetAddr::CIDR objects of the same version,
 #return all IP addresses between them. NetAddr.range will use the original IP 
@@ -492,7 +458,7 @@ def range(lower, upper, options=nil)
 
             my_ip = my_ip + bitstep
             if (limit)
-                limit = limit -1
+                limit = limit - 1
                 break if (limit == 0)
             end
         end
@@ -504,10 +470,6 @@ def range(lower, upper, options=nil)
 end
 module_function :range
 
-#==============================================================================#
-# shorten()
-#==============================================================================#
-
 #===Synopsis
 #Take a standard IPv6 address and format it in short-hand notation.
 #The address should not contain a netmask.
@@ -596,10 +558,6 @@ def shorten(addr)
 end
 module_function :shorten
 
-#==============================================================================#
-# sort()
-#==============================================================================#
-
 #===Synopsis
 #Sort a list of CIDR addresses or NetAddr::CIDR objects,
 #
@@ -680,10 +638,6 @@ def sort(list, options=nil)
 end
 module_function :sort
 
-#==============================================================================#
-# supernets()
-#==============================================================================#
-
 #===Synopsis
 #Given a list of CIDR addresses or NetAddr::CIDR objects,
 #return only the top-level supernet CIDR addresses.
@@ -780,10 +734,6 @@ def supernets(list,options=nil)
 end
 module_function :supernets
 
-#==============================================================================#
-# unshorten()
-#==============================================================================#
-
 #===Synopsis
 #Take an IPv6 address in short-hand format, and expand it into standard
 #notation. The address should not contain a netmask.
@@ -818,10 +768,6 @@ def unshorten(ip)
 end
 module_function :unshorten
 
-#==============================================================================#
-# validate_eui()
-#==============================================================================#
-
 #===Synopsis
 #Validate an EUI-48 or EUI-64 address. Raises NetAddr::ValidationError on validation failure.
 #
@@ -871,10 +817,6 @@ def validate_eui(eui)
 end
 module_function :validate_eui
 
-#==============================================================================#
-# validate_ip_addr()
-#==============================================================================#
-
 #===Synopsis
 #Validate an IP address. The address should not contain a netmask.
 #This method will attempt to auto-detect the IP version
@@ -930,10 +872,6 @@ def validate_ip_addr(ip, options=nil)
 end
 module_function :validate_ip_addr
 
-#==============================================================================#
-# validate_ip_netmask()
-#==============================================================================#
-
 #===Synopsis
 #Validate IP Netmask. Version defaults to 4 if not specified.
 #Raises NetAddr::ValidationError on validation failure.
@@ -988,10 +926,6 @@ def validate_ip_netmask(netmask, options=nil)
 end
 module_function :validate_ip_netmask
 
-#==============================================================================#
-# wildcard()
-#==============================================================================#
-
 #===Synopsis
 #Convert a wildcard IP into a valid CIDR address. Wildcards must always be at
 #the end of the address. Any data located after the first wildcard will be lost.

data/lib/netaddr.rb

@@ -1,9 +1,3 @@
-=begin rdoc
- Copyleft (c) 2006 Dustin Spinhirne
-  
- Licensed under the same terms as Ruby, No Warranty is provided.
-=end
-
 require 'time'
 require 'digest/sha1'
 require File.join(File.dirname(__FILE__), 'validation_shortcuts.rb')
@@ -16,14 +10,14 @@ require File.join(File.dirname(__FILE__), 'eui.rb')
 
 module NetAddr
 
-class BoundaryError < StandardError #:nodoc:
-end
+  class BoundaryError < StandardError #:nodoc:
+  end
 
-class ValidationError < StandardError #:nodoc:
-end
+  class ValidationError < StandardError #:nodoc:
+  end
 
-class VersionError < StandardError #:nodoc:
-end
+  class VersionError < StandardError #:nodoc:
+  end
 
 end # module NetAddr