ipaddr_range_set 0.9.0

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in ipaddr_range_set.gemspec
+gemspec

data/README.md

@@ -0,0 +1,72 @@
+ipaddr_range_set
+================
+
+convenience class to create a set of possibly discontiguous IP address range
+segments, and check if an IP address is in the set. 
+
+Ruby stdlib IPAddr does the heavy-lifting, this is relatively simple code, 
+but which can simplify your own code when used. Having to do this sort
+of thing is often the sign of a bad design, but many of us have to do it anyway. 
+
+== Usage
+
+    require 'ipaddr_range_set'
+    
+    # Zero or more segment arguments, of a variety
+    # of formats. 
+    range = IPAddrRangeSet.new(
+      '220.1.10.3',   # an IPv4 as a string
+      '2001:db8::10',  # An IPv6 as a string
+      '8.0.0.0/24',    # IPv4 as CIDR, IPv6 CIDR too
+      '8.*.*.*',       # informal splat notation, only for IPv4
+      '8.8.0.0'..'8.8.2.255', # arbitrary range
+      IPAddr.new(whatever),   # arbitrary existing IPAddr object
+      (ip_addr..ip_addr)      # range of arbitrary IPAddr objects.       
+    )
+    
+When ruby Range's are used, IPAddrRangeSegment makes sure to use `Range#cover?`
+internally, not `Range#include?` (the latter being disastrous for anything that
+doesn't have `#to_int`).  Triple dot `...` exclusive ranges are supported, if for
+some reason you want them. 
+
+    range.include?  '220.1.10.5'
+    range.include?  IPAddr.new('220.1.10.5')
+    
+`#include?` is aliased as `#===` so you can easily use it in `case/when`.  
+    
+IPAddrRangeSets are immutable, but you can create new ones combining existing
+ranges:
+
+    new_range = IPAddrRangeSet('8.10.5.1') + IPAddrRangeSet('8.11.6.1')
+    new_range = IPAddrRangeSet('8.10.5.1').add('8.0.0.0/24')
+    
+The internal implementation just steps through all range segments and checks
+the argument for inclusion, there's no special optimization to detect overlapping
+ranges and simplify them.  If you are doing a high enough volume of segment/arg
+checks that you need performance, you probably need a custom implementation
+involving a search tree of some kind anyway. 
+
+As above range 'union' is supported, but range intersection is not. It's 
+a bit tricky to implement well, and I don't have a use case for it. 
+
+Built-in constants are available for local (private, not publically routable)
+and loopback ranges in both IPv4 IPv6.   IPv4Local, IPv4Loopback, IPv6Local, 
+IPv6Loopback.  The constant `LocalAddresses` is the union of v4 and v6 local 
+and loopback addresses. 
+
+    IPAddrRangeSet::LocalAddress.include? "127.0.0.1" # true
+    IPAddrRangeSet::LocalAddress.include? "10.0.0.1" # true
+    IPAddrRangeSet::LocalAddress.include? "192.168.0.1" # true
+    IPAddrRangeSet::LocalAddress.include? "::1" # true, ipv6 loopback
+    IPAddrRangeSet::LocalAddress.include? "fc00::1" # an ipv6 local
+    
+== Note on ipv6
+
+It supports ipv6 just because it was so easy to do so with the underlying
+IPAddr implementation.  But I don't have much experience or use for IPv6, there
+could be oddities hiding in there. 
+
+You can create an IPAddrRangeSet that includes both IPv4 and IPv6 segments, no
+problem. But an individual `include?` argument will only match a segment of
+it's own type, no automatic conversion of IPv4-compatible IPv6 addresses
+is done (should it be? I have no idea, don't really understand ipv6 use cases). 

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+ t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test

data/ipaddr_range_set.gemspec

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "ipaddr_range_set/version"
+
+Gem::Specification.new do |s|
+  s.name        = "ipaddr_range_set"
+  s.version     = IpaddrRangeSet::VERSION
+  s.authors     = ["Jonathan Rochkind"]
+  s.email       = ["jonathan@dnil.net"]
+  s.homepage    = "https://github.com/jrochkind/ipaddr_range_set"
+  s.summary     = %q{convenience class to create a set of possibly discontiguous IP address range
+segments, and check if an IP address is in the set.}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/ipaddr_range_set.rb

@@ -0,0 +1,119 @@
+require "ipaddr_range_set/version"
+
+require 'ipaddr'
+
+class IPAddrRangeSet
+  
+  def initialize(*segments_list)        
+    
+    segments_list.each do |segment|
+      
+      if IPAddr === segment
+        segment.freeze
+        segments << segment
+        next
+      end
+      
+      if Range === segment
+        first = segment.first
+        last = segment.last
+        
+        first = IPAddr.new(first) unless first.kind_of? IPAddr
+        last = IPAddr.new(last) unless last.kind_of? IPAddr
+        
+        segments << Range.new(first, last, segment.exclude_end?).freeze   
+        next
+      end
+
+      
+      segment = segment.to_str
+      
+      # special splat processing? eg '124.*.*.*' ipv4 only.
+      # Convert to ordinary 'a.b.c.d/m' CIDR notation. 
+      if segment.include?('*') && segment =~ /(\d{1,3}|\*\.){3}\d{1,3}|\*/
+        octets = segment.split('.')
+                
+        if (octets.rindex {|o| o =~ /\d+/}) > octets.rindex("*")
+          raise ArgumentError.new("Invalid splat range, all *s have to come before all concrete octets")
+        end
+                
+        splats = 0
+        base = octets.collect do |o|
+          if o == '*'
+            splats += 1
+            '0'
+          else
+            o
+          end          
+        end.join(".")        
+        
+        prefix_size = 32 - (8 * splats)                
+        segments << IPAddr.new("#{base}/#{prefix_size}")        
+        
+        next
+      end
+      
+      segments << IPAddr.new(segment)              
+    end        
+  end
+  
+  # Does the range set include the argument?
+  # Can pass in IPAddr or string IP addr (that will be used as arg to IPAddr.new)
+  #
+  # Aliased as #=== (for case/when!) and cover?
+  def include?(ip_addr)
+    ip_addr = IPAddr.new(ip_addr) unless ip_addr.kind_of? IPAddr
+  
+    segments.each do |segment|
+      # important to use cover? and not include? on Ranges, to avoid
+      # terribly inefficient check. But if segment is an IPAddr, you want include?
+      if segment.respond_to?(:cover)
+        return true if segment.cover? ip_addr
+      else
+        return true if segment.include? ip_addr
+      end        
+    end
+    
+    return false    
+  end
+  alias_method :cover?, :include?
+  alias_method :'===', :include?
+  
+  # Returns a NEW IPAddrRangeSet composed of union of segments
+  # in receiver and argument.  Aliased as `+`
+  #
+  # IPAddrRangeSets are immutable. 
+  def union(other_set)
+    all_segments = self.segments + other_set.segments
+    self.class.new  *all_segments
+  end
+  alias_method :'+', :union
+  
+  # Returns a NEW IPAddrRangeSet composed of union of receiver,
+  # and additional segments(s) given as arguments. 
+  # IPAddrRangeSet is immutable. 
+  def add(*new_segments)
+    return self + IPAddrRangeSet.new(*new_segments)
+  end
+  
+  protected
+  
+  # Not public API, but used for creating unions of range sets,
+  # etc., is why it's protected instead of private
+  def segments
+    @segments ||= []
+  end
+   
+  
+end
+
+class IPAddrRangeSet
+  # Constant ranges for local/non-routable/private addresses
+  IPv4Local     = IPAddrRangeSet.new("10.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16")
+  IPv4Loopback  = IPAddrRangeSet.new("127.0.0.0/8")
+  
+  IPv6Local = IPAddrRangeSet.new("fc00::/7")
+  IPv6Loopback =  IPAddrRangeSet.new("::1")
+  
+  LocalAddresses = IPv4Local + IPv4Local + IPv6Local + IPv6Local 
+end

data/lib/ipaddr_range_set/version.rb

@@ -0,0 +1,3 @@
+module IpaddrRangeSet
+  VERSION = "0.9.0"
+end

data/test/test_ip_addr_range_set.rb

@@ -0,0 +1,135 @@
+require 'test/unit'
+
+require 'ipaddr_range_set'
+
+
+class TestIpAddrRange < Test::Unit::TestCase
+
+  def self.test_inclusion(label, argument, should_include, *should_not_include)
+    self.send(:define_method , "test_#{label}"  ) do
+      range = IPAddrRangeSet.new(argument)
+      assert range.include?(should_include), "IPAddrRangeSet.new #{argument} should include? #{should_include}"
+      
+      should_not_include.each do | should_not|
+        assert !range.include?(should_not), "IPAddrRangeSet.new #{argument} should NOT include? #{should_not}"
+      end      
+    end
+  end
+  
+  # label (suitable for part of method name), then 
+  # init argument, arg that should be included, 1 to more args that should not be included
+  test_inclusion("single_ipv4_str", "128.220.0.1", "128.220.0.1", "128.220.0.2", "128.220.0.0" )
+  test_inclusion("single_ipv4_obj", IPAddr.new("128.220.0.1"), "128.220.0.1", "128.220.0.2" )
+  test_inclusion("single_ipv4_obj_obj", IPAddr.new("128.220.0.1"), IPAddr.new("128.220.0.1"), IPAddr.new("128.220.0.2") )
+
+  test_inclusion("single_ipv6_str", "2607:f0d0:1002:51::4", "2607:f0d0:1002:51::4", "2607:f0d0:1002:51::5", "2607:f0d0:1002:51::3" )
+  test_inclusion("single_ipv6_obj", IPAddr.new("2607:f0d0:1002:51::4"), "2607:f0d0:1002:51::4", "2607:f0d0:1002:51::5", "2607:f0d0:1002:51::3" )
+
+  test_inclusion("test_ipv4_cidr", "128.220.10.1/24", "128.220.10.100", "128.220.9.255", "128.220.11.1" )
+
+  test_inclusion("test_ipv6_cidr", "2001:db8::/50", "2001:db8::10", "2001:db7::", "2001:db9::" )  
+  
+  test_inclusion("ipv4_range_str", ("128.220.10.1".."128.220.11.255"), "128.220.11.10", "128.220.9.255", '128.220.12.1')
+  test_inclusion("ipv4_range_obj", (IPAddr.new("128.220.10.1")..IPAddr.new("128.220.11.255")), "128.220.11.10", "128.220.9.255", '128.220.12.1')
+  
+  test_inclusion("ipv6_range_str", ("2001:db8::10".."2001:db8::15"), "2001:db8::12", "2001:db8::9", '2001:db8::16')
+    
+  
+  test_inclusion("ipv4_range_str_exclusive_endpoint", ("128.220.10.1"..."128.220.11.255"), "128.220.10.1", "128.220.9.255", "128.220.11.255")
+
+    
+  def test_incompatible_range        
+    # one ipv4 one ipv6. 
+    
+    # Somehow get this for free from ruby Range at the moment
+    assert_raise ArgumentError do
+      IPAddrRangeSet.new( ("128.220.0.1".."2001:db8::10") )
+    end
+    
+    assert_raise ArgumentError do
+      IPAddrRangeSet.new( (IPAddr.new("128.220.0.1").."2001:db8::10") )
+    end
+    
+    assert_raise ArgumentError do
+      IPAddrRangeSet.new(  (IPAddr.new("128.220.0.1")..IPAddr.new("2001:db8::10")) ) 
+    end
+  end
+  
+  def test_empty_set
+    range = IPAddrRangeSet.new()
+    
+    assert ! range.include?("128.220.0.1")
+    assert ! range.include?(IPAddr.new "128.220.0.1")
+    assert ! range.include?(IPAddr.new "2001:db8::10")    
+  end
+  
+  def test_splats
+    range = IPAddrRangeSet.new("128.*.*.*")     
+    
+    assert range.include?("128.4.2.1")
+    
+    assert ! range.include?("127.0.0.1")
+    
+    assert ! range.include?("129.1.1.1")
+  end
+  
+  def test_bad_input
+    assert_raise(ArgumentError) {  IPAddrRangeSet.new("foo")}
+    
+    assert_raise(ArgumentError) {  IPAddrRangeSet.new("124.*")}
+    
+    # splats have to be at end  
+    assert_raise(ArgumentError) {  IPAddrRangeSet.new("124.*.1.1")}
+    
+    # Not a valid ipv4, make sure we catch it on ranges
+    assert_raise(ArgumentError) {  IPAddrRangeSet.new("124.999.1.1".."125.0.0.1") }
+  end
+  
+  def test_multi_arg
+    range = IPAddrRangeSet.new("128.220.1.1", "128.221.*.*", "128.222.0.0/16", ("128.223.1.0".."128.224.255.255"))
+    
+    assert ! range.include?("128.220.10.1")
+    
+    assert range.include?("128.220.1.1")
+    assert range.include?("128.221.10.1")
+    assert range.include?("128.222.10.1")
+    assert range.include?("128.224.1.1")
+    
+    assert ! range.include?("128.225.0.0")
+  end
+  
+  def test_union
+    range = IPAddrRangeSet.new("128.220.1.1") + IPAddrRangeSet.new("128.225.1.1")
+    
+    assert range.include? "128.220.1.1"
+    assert range.include? "128.225.1.1"
+    
+    assert ! range.include?("128.222.1.1")
+  end
+  
+  def test_add
+    range = IPAddrRangeSet.new("128.220.1.1")
+    
+    new_range = range.add("128.225.1.1", "128.230.1.1")
+    
+    assert new_range.include? "128.220.1.1"
+    assert new_range.include? "128.225.1.1"
+    assert new_range.include? "128.230.1.1"
+    
+    assert ! new_range.include?("128.226.1.1")
+    
+  end
+  
+  def test_local_constants
+    %w{10.3.3.1 172.16.4.1 192.168.2.1  fc00::1}.each do |ip|
+      assert IPAddrRangeSet::LocalAddresses.include?(ip), "IPAddrRangeSet::LocalAddresses should include #{ip}"
+    end
+    
+    %w{9.1.1.1 173.1.1.1 193.1.1.1 2607:f0d0:1002:51::4}.each do |ip|
+      assert (! IPAddrRangeSet::LocalAddresses.include?(ip)), "IPAddrRangeSet::LocalAddresses should NOT include #{ip}"
+    end    
+  end
+    
+  
+  
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: ipaddr_range_set
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+  prerelease: 
+platform: ruby
+authors:
+- Jonathan Rochkind
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-08 00:00:00.000000000 Z
+dependencies: []
+description: 
+email:
+- jonathan@dnil.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- README.md
+- Rakefile
+- ipaddr_range_set.gemspec
+- lib/ipaddr_range_set.rb
+- lib/ipaddr_range_set/version.rb
+- test/test_ip_addr_range_set.rb
+homepage: https://github.com/jrochkind/ipaddr_range_set
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: convenience class to create a set of possibly discontiguous IP address range
+  segments, and check if an IP address is in the set.
+test_files:
+- test/test_ip_addr_range_set.rb
+has_rdoc: