net-block 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 305d1ead9c8ad555ed1a85b693f2418fbf48f017
+  data.tar.gz: 360306d17a457323a61d9cb41b138f9fc52c37f1
+SHA512:
+  metadata.gz: d05e3878257f3d67a41033a753f3d320cca18b6a3b148f6dcd16f517d9427613e18bb51f68d0082698c97d614ad5bb1677236171f9e27929d856825c5d392df2
+  data.tar.gz: 5485b82cf265d8764cdd624af6855ceb58c9b0884f7b1f08236b445b81c3c58711aaa83fb85ae6a6d2738af0c4875835d616bcb491594977622815a3c4eb9c6c

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rubocop.yml

@@ -0,0 +1,27 @@
+---
+inherit_from: .rubocop_todo.yml
+
+Metrics/AbcSize:
+  Max: 32
+
+Metrics/CyclomaticComplexity:
+  Max: 8
+
+# Configuration parameters: AllowHeredoc, AllowURI, URISchemes, IgnoreCopDirectives, IgnoredPatterns.
+# URISchemes: http, https
+Metrics/LineLength:
+  Max: 120
+
+# Configuration parameters: CountComments.
+Metrics/MethodLength:
+  Max: 16
+
+Metrics/PerceivedComplexity:
+  Max: 8
+
+# Configuration parameters: PreferredDelimiters.
+Style/PercentLiteralDelimiters:
+  PreferredDelimiters:
+    '%i': '[]'
+    '%q': '{}'
+    '%w': '()'

data/.rubocop_todo.yml

@@ -0,0 +1,12 @@
+# This configuration was generated by
+# `rubocop --auto-gen-config`
+# on 2017-11-06 23:53:58 -0500 using RuboCop version 0.51.0.
+# The point is for the user to remove these configuration records
+# one by one as the offenses are removed from the code base.
+# Note that changes in the inspected code, or installation of new
+# versions of RuboCop, may require this file to be generated again.
+
+# Offense count: 1
+# Configuration parameters: CountComments.
+Metrics/ClassLength:
+  Max: 117

data/.ruby-version

@@ -0,0 +1 @@
+2.4.1

data/Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in net-block.gemspec
+gemspec

data/README.md

@@ -0,0 +1,43 @@
+Net::Block
+==========
+
+The `net-block` gem provides several foundational classes for managing information about IPv4 networks and addresses, including a BitSet, Address, and Trie.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'net-block'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install net-block
+
+## Usage
+
+The included `nb` CLI exposes several commands to summarize a given network specification. Networks are defined in YAML documents with the following layout:
+
+```yml
+root: 192.168.1.0/24
+subnets:
+- address: 192.168.1.0/27
+  property1: value1
+- address: 192.168.1.32/27
+  property1: value2
+- address: 192.168.1.64/27
+  property1: value3
+```
+
+A `root` address in CIDR form that encapsulates all of the given subnets must be provided. The `subnets` property is an array of objects with, at least, an `address` property containing a CIDR string. Additional properties may be provided for metadata.
+
+Run `bundle exec nb help` for detailed CLI usage.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/jmanero/net-block.

data/Rakefile

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+task default: :spec

data/bin/nb

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'net/block/cli'
+
+Net::Block::CLI.start

data/lib/net/block.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'block/address'
+require_relative 'block/bit'
+require_relative 'block/bitset'
+require_relative 'block/trie'
+
+require_relative 'block/cli'
+
+module Net
+  # Organize and manipulate IPv4 addresses and network blocks
+  #
+  module Block
+    class << self
+      # Build an Address object from a CIDR string
+      #
+      def address(cidr, **metadata)
+        Address.from(cidr, **metadata)
+      end
+
+      # Construct a new Trie structure with the given root network and subnets
+      #
+      def trie(root, *addresses)
+        Trie.from(root, *addresses)
+      end
+    end
+  end
+end

data/lib/net/block/address.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require_relative 'bitset'
+
+module Net
+  module Block
+    # An IPv4 network address
+    #
+    class Address
+      ZERO = 0
+      THIRTY_ONE = 31
+      THIRTY_TWO = 32
+
+      attr_reader :address
+      attr_reader :mask
+      attr_reader :metadata
+
+      # Construct an Address from a CIDR string
+      #
+      def self.from(string, **metadata)
+        dotted, mask_length = string.split('/')
+        octets = dotted.split('.').map(&:to_i)
+
+        mask_length ||= THIRTY_TWO # If argument didn't have a /MASK, default to /32
+        mask_length = mask_length.to_i
+
+        ## IPv4 Validation
+        unless mask_length.between?(ZERO, THIRTY_TWO)
+          raise ArgumentError, "Mask length `#{mask}` is not valid for an IPv4 address"
+        end
+
+        unless octets.length == 4 && octets.all? { |o| o.between?(ZERO, 255) }
+          raise ArgumentError, "Address `#{dotted}` is not a valid IPv4 address in dotted-decimal form"
+        end
+
+        ## Generate BitSet from address octets. BitSets are little-endian!
+        address = octets.map { |octet| BitSet.from(octet, 8) }.reverse.reduce(:+)
+
+        new(address, BitSet.mask(mask_length, THIRTY_TWO), **metadata)
+      end
+
+      def initialize(address, mask, **metadata)
+        @address = address
+        @mask = mask
+        @metadata = metadata
+      end
+
+      def network
+        Address.new(mask & address, mask.clone)
+      end
+
+      def broadcast
+        Address.new(address | !mask, mask.clone)
+      end
+
+      # If this is a network address, ANDing w/ mask should be a NOOP
+      #
+      def network?
+        (address & mask) == address
+      end
+
+      # Test if a given address is a sub-network of this address
+      #
+      def subnet?(other)
+        return false if other.length <= length
+
+        (mask & other.address) == address
+      end
+
+      # Calculate the super-block of this address. For a host-address, this is
+      # the network address. For a network-address, this is the next-shortest mask
+      #
+      def parent
+        return network unless network?
+        return @parent unless @parent.nil?
+
+        ## Calculate the next shortest prefix
+        supermask = mask.clone
+        supermask.flip!(THIRTY_TWO - length)
+
+        @parent = Address.new(supermask & address, supermask)
+      end
+
+      # Calculate the bottom subnet of the next most specific prefix
+      #
+      def left_child
+        raise RangeError, 'Cannot allocate an address with mask longer than 32' if length == THIRTY_TWO
+        return @left_child unless @left_child.nil?
+
+        ## Calculate the next longest prefix
+        submask = mask.clone
+        submask.flip!(THIRTY_ONE - length)
+
+        @left_child = Address.new(network.address.clone, submask)
+      end
+
+      # Calculate the top subnet of the next most specific prefix
+      #
+      def right_child
+        raise RangeError, 'Cannot allocate an address with mask longer than 32' if length == THIRTY_TWO
+        return @right_child unless @right_child.nil?
+
+        ## Calculate the next longest prefix
+        submask = mask.clone
+        submask.flip!(THIRTY_ONE - length)
+
+        ## Increment next-most-significant bit in network address. Should always be Zero
+        ## for the `network` Address instance.
+        subnet = network.address.clone
+        subnet.flip!(THIRTY_ONE - length)
+
+        @right_child = Address.new(subnet, submask)
+      end
+
+      def length
+        mask.ones
+      end
+
+      def ==(other)
+        length == other.length && address == other.address
+      end
+
+      def <=>(other)
+        address <=> other.address
+      end
+
+      def to_s
+        annotations = metadata.map { |k, v| "#{k}: #{v}" }.join(', ')
+
+        "#{address.v4}/#{mask.ones} #{annotations}"
+      end
+    end
+  end
+end

data/lib/net/block/bit.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Net
+  module Block
+    # A boolean value
+    #
+    class Bit
+      PLUS  = 1
+      ZERO  = 0
+      MINUS = -1
+
+      class << self
+        # Coerce a value to a Bit
+        #
+        # NOTE that `to_i` is called on `value`, and may have unexpected effects
+        # upon non-numeric values.
+        #
+        def from(value)
+          return value if value.is_a?(self)
+          value.to_i.zero? ? Zero : One
+        end
+
+        def ^(other)
+          other == self ? Zero : One
+        end
+
+        def one?
+          false
+        end
+
+        def zero?
+          false
+        end
+
+        def to_s
+          to_i.to_s
+        end
+      end
+    end
+
+    # A One Bit
+    #
+    class One < Bit
+      class << self
+        def !
+          Zero
+        end
+
+        def &(other)
+          other
+        end
+
+        def |(_other)
+          One
+        end
+
+        def <=>(other)
+          other == self ? Bit::ZERO : Bit::MINUS
+        end
+
+        # Calculate the binary power of the bit at a given position in a BitSet
+        #
+        def **(other)
+          Bit::PLUS << other
+        end
+
+        def one?
+          true
+        end
+
+        def to_i
+          Bit::PLUS
+        end
+      end
+    end
+
+    # A Zero Bit
+    #
+    class Zero < Bit
+      class << self
+        def !
+          One
+        end
+
+        def &(_other)
+          Zero
+        end
+
+        def |(other)
+          other
+        end
+
+        def <=>(other)
+          other == self ? Bit::ZERO : Bit::PLUS
+        end
+
+        def **(_other)
+          Bit::ZERO
+        end
+
+        def zero?
+          true
+        end
+
+        def to_i
+          Bit::ZERO
+        end
+      end
+    end
+  end
+end

data/lib/net/block/bitset.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require_relative 'bit'
+
+module Net
+  module Block
+    # A vector of Bit objects
+    #
+    class BitSet
+      include Enumerable
+      extend Forwardable
+
+      def_delegators :bits, :[], :length
+
+      # Populate a BitSet from an Integer value
+      #
+      def self.from(value, length)
+        value = value.to_i
+
+        result = new
+        length.times do
+          result.push(Bit.from(value % 2))
+          value /= 2 # Ruby Integer division rounds down
+        end
+
+        result
+      end
+
+      # Populate a BitSet for a bit-mask
+      #
+      def self.mask(ones, length)
+        raise RangeError, 'Mask cannot have more ones that the BitSet length' if ones > length
+
+        result = new(length)
+
+        until result.ones == ones
+          length -= 1
+          result.flip!(length)
+        end
+
+        result
+      end
+
+      def initialize(length = 0, fill = Zero)
+        @bits = Array.new(length, fill)
+      end
+
+      # Flip a bit at `index` in-place in the BitSet
+      #
+      def flip!(index)
+        bits[index] = !bits[index]
+
+        self
+      end
+
+      def !
+        BitSet.new.tap { |result| each { |bit| result.push(!bit) } }
+      end
+
+      def &(other)
+        raise IndexError, 'BitSets must be the same length' unless other.length == length
+        BitSet.new.tap { |result| each_with_index { |bit, i| result.push(bit & other[i]) } }
+      end
+
+      def |(other)
+        raise IndexError, 'BitSets must be the same length' unless other.length == length
+        BitSet.new.tap { |result| each_with_index { |bit, i| result.push(bit | other[i]) } }
+      end
+
+      def ==(other)
+        other.length == length && other.bits == bits
+      end
+
+      def <=>(other)
+        raise IndexError, 'BitSets must be the same length' unless other.length == length
+
+        ## Comparison searches from MSB (31 for an IPV4) to LSB for the first
+        ## pair of bits that do not match, and returns that comparison
+        index = length - 1
+        index -= 1 until bits[index] != other.bits[index] || index.zero?
+
+        other.bits[index] <=> bits[index]
+      end
+
+      # Join two BitSets into a new BitSet
+      def +(other)
+        BitSet.new.tap { |result| result.bits = bits + other.bits }
+      end
+
+      def clone
+        BitSet.new.tap { |result| result.bits = bits.clone }
+      end
+
+      # Construct a BitSet from a sub-section of this BitSet. `from` is inclusive,
+      # `to` is exclusive.
+      #
+      def slice(from, to)
+        raise ArgumentError, 'Argument `from` must be less than or equal to `to`' unless from <= to
+        raise ArgumentError, 'Argument `from` must be between 0 and the set length' unless from.between?(0, length)
+        raise ArgumentError, 'Argument `to` must be between 0 and the set length' unless from.between?(0, length)
+
+        BitSet.new(to - from).tap { |set| set.bits = bits.slice(from, to - from) }
+      end
+
+      def ones
+        count(&:one?)
+      end
+
+      def zeros
+        count(&:zero?)
+      end
+
+      # Calculate the Integer value of the BitSet
+      def to_i
+        reduce([0, 0]) { |(value, index), bit| [value + bit**index, index + 1] }.first
+      end
+
+      def to_s
+        "<#{self.class.name}(#{length}): #{reverse.join(' ')}>"
+      end
+
+      # Helper to format the BitSet as a dotted-quad IPv4 address string
+      #
+      def v4
+        raise RangeError, 'BitSet must have a length of 32 to format as an IPv4 address!' unless length == 32
+        [slice(24, 32), slice(16, 24), slice(8, 16), slice(0, 8)].map(&:to_i).join('.')
+      end
+
+      protected
+
+      # Allow a BitSet to modify the underlying bit-array of another BitSet
+      #
+      attr_reader :bits
+      attr_writer :bits
+
+      def_delegators :bits, :each, :push, :reverse, :unshift
+    end
+  end
+end

data/lib/net/block/cli.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'thor'
+require 'yaml'
+
+require_relative '../block'
+
+module Net
+  module Block
+    # CLI for nb executable
+    #
+    class CLI < Thor
+      desc 'sumarize NETWORK', 'Read a network allocation table from a YAML file and sumarize'
+      def summarize(path)
+        trie = Utils.load_trie(path)
+
+        ## Aggregations
+        aggregates = trie.aggregate
+        holes = trie.holes
+
+        say "Found #{aggregates.length} continuous netblocks:"
+        aggregates.each { |block| puts " - #{block.network}" }
+        puts '---'
+        puts ''
+
+        say "Found #{holes.length} unallocated netblocks:"
+        holes.sort_by(&:length).each { |address| puts " - #{address}" }
+      end
+
+      desc 'aggregate NETWORK', 'Read a network allocation table from a\
+ YAML file aggregate into the largest possible network blocks'
+
+      def aggregate(path)
+        aggregates = Utils.load_trie(path).aggregate
+
+        say "Found #{aggregates.length} continuous netblocks:"
+        aggregates.each { |block| puts "---\n#{block}" }
+      end
+
+      desc 'next NETWORK MASK', 'Find the next available address of the given\
+ MASK length in the network allocation table'
+      def next(path, length)
+        suitable = Utils.load_trie(path).next(length.to_i)
+
+        say "Found #{suitable.length} possible addresses:"
+        suitable.each { |address| puts " - #{address}" }
+      end
+    end
+
+    # Common CLI helper methods
+    #
+    module Utils
+      class << self
+        def load_yaml(path)
+          content = IO.read(File.expand_path(path))
+          YAML.safe_load(content)
+        end
+
+        def load_trie(path)
+          network = load_yaml(path)
+
+          ## Parse subnet entries {address: 'CIDR/NN', ...metadata: tags}
+          addresses = network.fetch('subnets').map do |entry|
+            cidr = entry.delete('address')
+            metadata = entry.each_with_object({}) { |(k, v), object| object[k.to_sym] = v }
+
+            Address.from(cidr, **metadata)
+          end
+
+          ## Build the Trie
+          Trie.from(network.fetch('root'), addresses)
+        end
+      end
+    end
+  end
+end

data/lib/net/block/trie.rb

@@ -0,0 +1,211 @@
+
+# frozen_string_literal: true
+
+module Net
+  module Block
+    # Organize IPv4 addresses into a binary tree
+    #
+    class Trie
+      attr_reader :parent
+      attr_reader :network
+      attr_reader :left
+      attr_reader :right
+
+      def self.root
+        new(nil, Address.from('0.0.0.0/0'))
+      end
+
+      def self.from(root, *addresses)
+        new(nil, Address.from(root)).tap do |trie|
+          addresses.flatten.each { |addr| trie.insert(addr) }
+        end
+      end
+
+      def initialize(parent, network)
+        @parent = parent
+        @network = network
+      end
+
+      # Check if the node has a left-hand child, and if the child satasifes an
+      # optional block condition
+      #
+      def left?
+        if @left.nil? then false
+        elsif block_given? then yield left
+        else true
+        end
+      end
+
+      # Check if the node has a right-hand child, and if the child satasifes an
+      # optional block condition
+      #
+      def right?
+        if @right.nil? then false
+        elsif block_given? then yield right
+        else true
+        end
+      end
+
+      # Check if the node has any children that satasfy an optional block condition
+      #
+      def any?(&block)
+        left?(&block) || right?(&block)
+      end
+
+      # Check if the node has both children that satasfy an optional block condition
+      #
+      def all?(&block)
+        left?(&block) && right?(&block)
+      end
+
+      # Check if the node has exactly one child that satasifes an optional block
+      # condition
+      #
+      def one?(&block)
+        left?(&block) ^ right?(&block)
+      end
+
+      # Check if the node has no children
+      #
+      def empty?
+        !any?
+      end
+
+      # Check if the node or any of its decendants have only one child
+      #
+      def sparse?
+        return true if one?
+        return false if empty?
+
+        ## all? -> true
+        left.sparse? || right.sparse?
+      end
+
+      # Evaluate a block for each of the node's decendants. The node itself is evaluated first,
+      # followed by left and left's decendants, then right and right's decendants. Blocks can
+      # raise `StopIteration` to stop traversing farther into the Trie
+      #
+      def each(&block)
+        begin
+          yield self
+        rescue StopIteration
+          return ## break
+        end
+
+        left.each(&block) if left?
+        right.each(&block) if right?
+
+        self
+      end
+
+      # Allow reduction operations to traverse the Trie. Blocks can raise
+      # `StopIteration` to stop traversing farther into the Trie
+      #
+      # @yields collection, node
+      #
+      def collect(collection = [], &block)
+        begin
+          yield collection, self
+        rescue StopIteration
+          return ## break
+        end
+
+        left.collect(collection, &block) if left?
+        right.collect(collection, &block) if right?
+
+        collection
+      end
+
+      # Return the address of this node's unallocated child if only one child
+      # is populated
+      #
+      def unallocated
+        return network.left_child unless left?
+        return network.right_child unless right?
+      end
+
+      # Hash an Address object into the correct Trie node
+      #
+      def insert(address)
+        unless network.subnet?(address)
+          raise ArgumentError, 'Cannot insert an address that is not a subnet of this node'
+        end
+
+        ## Already allocated. This is somewhat undefined.
+        return if network == address
+
+        ## Direct descendant. Don't let a new entry clobber an existing node.
+        return @left ||= Trie.new(self, address) if network.left_child == address
+        return @right ||= Trie.new(self, address) if network.right_child == address
+
+        if network.left_child.subnet?(address)
+          @left ||= Trie.new(self, network.left_child)
+          left.insert(address)
+        elsif network.right_child.subnet?(address)
+          @right ||= Trie.new(self, network.right_child)
+          right.insert(address)
+        end
+      end
+
+      # Find the least-specific prefix for continuous blocks of hashed IPv4 addresses
+      #
+      def aggregate
+        ## Find nodes in the trie whose offspring from complete sets. e.g. every
+        ## node that has two children, or zero children, recursively. Nodes with
+        ## one child can not be aggregated without covering a hole
+        collect do |aggregates, node|
+          next if node.sparse?
+
+          aggregates << node
+          raise StopIteration
+        end
+      end
+
+      # Find unallocated prefixes in a set of IPv4 addresses
+      #
+      def holes
+        collect do |unallocated, node|
+          ## This children and all of this node are non-sparse
+          raise StopIteration unless node.sparse?
+
+          ## If this node is missing a child, collect that address. In any case,
+          ## keep searching this node's decendants for unallocated children
+          unallocated << node.unallocated unless node.all?
+        end
+      end
+
+      # Find possible addresses for a given mask length
+      #
+      def next(length)
+        ## Select blocks with short ehough masks
+        suitable = holes.select { |address| address.length <= length }.sort
+
+        ## Find the first subnet of each available block that satasifes the given length
+        suitable.map do |address|
+          address = address.left_child until address.length == length
+          address
+        end
+      end
+
+      # Flatten the Trie into an array of its hashed network Address instances
+      #
+      def flatten
+        return [network] if empty?
+
+        children = []
+        children += left.flatten if left?
+        children += right.flatten if right?
+
+        children
+      end
+
+      def to_s(indent = 0)
+        lines = [(' ' * indent) + network.to_s]
+        lines << left.to_s(indent + 2) if left?
+        lines << right.to_s(indent + 2) if right?
+
+        lines.join("\n")
+      end
+    end
+  end
+end

data/lib/net/block/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Net
+  module Block
+    VERSION = '0.1.0'
+  end
+end

data/net-block.gemspec

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'net/block/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'net-block'
+  spec.version       = Net::Block::VERSION
+  spec.authors       = ['John Manero']
+  spec.email         = ['john.manero@gmail.com']
+
+  spec.summary       = 'Organize sets of IPv4 addresses into hierarchial structures for processing'
+  spec.description   = 'Organize sets of IPv4 addresses into hierarchial structures for processing'
+  spec.homepage      = 'https://github.com/jmanero/netc'
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.15'
+  spec.add_development_dependency 'rake', '~> 10.0'
+
+  spec.add_dependency 'thor', '~> 0.20'
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: net-block
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- John Manero
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-11-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.20'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.20'
+description: Organize sets of IPv4 addresses into hierarchial structures for processing
+email:
+- john.manero@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- ".rubocop_todo.yml"
+- ".ruby-version"
+- Gemfile
+- README.md
+- Rakefile
+- bin/nb
+- lib/net/block.rb
+- lib/net/block/address.rb
+- lib/net/block/bit.rb
+- lib/net/block/bitset.rb
+- lib/net/block/cli.rb
+- lib/net/block/trie.rb
+- lib/net/block/version.rb
+- net-block.gemspec
+homepage: https://github.com/jmanero/netc
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: Organize sets of IPv4 addresses into hierarchial structures for processing
+test_files: []