subnets 1.0.0pre → 1.0.0pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ca7677ed446bf92038930c57e31d26878b05fe6dc7c6fa4cf5f731ec58a5340
-  data.tar.gz: 3d82804a72f2181c5036d69aad617c927bac2eb64ee4fe496d822ca6a006a043
+  metadata.gz: 54f0c79b3c0859e0d9cd2758276652d48fd0ceeece739695691b76c5cb8d01a7
+  data.tar.gz: 69b64044d769ede44735081a0411b088cf3016bf6a4a732238c5996c105e5e19
 SHA512:
-  metadata.gz: 1f152961d4118eac6bb2bfafb1f65bdc94ee971b6ff0215542790a446da7e3c3e09d35278dcbfbd8e918f5defad442dbf38d3cb067f39521a3e9fa67ae86d853
-  data.tar.gz: 2655d78b2dbf09510a28cdabaea00c572c5038889b7724c34fa96e2f1bb72319831c468b57caf39055ddae8d106ff91a61e7695d9dd3762d6fbe92c7f7ac6f4b
+  metadata.gz: ceebcd95e1fb22ee86acf2c4eb606c3deda2a97c04a7f57d0e97f5493974441855f3e7a04e2525e6b4ff1a88f6508df29b548bebcfca36dceb0ee4384ab76f82
+  data.tar.gz: ac0e808b3e42227f53881eed50a807e136a0b2602f0402bda120a42f9cc78d16ce64029cd2d5aa2e6fd9456dfb797411fe5496c6fda5321528e4cd39a828e591

data/README.md

@@ -27,11 +27,11 @@ better. Plotted on logscale. (Ruby 2.5.0p0, 2.5 GHz Intel Core i7).
 ```
 $ bundle exec rake benchmark TEST=test/private_networks_benchmark
     
- ipaddr         : 46.25us/ip ██████████████████████████████████▋
- ipaddress      : 63.88us/ip ██████████████████████████████████████▏
- netaddr        : 31.03us/ip ██████████████████████████████▎
-*subnets        :  4.19us/ip ████████▏
- rack (regexp)  :  5.25us/ip ██████████▋
+ ipaddr         : 46.25μs/ip ██████████████████████████████████▋
+ ipaddress      : 63.88μs/ip ██████████████████████████████████████▏
+ netaddr        : 31.03μs/ip ██████████████████████████████▎
+*subnets        :  4.19μs/ip ████████▏
+ rack (regexp)  :  5.25μs/ip ██████████▋
                              '         '       '      '         '
                              2         5       10     20        50
 ```

data/ext/subnets/ext.c

@@ -318,54 +318,45 @@ method_ip4_band(VALUE self, VALUE other) {
 
 VALUE
 method_ip6_not(VALUE self) {
-  ip6_t *ip, not;
+  ip6_t *ip;
   Data_Get_Struct(self, ip6_t, ip);
-  for (int i=0; i<8; i++) {
-    not.x[i] = ~(ip->x[i]);
-  }
-  return ip6_new(IP6, not);
+  return ip6_new(IP6, ip6_not(*ip));
 }
 
 VALUE
 method_ip6_bor(VALUE self, VALUE other) {
-  ip6_t *a, *b, bor;
+  ip6_t *a, *b;
 
   assert_kind_of(other, IP6);
 
   Data_Get_Struct(self, ip6_t, a);
   Data_Get_Struct(other, ip6_t, b);
-  for (int i=0; i<8; i++) {
-    bor.x[i] = a->x[i] | b->x[i];
-  }
-  return ip6_new(IP6, bor);
+
+  return ip6_new(IP6, ip6_bor(*a, *b));
 }
 
 VALUE
 method_ip6_xor(VALUE self, VALUE other) {
-  ip6_t *a, *b, xor;
+  ip6_t *a, *b;
 
   assert_kind_of(other, IP6);
 
   Data_Get_Struct(self, ip6_t, a);
   Data_Get_Struct(other, ip6_t, b);
-  for (int i=0; i<8; i++) {
-    xor.x[i] = a->x[i] ^ b->x[i];
-  }
-  return ip6_new(IP6, xor);
+
+  return ip6_new(IP6, ip6_xor(*a, *b));
 }
 
 VALUE
 method_ip6_band(VALUE self, VALUE other) {
-  ip6_t *a, *b, band;
+  ip6_t *a, *b;
 
   assert_kind_of(other, IP6);
 
   Data_Get_Struct(self, ip6_t, a);
   Data_Get_Struct(other, ip6_t, b);
-  for (int i=0; i<8; i++) {
-    band.x[i] = a->x[i] & b->x[i];
-  }
-  return ip6_new(IP6, band);
+
+  return ip6_new(IP6, ip6_band(*a, *b));
 }
 
 /**
@@ -546,6 +537,33 @@ method_net6_to_s(VALUE self) {
   return rb_str_new2(buf);
 }
 
+VALUE
+method_ip4_to_i(VALUE self) {
+  ip4_t *ip;
+  Data_Get_Struct(self, ip4_t, ip);
+  return RB_UINT2NUM(*ip);
+}
+
+VALUE
+method_ip6_to_i(VALUE self) {
+  VALUE ret;
+  ip6_t *ip;
+  Data_Get_Struct(self, ip6_t, ip);
+
+  ID lshift = rb_intern("<<");
+  ID plus = rb_intern("+");
+
+  ret = RB_INT2NUM(0);
+
+  for (int i=0; i<8; i++) {
+    VALUE hextet = RB_UINT2NUM(ip->x[i]);
+    VALUE inc = rb_funcall(hextet, lshift, 1, RB_INT2NUM(16*(7-i)));
+    ret = rb_funcall(ret, plus, 1, inc);
+  }
+
+  return ret;
+}
+
 /**
  * @return [Boolean]
  */
@@ -600,10 +618,7 @@ method_ip6_eql_p(VALUE self, VALUE other) {
   Data_Get_Struct(self, ip6_t, a);
   Data_Get_Struct(other, ip6_t, b);
 
-  for (int i=0; i<8; i++) {
-    if (a->x[i] != b->x[i]) return Qfalse;
-  }
-  return Qtrue;
+  return ip6_eql_p(*a, *b) ? Qtrue : Qfalse;
 }
 
 /**
@@ -745,34 +760,86 @@ method_net6_hextets(VALUE self) {
   return hextets;
 }
 
+/**
+ * @return [Subnets::Net4] the smallest subnet that includes all of
+ * the subnets in +nets+
+ *
+ * @param nets [Array<Subnets::Net4>]
+ */
 VALUE
 method_net4_summarize(VALUE class, VALUE nets) {
   net4_t result;
 
-  result.address = mk_mask4(32);
-  result.prefixlen = 32;
-  result.mask = mk_mask4(32);
-
   for (ssize_t i = 0; i < RARRAY_LEN(nets); i++) {
     VALUE rbnet = RARRAY_AREF(nets, i);
 
     assert_kind_of(rbnet, Net4);
 
-    net4_t *net;
+    const net4_t *net;
     Data_Get_Struct(rbnet, net4_t, net);
 
-    result.address &= (net->address & net->mask);
+    if (i == 0) {
+      result.address = (net->address & net->mask);
+      result.prefixlen = net->prefixlen;
+      result.mask = net->mask;
+    } else {
+      if (result.prefixlen > net->prefixlen) {
+        result.prefixlen = net->prefixlen;
+        result.mask = net->mask;
+        result.address &= result.mask;
+      }
 
-    while (!net4_include_net4_p(result, *net)) {
-      result.prefixlen -= 1;
-      result.mask = mk_mask4(result.prefixlen);
-      result.address &= result.mask;
+      while (result.address != (net->address & result.mask)) {
+        result.prefixlen -= 1;
+        result.mask = mk_mask4(result.prefixlen);
+        result.address &= result.mask;
+      }
     }
   }
 
   return net4_new(class, result);
 }
 
+/**
+ * @return [Subnets::Net6] the smallest subnet that includes all of
+ * the subnets in +nets+
+ *
+ * @param nets [Array<Subnets::Net6>]
+ */
+VALUE
+method_net6_summarize(VALUE class, VALUE nets) {
+  net6_t result;
+
+  for (ssize_t i = 0; i < RARRAY_LEN(nets); i++) {
+    VALUE rbnet = RARRAY_AREF(nets, i);
+
+    assert_kind_of(rbnet, Net6);
+
+    net6_t *net;
+    Data_Get_Struct(rbnet, net6_t, net);
+
+    if (i == 0) {
+      result.address = ip6_band(net->address, net->mask);
+      result.prefixlen = net->prefixlen;
+      result.mask = net->mask;
+    } else {
+      if (result.prefixlen > net->prefixlen) {
+        result.prefixlen = net->prefixlen;
+        result.mask = net->mask;
+        result.address = ip6_band(result.address, result.mask);
+      }
+
+      while(!ip6_eql_p(result.address, ip6_band(net->address, result.mask))) {
+        result.prefixlen -= 1;
+        result.mask = mk_mask6(result.prefixlen);
+        result.address = ip6_band(result.address, result.mask);
+      }
+    }
+  }
+
+  return net6_new(class, result);
+}
+
 /**
  * Try parsing +str+ as Net4, Net6, IP4, IP6.
  *
@@ -942,6 +1009,7 @@ void Init_Subnets() {
   rb_define_alias(IP4, "eql?", "==");
   rb_define_method(IP4, "hash", method_ip4_hash, 0);
   rb_define_method(IP4, "to_s", method_ip4_to_s, 0);
+  rb_define_method(IP4, "to_i", method_ip4_to_i, 0);
 
   rb_define_method(IP4, "~", method_ip4_not, 0);
   rb_define_method(IP4, "|", method_ip4_bor, 1);
@@ -955,6 +1023,7 @@ void Init_Subnets() {
   rb_define_alias(IP6, "eql?", "==");
   rb_define_method(IP6, "hash", method_ip6_hash, 0);
   rb_define_method(IP6, "to_s", method_ip6_to_s, 0);
+  rb_define_method(IP6, "to_i", method_ip6_to_i, 0);
   rb_define_method(IP6, "hextets", method_ip6_hextets, 0);
 
   rb_define_method(IP6, "~", method_ip6_not, 0);
@@ -988,6 +1057,7 @@ void Init_Subnets() {
   rb_define_singleton_method(Net6, "parse", method_net6_parse, 1);
   rb_define_singleton_method(Net6, "random", method_net6_random, -1);
   rb_define_singleton_method(Net6, "new", method_net6_new, 2);
+  rb_define_singleton_method(Net6, "summarize", method_net6_summarize, 1);
   rb_define_method(Net6, "==", method_net6_eql_p, 1);
   rb_define_alias(Net6, "eql?", "==");
   rb_define_method(Net6, "hash", method_net6_hash, 0);

data/ext/subnets/ipaddr.c

@@ -187,6 +187,50 @@ net6_snprint(net6_t net, char *str, size_t size) {
   return n0 + n1;
 }
 
+int
+ip6_eql_p(ip6_t a, ip6_t b) {
+  for (int i=0; i<8; i++) {
+    if (a.x[i] != b.x[i]) return 0;
+  }
+  return !0;
+}
+
+ip6_t
+ip6_not(ip6_t ip) {
+  ip6_t not;
+  for (int i=0; i<8; i++) {
+    not.x[i] = ~(ip.x[i]);
+  }
+  return not;
+}
+
+ip6_t
+ip6_band(ip6_t a, ip6_t b) {
+  ip6_t band;
+  for (int i=0; i<8; i++) {
+    band.x[i] = a.x[i] & b.x[i];
+  }
+  return band;
+}
+
+ip6_t
+ip6_bor(ip6_t a, ip6_t b) {
+  ip6_t bor;
+  for (int i=0; i<8; i++) {
+    bor.x[i] = a.x[i] | b.x[i];
+  }
+  return bor;
+}
+
+ip6_t
+ip6_xor(ip6_t a, ip6_t b) {
+  ip6_t xor;
+  for (int i=0; i<8; i++) {
+    xor.x[i] = a.x[i] ^ b.x[i];
+  }
+  return xor;
+}
+
 int
 hexvalue(unsigned int c) {
   if (c-'0'<10) return c-'0';

data/ext/subnets/ipaddr.h

@@ -102,4 +102,10 @@ size_t read_ip6_strict(const char *, ip6_t *);
 size_t read_net4_strict(const char *, net4_t *);
 size_t read_net6_strict(const char *, net6_t *);
 
+int ip6_eql_p(ip6_t, ip6_t);
+ip6_t ip6_not(ip6_t);
+ip6_t ip6_band(ip6_t, ip6_t);
+ip6_t ip6_bor(ip6_t, ip6_t);
+ip6_t ip6_xor(ip6_t, ip6_t);
+
 #endif                          /* __IPADDR_H__ */

data/test/private_networks_benchmark.rb

@@ -43,11 +43,11 @@ puts "# check if single IP is in the private IPv4 subnets"
     }.total
     count += 100
   end
-  puts "%10.10s: checked %8d (%6d hits, %2d%%) in %2.2f for %7.2fus/ip" %
+  puts "%10.10s: checked %8d (%6d hits, %2d%%) in %2.2f for %7.2fμs/ip" %
        [check.name, count, hits, 100.0*hits/count, total, total/count*1e6]
 
   results[check.name] = total/count*1e6
 end
 
 puts
-plotbarslogscale(prefix: '%-15.15s: %5.2fus/ip ', width: 46, min: 2, max: 65, tics: [2,5,10,20,50], data: results)
+plotbarslogscale(prefix: '%-15.15s: %5.2fμs/ip ', width: 46, min: 2, max: 65, tics: [2,5,10,20,50], data: results)

data/test/subnets/net4_test.rb

@@ -3,6 +3,7 @@ require 'test_helper'
 module Subnets
   class TestNet4 < Minitest::Test
     include EqlAndHash
+    include Summarize
 
     def klass
       Net4
@@ -70,5 +71,20 @@ module Subnets
         end
       end
     end
+
+    def test_summarize
+      data = {
+        '192.168.0.0/24' => ['192.168.0.0/25', '192.168.0.128/25'],
+        '10.0.0.0/8' => ['10.0.0.0/24', '10.250.2.3/19'],
+      }
+
+      data.each do |summ, nets|
+        summ = Subnets.parse(summ)
+        nets = nets.map(&Subnets.method(:parse))
+
+        assert_equal summ, Net4.summarize(nets)
+        assert_summarizes summ, nets
+      end
+    end
   end
 end

data/test/subnets/net6_test.rb

@@ -4,6 +4,7 @@ require 'ipaddr'
 module Subnets
   class TestNet6 < Minitest::Test
     include EqlAndHash
+    include Summarize
 
     # for EqlAndHash
     def klass

data/test/summarize.rb

@@ -0,0 +1,12 @@
+module Summarize
+  def test_summarizing_net_includes_subnets
+    random = Random.new
+    start = Time.now
+    until Time.now - start > TIMED_TEST_DURATION
+      nets = (1..3).map{klass.random(random)}
+      summ = klass.summarize(nets)
+      assert_operator summ.prefixlen, :>=, 0, "summarized #{nets} to invalid #{summ}"
+      assert_summarizes klass.summarize(nets), nets
+    end
+  end
+end

data/test/test_helper.rb

@@ -18,6 +18,7 @@ Minitest::Reporters.use! [Minitest::Reporters::SpecReporter.new,
 require 'subnets'
 require 'well_known_subnets'
 require 'eql_and_hash'
+require 'summarize'
 
 TIMED_TEST_DURATION = (ENV['TIMED_TEST_DURATION'] || 1).to_i
 
@@ -28,3 +29,14 @@ end
 def refute_include(obj, val)
   refute obj.include?(val), "#{obj} should not include #{val}"
 end
+
+def assert_summarizes(summ, nets)
+  bad = nil
+  nets.each do |net|
+    unless summ.include?(net)
+      bad = net
+      break
+    end
+  end
+  refute bad, "#{nets} not summarized by #{summ}: #{summ}.include?(#{bad}) was false"
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: subnets
 version: !ruby/object:Gem::Version
-  version: 1.0.0pre
+  version: 1.0.0pre1
 platform: ruby
 authors:
 - Patrick Mahoney
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-12 00:00:00.000000000 Z
+date: 2018-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -175,6 +175,7 @@ files:
 - test/subnets/net4_test.rb
 - test/subnets/net6_test.rb
 - test/subnets_test.rb
+- test/summarize.rb
 - test/test_helper.rb
 - test/well_known_subnets.rb
 homepage: https://github.com/raisemarketplace/subnets