ipaddress_2 0.11.0 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 64e253cbf0ced3857087c448ed2308037465bb3ed59162c0b90348df5f3986c7
-  data.tar.gz: c2c11d0cf5e6a2811097e5365cf14f19d53052d98e5ba2abf7565ac24365b353
+  metadata.gz: 359df425a73931023ee0026c8fdb2819f43117e24e1aa24b5ff7bb3d7f6121f6
+  data.tar.gz: db06b07d89444432225af2e82529a0eca395cda6e42ed59bf0cf443befc914c8
 SHA512:
-  metadata.gz: 9f399ef081ca059f28e465e969f3b1f430a2eecd0d9b171d74b5d2191e9aee83cd09c5fb68fcda7d8d71457a5621803e33a67c19a700383f6e330ce4f772973e
-  data.tar.gz: acbced5a8b91d5c5da3b123d69d22a3d701e37f92365250f7328788749639bcca5559053ecf4019095b12e2d3b0b6c44d8f21b55cac3bcc856df8583102b9494
+  metadata.gz: b537db60dfaf772c2162d3c1f52c0066b0737af5811fa0ac1894aa86414ce86950f4bba00c8aa3c3a1c1171937de26848933020ce428f5b7df04611a08bcf19f
+  data.tar.gz: e2632e98d23618da97172f711d1736d7b6845105cb53412c42db5caa6326edc66b9e1f1ec2319f61855d1c54f3fa743df02cd653a6fd86f933b4f5d9944392f3

data/.travis.yml

@@ -4,6 +4,8 @@ rvm:
 - 2.4
 - 2.5
 - 2.6
+- 2.7
+- 3.0
 install:
 - gem install bundler
 - gem install rake

data/CHANGELOG.md

@@ -1,5 +1,31 @@
 ## [Unreleased]
 
+## 0.14.0
+
+### Enhancements
+* include? will now accept a string. Will also work for include_all?
+
+## 0.13.0
+
+### Enhancements
+* Provide arithmetic operations on IPv4 and IPv6
+
+## 0.12.1
+
+### Bugfix
+* Remove dup from IPv6 summarization to slightly improve performance
+
+## 0.12.0
+
+### Enhancements
+* Added 'last' to IPv6
+* Added 'broadcast' to IPv6
+
+## 0.11.1
+
+### Bugfix
+* Fix prefix change in find\_adjacent
+
 ## 0.11.0
 
 ### Enhancements
@@ -26,6 +52,6 @@
 ### Bugfix
 * Removed duplicate link_local? in IPv6
 
-Please check [CHANGELOG.rdoc](https://github.com/ipaddress2-gem/ipaddress2/blob/master/CHANGELOG.rdoc) for previous changes.
+Please check [CHANGELOG.rdoc](https://github.com/ipaddress2-gem/ipaddress_2/blob/master/CHANGELOG.rdoc) for previous changes.
 
 

data/README.rdoc

@@ -16,11 +16,11 @@ examples of typical usage.
 
 * Ruby 1.9.3 or later
 
-Please refer to {Travis CI}[https://travis-ci.org/ipaddress2-gem/ipaddress2] for Build Tests on specific versions of Ruby.
+Please refer to {Travis CI}[https://travis-ci.org/ipaddress2-gem/ipaddress_2] for Build Tests on specific versions of Ruby.
 
-{<img src="https://travis-ci.org/ipaddress2-gem/ipaddress2.svg?branch=master" alt="Build Status" />}[https://travis-ci.org/ipaddress2-gem/ipaddress2] {<img src="https://codeclimate.com/github/ipaddress2-gem/ipaddress2/badges/gpa.svg" />}[https://codeclimate.com/github/ipaddress2-gem/ipaddress2]
+{<img src="https://travis-ci.org/ipaddress2-gem/ipaddress_2.svg?branch=master" alt="Build Status" />}[https://travis-ci.org/ipaddress2-gem/ipaddress_2] {<img src="https://codeclimate.com/github/ipaddress2-gem/ipaddress_2/badges/gpa.svg" />}[https://codeclimate.com/github/ipaddress2-gem/ipaddress_2]
 
-If you want to contribute, please refer to {Contributing.md}[https://github.com/ipaddress2-gem/ipaddress2/blob/master/CONTRIBUTING.md].
+If you want to contribute, please refer to {Contributing.md}[https://github.com/ipaddress2-gem/ipaddress_2/blob/master/CONTRIBUTING.md].
 
 
 == Installation

data/VERSION

@@ -1 +1 @@
-0.11.0
+0.14.0

data/ipaddress_2.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |s|
   s.version = IPAddress::VERSION
   s.require_paths = ["lib"]
   s.authors = ["bluemonk", "mikemackintosh"]
-  s.description = "IPAddress2 is a Ruby library designed to make manipulation\n      of IPv4 and IPv6 addresses both powerful and simple. It mantains\n      a layer of compatibility with Ruby's own IPAddr, while\n      addressing many of its issues."
+  s.description = "IPAddress2 is a Ruby library designed to make manipulation\n      of IPv4 and IPv6 addresses both powerful and simple. It maintains\n      a layer of compatibility with Ruby's own IPAddr, while\n      addressing many of its issues."
   s.email = "adam@21eleven.com"
   s.extra_rdoc_files = [
     "CHANGELOG.rdoc",
@@ -17,7 +17,7 @@ Gem::Specification.new do |s|
     "README.rdoc"
   ]
   s.files = `git ls-files -z`.split("\x0")
-  s.homepage = "https://github.com/ipaddress2-gem/ipaddress2"
+  s.homepage = "https://github.com/ipaddress2-gem/ipaddress_2"
 
   s.add_development_dependency "bundler"
   s.add_development_dependency "rake"

data/lib/ipaddress_2/ipv4.rb

@@ -377,6 +377,18 @@ module IPAddress;
     def network
       self.class.parse_u32(network_u32, @prefix)
     end
+    
+    #
+    # Returns a new IPv4 object containing only the host part of this IP.
+    #
+    #   ip = IPAddress("172.16.10.64/24")
+    #
+    #   ip.hostpart.to_s
+    #     #=> "0.0.0.64"
+    #
+    def hostpart
+      self.class.parse_u32(hostpart_u32, 32)
+    end
 
     #
     # Returns a new IPv4 object with the
@@ -600,6 +612,18 @@ module IPAddress;
     def network_u32
       @u32 & @prefix.to_u32
     end
+    
+    #
+    # Returns this address' host part in unsigned 32bits format
+    #
+    #   ip = IPAddress("10.0.0.42/24")
+    #
+    #   ip.host_u32
+    #     #=> 42
+    #
+    def hostpart_u32
+      @u32 & ~@prefix.to_u32
+    end
 
     #
     # Returns the broadcast address in Unsigned 32bits format
@@ -616,7 +640,7 @@ module IPAddress;
     #
     # Checks whether a subnet includes the given IP address.
     #
-    # Accepts an IPAddress::IPv4 object.
+    # Accepts an IPAddress::IPv4 object or a string.
     #
     #   ip = IPAddress("192.168.10.100/24")
     #
@@ -628,13 +652,19 @@ module IPAddress;
     #   ip.include? IPAddress("172.16.0.48/16")
     #     #=> false
     #
+    #   ip.include? "192.168.10.50"
+    #     #=> true
+    #
     def include?(oth)
+      unless oth.is_a? IPAddress::IPv4
+        oth = IPv4.new(oth)
+      end
       @prefix <= oth.prefix and network_u32 == (oth.to_u32 & @prefix.to_u32)
     end
 
     #
     # Checks whether a subnet includes all the 
-    # given IPv4 objects.
+    # given IPv4 objects or strings.
     #
     #   ip = IPAddress("192.168.10.100/24")
     #
@@ -644,6 +674,9 @@ module IPAddress;
     #   ip.include_all?(addr1,addr2)
     #     #=> true
     #
+    #   ip.include_all?("192.168.10.102/24", "192.168.10.103/24")
+    #     #=> true
+    #
     def include_all?(*others)
       others.all? {|oth| include?(oth)}
     end
@@ -886,6 +919,97 @@ module IPAddress;
     def +(oth)
       aggregate(*[self,oth].sort.map{|i| i.network})
     end
+    
+    #
+    # Returns a new IPv4 object which is the result 
+    # of advancing this IP address by a given value.
+    # In other words, this arithmetically adds IP addresses.
+    #
+    # Will raise an error if the resulting address is in a different subnet,
+    # except validating is set to false.
+    #
+    # Example:
+    #
+    #   ip = IPAddress::IPv4.new("172.16.10.1/24")
+    #   ip.add(5).to_string
+    #     #=> "172.16.10.6/24"
+    def add(oth, validating=true)
+      oth = oth.to_i if oth.kind_of? IPAddress::IPv4 # oth shall be integer
+      
+      new_obj = self.class.parse_u32(self.to_i + oth, prefix)
+      
+      if validating and self.network_u32 != new_obj.network_u32
+        raise RuntimeError, "Subnet (/#{@prefix}) is not large enough."
+      end
+      
+      new_obj
+    end
+    
+    #
+    # Returns a new IPv4 object which is the result 
+    # of decreasing this IP address by a given value.
+    # In other words, this arithmetically subtracts IP addresses.
+    #
+    # Will raise an error if the resulting address is in a different subnet,
+    # except validating is set to false.
+    #
+    # Example:
+    #
+    #   ip = IPAddress::IPv4.new("172.16.10.10/24")
+    #   ip.subtract(5).to_string
+    #     #=> "172.16.10.5/24"
+    def subtract(oth, validating=true)
+      oth = oth.to_i if oth.kind_of? IPAddress::IPv4 # oth shall be integer
+      add(-oth, validating)
+    end
+    
+    #
+    # Returns the network address of the n-th network succeeding this one.
+    #
+    # Example:
+    #
+    #   ip = IPAddress::IPv4.new("172.16.10.0/24")
+    #   ip.advance_network(24).to_string
+    #     #=> "172.16.52.0/24"
+    def advance_network(amount)
+      IPAddress::IPv4.parse_u32(self.network.u32 + amount*self.size, @prefix)
+    end
+    
+    #
+    # Returns the network address of the network succeeding this one.
+    #
+    # Example:
+    #
+    #   ip = IPAddress::IPv4.new("172.16.10.0/24")
+    #   ip.next_network.to_string
+    #     #=> "172.16.11.0/24"
+    def next_network
+      advance_network 1
+    end
+    
+    #
+    # Returns the network address of the n-th network preceeding this one.
+    #
+    # Example:
+    #
+    #   ip = IPAddress::IPv4.new("172.16.10.0/24")
+    #   ip.regress_network(5).to_string
+    #     #=> "172.16.5.0/24"
+    def regress_network(amount)
+      advance_network(-amount)
+    end
+    
+    #
+    # Returns the network address of the network preceeding this one.
+    #
+    # Example:
+    #
+    #   ip = IPAddress::IPv4.new("172.16.10.0/24")
+    #   ip.previous_network.to_string
+    #     #=> "172.16.9.0/24"
+    def previous_network
+      regress_network 1
+    end
 
     #
     # Checks whether the ip address belongs to a 
@@ -1164,7 +1288,9 @@ module IPAddress;
       return false if prefix == 0
       current_subnet = to_string
       self.prefix = @prefix - 1
-      (split.map{|i| i.to_string} - [current_subnet])[0]
+      adjacent_subnet = (split.map{|i| i.to_string} - [current_subnet])[0]
+      self.prefix = @prefix + 1
+      return adjacent_subnet
     end
 
     #

data/lib/ipaddress_2/ipv6.rb

@@ -246,6 +246,63 @@ module IPAddress;
       to_u128 | @prefix.to_u128 == @prefix.to_u128
     end
 
+    #
+    # Returns a new IPv6 object with the
+    # first host IP address in the range.
+    # 
+    # Example: given the 2001:db8:8:800::/64 network, the first
+    # host IP address is 2001:db8:8:800::
+    #
+    #   ip = IPAddress("2001:db8:8:800::/64")
+    #
+    #   ip.first.to_s
+    #     #=> "2001:db8:8:800::"
+    #
+    # The object IP doesn't need to be a network: the method
+    # automatically gets the network number from it
+    #
+    #   ip = IPAddress("2001:db8:9:800::2/64")
+    #
+    #   ip.first.to_s
+    #     #=> "2001:db8:9:800::"
+    #
+    def first
+      if prefix == 128
+        return self
+      else
+        IPAddress::IPv6::parse_u128(network_u128)
+      end
+    end
+
+    #
+    # Like its sibling method IPv4#first, this method 
+    # returns a new IPv4 object with the 
+    # last host IP address in the range.
+    # 
+    # Example: given the 192.168.100.0/24 network, the last
+    # host IP address is 192.168.100.254
+    #
+    #   ip = IPAddress("2001:db8:8:800::/64")
+    #
+    #   ip.last.to_s
+    #     #=> "2001:db8:8:800:ffff:ffff:ffff:ffff"
+    #
+    # The object IP doesn't need to be a network: the method
+    # automatically gets the network number from it
+    #
+    #   ip = IPAddress("2001:db8:9:800::2/64")
+    #
+    #   ip.last.to_s
+    #     #=> "2001:db8:9:800:ffff:ffff:ffff:ffff"
+    #
+    def last
+      if prefix == 128
+        return self
+      else
+        IPAddress::IPv6::parse_u128(broadcast_u128)
+      end
+    end
+
     #
     # Returns the 16-bits value specified by index
     #
@@ -337,8 +394,110 @@ module IPAddress;
       to_hex.reverse.gsub(/./){|c| c+"."} + "ip6.arpa"
     end
     alias_method :arpa, :reverse
+    
+    #
+    # Returns a new IPv6 object which is the result 
+    # of advancing this IP address by a given value.
+    # In other words, this arithmetically adds IP addresses.
+    #
+    # Will raise an error if the resulting address is in a different subnet,
+    # except validating is set to false.
+    #
+    # Example:
+    #
+    #   ip = IPAddress::IPv6.new("fc42:1337::/64")
+    #   ip.add(5).to_string
+    #     #=> "fc42:1337::5/64"
+    def add(oth, validating=true)
+      oth = oth.to_i if oth.kind_of? IPAddress::IPv6 # oth shall be integer
+      
+      new_obj = self.class.parse_u128(self.to_i + oth, prefix)
+      
+      if validating and self.network_u128 != new_obj.network_u128
+        raise RuntimeError, "Subnet (/#{@prefix}) is not large enough."
+      end
+      
+      new_obj
+    end
+    
+    #
+    # Returns a new IPv6 object which is the result 
+    # of decreasing this IP address by a given value.
+    # In other words, this arithmetically subtracts IP addresses.
+    #
+    # Will raise an error if the resulting address is in a different subnet,
+    # except validating is set to false.
+    #
+    # Example:
+    #
+    #   ip = IPAddress::IPv6.new("fc42:1337::a/64")
+    #   ip.subtract(5).to_string
+    #     #=> "fc42:1337::5/64"
+    def subtract(oth, validating=true)
+      oth = oth.to_i if oth.kind_of? IPAddress::IPv6 # oth shall be integer
+      add(-oth, validating)
+    end
 
     #
+    # Returns the network address of the n-th network succeeding this one.
+    #
+    # Example:
+    #
+    #   ip = IPAddress::IPv6.new("fc42:1337:0:0::/64")
+    #   ip.advance_network(5).to_string
+    #     #=> "fc42:1337:0:5::/64"
+    def advance_network(amount)
+      IPAddress::IPv6.parse_u128(self.network.to_i + amount*self.size, @prefix)
+    end
+    
+    #
+    # Returns the network address of the network succeeding this one.
+    #
+    # Example:
+    #
+    #   ip = IPAddress::IPv6.new("fc42:1337:0:0::/64")
+    #   ip.next_network.to_string
+    #     #=> "fc42:1337:0:1::/64"
+    def next_network
+      advance_network 1
+    end
+    
+    #
+    # Returns the network address of the n-th network preceeding this one.
+    #
+    # Example:
+    #
+    #   ip = IPAddress::IPv6.new("fc42:1337:0:5::/64")
+    #   ip.regress_network(4).to_string
+    #     #=> "fc42:1337:0:1::/64"
+    def regress_network(amount)
+      advance_network(-amount)
+    end
+    
+    #
+    # Returns the network address of the network preceeding this one.
+    #
+    # Example:
+    #
+    #   ip = IPAddress::IPv6.new("fc42:1337:0:5::/64")
+    #   ip.previous_network.to_string
+    #     #=> "fc42:1337:0:4::/64"
+    def previous_network
+      regress_network 1
+    end
+    
+    #
+    # Returns a new IPv6 object containing only the host part of this IP.
+    #
+    #   ip = IPAddress::IPv6.new("fc42:1337:0:5::7/64")
+    #
+    #   ip.hostpart.to_s
+    #     #=> "::7"
+    #
+    def hostpart
+      self.class.parse_u128(hostpart_u128, 128)
+    end
+    
     # Splits a network into different subnets
     #
     # NOTE: Will allow you to split past /64 against RFC 5375
@@ -396,6 +555,18 @@ module IPAddress;
     def network_u128
       to_u128 & @prefix.to_u128
     end
+    
+    #
+    # Returns this address' host part in unsigned 128bits format
+    #
+    #   ip = IPAddress::IPv6.new("fc42:1337:0:5::7/64")
+    #
+    #   ip.host_u128
+    #     #=> 7
+    #
+    def hostpart_u128
+      to_u128 & ~@prefix.to_u128
+    end
 
     #
     # Returns the broadcast address in Unsigned 128bits format
@@ -441,13 +612,19 @@ module IPAddress;
     #   ip6.include? IPAddress("2001:db8:1::8:800:200c:417a/76")
     #     #=> false
     #
+    #   ip6.include? "2001:db8::8:800:200c:1"
+    #     #=> true
+    #
     def include?(oth)
+      unless oth.is_a? IPAddress::IPv6
+        oth = IPv6.new(oth)
+      end
       @prefix <= oth.prefix and network_u128 == self.class.new(oth.address+"/#@prefix").network_u128
     end
 
     #
     # Checks whether a subnet includes all the
-    # given IPv4 objects.
+    # given IPv4 objects or strings.
     #
     #   ip = IPAddress("2001:db8:8:800::1/64")
     #
@@ -457,6 +634,9 @@ module IPAddress;
     #   ip.include_all?(addr1,addr2)
     #     #=> true
     #
+    #   ip.include_all?("2001:db8:8:800::2/64", "2001:db8:8:800::8/64")
+    #     #=> true
+    #
     def include_all?(*others)
       others.all? {|oth| include?(oth)}
     end
@@ -771,6 +951,23 @@ module IPAddress;
       self.class.parse_u128(network_u128, @prefix)
     end
 
+    #
+    # Returns the broadcast address for the given IP.
+    # As this is IPv6 it is just the last IP
+    #
+    #   ip = IPAddress("2001:db8:8:800::/64")
+    #
+    #   ip.broadcast.to_s
+    #     #=> "2001:db8:8:800::"
+    #
+    def broadcast
+      if prefix == 128
+        return self
+      else
+        IPAddress::IPv6::parse_u128(broadcast_u128)
+      end
+    end
+
     #
     # Extract 16 bits groups from a string
     #
@@ -915,9 +1112,10 @@ module IPAddress;
     def self.summarize(*args)
       # one network? no need to summarize
       return [args.first.network] if args.size == 1
+      args_size = args.size 
 
       i = 0
-      result = args.dup.sort.map{|ip| ip.network}
+      result = args.sort.map{|ip| ip.network}
       while i < result.size-1
         sum = result[i] + result[i+1]
         result[i..i+1] = sum.first if sum.size == 1
@@ -925,7 +1123,7 @@ module IPAddress;
       end
 
       result.flatten!
-      if result.size == args.size
+      if result.size == args_size
         # nothing more to summarize
         return result
       else
@@ -977,7 +1175,9 @@ module IPAddress;
       return false if prefix == 0
       current_subnet = to_string
       self.prefix = @prefix - 1
-      (split.map{|i| i.to_string} - [current_subnet])[0]
+      adjacent_subnet = (split.map{|i| i.to_string} - [current_subnet])[0]
+      self.prefix = @prefix + 1
+      return adjacent_subnet
     end
 
     private

data/lib/ipaddress_2/version.rb

@@ -1,3 +1,3 @@
 module IPAddress
-  VERSION = "0.11.0"
+  VERSION = "0.14.0"
 end

data/test/ipaddress_2/ipv4_test.rb

@@ -327,7 +327,10 @@ class IPv4Test < Minitest::Test
     assert_equal false, ip.include?(@klass.new("5.5.5.5/32"))
     assert_equal false, ip.include?(@klass.new("11.0.0.0/8"))
     ip = @klass.new("13.13.0.0/13")
-    assert_equal false, ip.include?(@klass.new("13.16.0.0/32"))    
+    assert_equal false, ip.include?(@klass.new("13.16.0.0/32"))
+    ip = @klass.new("10.10.10.0/24")
+    assert_equal true, ip.include?("10.10.10.100")
+    assert_equal false, ip.include?("10.10.9.100")
   end
 
   def test_method_include_all?
@@ -336,6 +339,8 @@ class IPv4Test < Minitest::Test
     addr2 = @klass.new("192.168.10.103/24")    
     assert_equal true, ip.include_all?(addr1,addr2)
     assert_equal false, ip.include_all?(addr1, @klass.new("13.16.0.0/32"))
+    assert_equal true, ip.include_all?("192.168.10.102/24", "192.168.10.103/24")
+    assert_equal false, ip.include_all?(addr1, "13.16.0.0/32")
   end
 
   def test_method_ipv4?
@@ -455,7 +460,7 @@ class IPv4Test < Minitest::Test
 
     ip2 = @klass.new("172.16.12.2/24")
     assert_equal [ip1.network.to_string, ip2.network.to_string], 
-    (ip1 + ip2).map{|i| i.to_string}
+                 (ip1 + ip2).map{|i| i.to_string}
 
     ip1 = @klass.new("10.0.0.0/23")
     ip2 = @klass.new("10.0.2.0/24")
@@ -533,6 +538,57 @@ class IPv4Test < Minitest::Test
     assert_equal "172.16.8.0/22", @ip.supernet(22).to_string
   end
 
+  def test_method_add
+    ip = IPAddress::IPv4.new("172.16.10.1/24")
+    assert_equal ip.add(5), IPAddress::IPv4.new("172.16.10.6/24")
+    assert_equal ip.add(IPAddress::IPv4.new("0.0.0.5/6")), IPAddress::IPv4.new("172.16.10.6/24")
+    assert_equal ip.add(50), IPAddress::IPv4.new("172.16.10.51/24")
+    assert_equal ip.add(254), IPAddress::IPv4.new("172.16.10.255/24")
+    assert_raises(RuntimeError) {ip.add(255)}
+    assert_equal ip.add(255, false), IPAddress::IPv4.new("172.16.11.0/24")
+    assert_raises(RuntimeError) {ip.add(1000)}
+    ip = IPAddress::IPv4.new("172.16.10.1/30")
+    assert_equal ip.add(2), IPAddress::IPv4.new("172.16.10.3/30")
+    assert_raises(RuntimeError) {ip.add(3)}
+  end
+
+  def test_method_subtract
+    ip = IPAddress::IPv4.new("172.16.10.10/24")
+    assert_equal ip.subtract(5), IPAddress::IPv4.new("172.16.10.5/24")
+    assert_equal ip.subtract(IPAddress::IPv4.new("0.0.0.5/32")), IPAddress::IPv4.new("172.16.10.5/24")
+    assert_equal ip.subtract(10), IPAddress::IPv4.new("172.16.10.0/24")
+    assert_raises(RuntimeError) {ip.subtract(11)}
+    assert_equal ip.subtract(11, false), IPAddress::IPv4.new("172.16.9.255/24")
+    assert_raises(RuntimeError) {ip.subtract(IPAddress::IPv4.new("0.0.0.11/16"))}
+  end
+  
+  def test_method_hostpart
+    ip = IPAddress::IPv4.new("172.16.10.64/24")
+    assert_equal ip.hostpart.to_s, "0.0.0.64"
+    ip = IPAddress::IPv4.new("172.16.10.130/25")
+    assert_equal ip.hostpart.to_s, "0.0.0.2"
+  end
+  
+  def test_method_advance_network
+    ip = IPAddress::IPv4.new("172.16.10.64/24")
+    assert_equal ip.advance_network(42), IPAddress::IPv4.new("172.16.52.0/24")
+  end
+
+  def test_method_next_network
+    ip = IPAddress::IPv4.new("172.16.10.64/24")
+    assert_equal ip.next_network, IPAddress::IPv4.new("172.16.11.0/24")
+  end
+  
+  def test_method_regress_network
+    ip = IPAddress::IPv4.new("172.16.10.64/24")
+    assert_equal ip.regress_network(5), IPAddress::IPv4.new("172.16.5.0/24")
+  end
+  
+  def test_method_previous_network
+    ip = IPAddress::IPv4.new("172.16.10.64/24")
+    assert_equal ip.previous_network, IPAddress::IPv4.new("172.16.9.0/24")
+  end  
+  
   def test_classmethod_parse_u32
     @decimal_values.each do  |addr,int|
       ip = @klass.parse_u32(int)
@@ -689,6 +745,7 @@ class IPv4Test < Minitest::Test
   def test_finds_adjacent_subnet
     ip = @klass.new("10.0.0.0/24")
     assert_equal "10.0.1.0/24", ip.find_adjacent_subnet
+    assert_equal 24, ip.prefix
     refute @klass.new("10.0.0.0/0").find_adjacent_subnet 
     assert_equal "10.0.0.0/8", @klass.new("11.0.0.0/8").find_adjacent_subnet 
     assert_equal "172.16.0.0/16", @klass.new("172.17.0.0/16").find_adjacent_subnet 

data/test/ipaddress_2/ipv6_test.rb

@@ -128,6 +128,36 @@ class IPv6Test < Minitest::Test
     assert_equal bits, @ip.bits
   end
 
+  def test_method_first
+    ip = @klass.new("2001:db8:8:800::/64")
+    assert_instance_of @klass, ip.first
+    assert_equal "2001:db8:8:800::", ip.first.to_s
+    ip = @klass.new("2001:db8:8::/48")
+    assert_instance_of @klass, ip.first
+    assert_equal "2001:db8:8::", ip.first.to_s
+    ip = @klass.new("2001:db8::/32")
+    assert_instance_of @klass, ip.first
+    assert_equal "2001:db8::", ip.first.to_s
+    ip = @klass.new("2001:db8::8:800:200c:417a/64")
+    assert_instance_of @klass, ip.first
+    assert_equal "2001:db8::", ip.first.to_s
+  end
+
+  def test_method_last
+    ip = @klass.new("2001:db8:8:800::/64")
+    assert_instance_of @klass, ip.last
+    assert_equal  "2001:db8:8:800:ffff:ffff:ffff:ffff", ip.last.to_s
+    ip = @klass.new("2001:db8:8::/48")
+    assert_instance_of @klass, ip.last
+    assert_equal "2001:db8:8:ffff:ffff:ffff:ffff:ffff", ip.last.to_s
+    ip = @klass.new("2001:db8::/32")
+    assert_instance_of @klass, ip.last
+    assert_equal "2001:db8:ffff:ffff:ffff:ffff:ffff:ffff", ip.last.to_s
+    ip = @klass.new("2001:db8::8:800:200c:417a/64")
+    assert_instance_of @klass, ip.last
+    assert_equal  "2001:db8::ffff:ffff:ffff:ffff", ip.last.to_s
+  end
+
   def test_method_prefix=()
     ip = @klass.new "2001:db8::8:800:200c:417a"
     assert_equal 128, ip.prefix
@@ -322,6 +352,9 @@ class IPv6Test < Minitest::Test
     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)
+    # string test
+    assert_equal true, @ip.include?("2001:db8::8:800:200c:2")
+    assert_equal false, @ip.include?("2001:db8:1::8:800:200c:417a")
   end
 
   def test_method_include_all?
@@ -330,6 +363,8 @@ class IPv6Test < Minitest::Test
     addr2 = @klass.new("2001:db8:8:800::8/64")
     assert_equal true, ip.include_all?(addr1,addr2)
     assert_equal false, ip.include_all?(addr1, @klass.new("2002:db8:8:800::2/64"))
+    assert_equal true, ip.include_all?("2001:db8:8:800::2/64", "2001:db8:8:800::8/64")
+    assert_equal false, ip.include_all?(addr1, "2002:db8:8:800::2/64")
   end
 
   def test_method_to_hex
@@ -399,6 +434,21 @@ class IPv6Test < Minitest::Test
     end
   end
 
+  def test_method_broadcast
+    ip = @klass.new("2001:db8:8:800::/64")
+    assert_instance_of @klass, ip.broadcast
+    assert_equal  "2001:db8:8:800:ffff:ffff:ffff:ffff", ip.broadcast.to_s
+    ip = @klass.new("2001:db8:8::/48")
+    assert_instance_of @klass, ip.broadcast
+    assert_equal "2001:db8:8:ffff:ffff:ffff:ffff:ffff", ip.broadcast.to_s
+    ip = @klass.new("2001:db8::/32")
+    assert_instance_of @klass, ip.broadcast
+    assert_equal "2001:db8:ffff:ffff:ffff:ffff:ffff:ffff", ip.broadcast.to_s
+    ip = @klass.new("2001:db8::8:800:200c:417a/64")
+    assert_instance_of @klass, ip.broadcast
+    assert_equal  "2001:db8::ffff:ffff:ffff:ffff", ip.broadcast.to_s
+  end
+
   def test_method_network
     @networks.each do |addr,net|
       ip = @klass.new addr
@@ -572,13 +622,61 @@ class IPv6Test < Minitest::Test
 
   def test_finds_adjacent_subnet
     refute @klass.new("::/0").find_adjacent_subnet 
+
+    ip = @klass.new("2001:db8::/32")
+    assert_equal "2001:db9::/32", ip.find_adjacent_subnet
+    assert_equal 32, ip.prefix
+
     assert_equal "2001:db9::/32", @klass.new("2001:db8::/32").find_adjacent_subnet 
     assert_equal "2001:db8:0:1::/64", @klass.new("2001:db8::/64").find_adjacent_subnet 
     assert_equal "2001:db8:8:2000::/51", @klass.new("2001:db8:8::/51").find_adjacent_subnet 
-    # assert_equal "", @klass.new("").find_adjacent_subnet 
-    # assert_equal "", @klass.new("").find_adjacent_subnet 
   end
 
+  def test_method_add
+    ip = IPAddress::IPv6.new("fc42:1337::/64")
+    assert_equal ip.add(5), IPAddress::IPv6.new("fc42:1337::5/64")
+    assert_equal ip.add(IPAddress::IPv6.new("::5/42")), IPAddress::IPv6.new("fc42:1337::5/64")
+    assert_equal ip.add(50), IPAddress::IPv6.new("fc42:1337::32/64")
+    ip = IPAddress::IPv6.new("fc42:1337::/120")
+    assert_equal ip.add(2), IPAddress::IPv6.new("fc42:1337::2/120")
+    assert_raises(RuntimeError) {ip.add(256)}
+    assert_equal ip.add(256, false), IPAddress::IPv6.new("fc42:1337::100/120")
+  end
+
+  def test_method_subtract
+    ip = IPAddress::IPv6.new("fc42:1337::5/64")
+    assert_equal ip.subtract(5), IPAddress::IPv6.new("fc42:1337::/64")
+    assert_equal ip.subtract(IPAddress::IPv6.new("::5/12")), IPAddress::IPv6.new("fc42:1337::0/64")
+    assert_raises(RuntimeError) {ip.subtract(11)}
+    assert_raises(RuntimeError) {ip.subtract(IPAddress::IPv6.new("::11/66"))}
+  end
+  
+  def test_method_hostpart
+    ip = IPAddress::IPv6.new("fc42:1337:0:5::7/64")
+    assert_equal ip.hostpart.to_s, "::7"
+  end
+
+  def test_method_advance_network
+    ip = IPAddress::IPv6.new("fc42:1337:0:0::/64")
+    assert_equal ip.advance_network(5), IPAddress::IPv6.new("fc42:1337:0:5::/64")
+  end
+
+  def test_method_next_network
+    ip = IPAddress::IPv6.new("fc42:1337:0:0::/64")
+    assert_equal ip.next_network, IPAddress::IPv6.new("fc42:1337:0:1::/64")
+  end
+  
+  def test_method_regress_network
+    ip = IPAddress::IPv6.new("fc42:1337:0:5::/64")
+    assert_equal ip.regress_network(4), IPAddress::IPv6.new("fc42:1337:0:1::/64")
+  end
+  
+  def test_method_previous_network
+    ip = IPAddress::IPv6.new("fc42:1337:0:5::/64")
+    assert_equal ip.previous_network, IPAddress::IPv6.new("fc42:1337:0:4::/64")
+  end  
+
+
 end # class IPv6Test
 
 class IPv6UnspecifiedTest < Minitest::Test

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: ipaddress_2
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.14.0
 platform: ruby
 authors:
 - bluemonk
 - mikemackintosh
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-01-22 00:00:00.000000000 Z
+date: 2021-07-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -131,7 +131,7 @@ dependencies:
         version: '0'
 description: |-
   IPAddress2 is a Ruby library designed to make manipulation
-        of IPv4 and IPv6 addresses both powerful and simple. It mantains
+        of IPv4 and IPv6 addresses both powerful and simple. It maintains
         a layer of compatibility with Ruby's own IPAddr, while
         addressing many of its issues.
 email: adam@21eleven.com
@@ -168,11 +168,11 @@ files:
 - test/ipaddress_2/prefix_test.rb
 - test/ipaddress_2_test.rb
 - test/test_helper.rb
-homepage: https://github.com/ipaddress2-gem/ipaddress2
+homepage: https://github.com/ipaddress2-gem/ipaddress_2
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -187,9 +187,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.8
-signing_key: 
+rubygems_version: 3.2.3
+signing_key:
 specification_version: 4
 summary: IPv4/IPv6 address manipulation library
 test_files: []