Module: BetterIpaddr::InstanceMethods

Includes:
Constants
Included in:
IPAddr, IPAddr::Base
Defined in:
lib/better_ipaddr/methods.rb,
lib/better_ipaddr/kernel_method.rb

Overview

Methods included in IPAddr::Base and its descendants

Constant Summary

Constants included from Constants

Constants::FAMILY_TO_BIT_LENGTH, Constants::NETMASK_TO_PREFIX_LENGTH, Constants::PREFIX_LENGTH_TO_NETMASK, Constants::SYMBOL_TO_FAMILY

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#family ⇒ Integer (readonly)

Return the magic number representing the address family.

Returns:

  • (Integer) 


18
19
20
 
# File 'lib/better_ipaddr/methods.rb', line 18

def family
  @family
end

#mask_addr ⇒ Integer (readonly)

Return the integer representation of the netmask.

Returns:

  • (Integer) 


22
23
24
 
# File 'lib/better_ipaddr/methods.rb', line 22

def mask_addr
  @mask_addr
end

Class Method Details

.included(base) ⇒ Object 



9
10
11
12
13
14
 
# File 'lib/better_ipaddr/methods.rb', line 9

def self.included(base)
  return unless base <= IPAddr
  base.class_eval do
    define_method :stdlib_to_s, IPAddr.instance_method(:to_s)
  end
end

Instance Method Details

#+(offset) ⇒ IPAddr

Return the address greater than the original address by the given offset. Note that the result will always be a host address.

Parameters:

  • offset (Integer) —

    the difference between the original address and the returned address

Returns:



37
38
39
 
# File 'lib/better_ipaddr/methods.rb', line 37

def +(offset)
  self.class.new(@addr + offset, family)
end

#-(offset) ⇒ IPAddr

Return the address less than the original address by the given offset. Note that the result will always be a host address.

Parameters:

  • offset (Integer) —

    the difference between the original address and the returned address

Returns:



48
49
50
 
# File 'lib/better_ipaddr/methods.rb', line 48

def -(offset)
  self + -offset
end

#<=>(other) ⇒ Integer

Compare this address with the integer representation of another address of the same address family.

Parameters:

  • other (Integer)

Returns:

  • (Integer) 


64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
 
# File 'lib/better_ipaddr/methods.rb', line 64

def <=>(other)
  if other.is_a?(IPAddr)
    family_difference = family <=> other.family
    return family_difference unless family_difference == 0
  elsif !other.is_a?(Integer)
    return nil
  end

  address_difference = to_i <=> other.to_i

  if address_difference != 0 || !other.is_a?(IPAddr)
    return address_difference
  end

  other.instance_variable_get(:@mask_addr) <=> @mask_addr
end

#==(other) ⇒ Boolean

Test the equality of two IP addresses, or an IP address an integer representing an address in the same address family.

Returns false for any other type.

Parameters:

  • other (IPAddr, Integer) —

    the address to compare with

Returns:

  • (Boolean) 


89
90
91
 
# File 'lib/better_ipaddr/methods.rb', line 89

def ==(other)
  (other.is_a?(IPAddr) || other.is_a?(Integer)) && (self <=> other) == 0
end

#[](offset) ⇒ IPAddr

The address at the given offset relative to the network address of the network. A negative offset will be used to count backwards from the highest addresses within the network. desired address

Parameters:

  • offset (Integer) —

    the index within the network of the

Returns:

  • (IPAddr) —

    the address at the given index



100
101
102
103
104
 
# File 'lib/better_ipaddr/methods.rb', line 100

def [](offset)
  return self if offset == 0 && host?
  offset2 = offset >= 0 ? offset : size + offset
  self.class[to_i + offset2, family: family]
end

#address_family_bit_length ⇒ Integer

Returns the number of bits allowed by the address family. A more efficient form of this method is available to the specialized IPAddr child classes.

Returns:

  • (Integer) 


112
113
114
 
# File 'lib/better_ipaddr/methods.rb', line 112

def address_family_bit_length
  FAMILY_TO_BIT_LENGTH.fetch(family)
end

#base(full: false) ⇒ String

Returns a string representation of the address without a prefix length.

Returns:

  • (String) 


120
121
122
123
124
125
126
 
# File 'lib/better_ipaddr/methods.rb', line 120

def base(full: false)
  if full
    to_string
  else
    stdlib_to_s
  end
end

#better_to_s(cidr: false, full: false) ⇒ Object 



128
129
130
131
132
133
134
 
# File 'lib/better_ipaddr/methods.rb', line 128

def better_to_s(cidr: false, full: false)
  if cidr
    "#{base(full: full)}/#{prefix_length}"
  else
    base(full: full)
  end
end

#cidr(cidr: nil, full: false) ⇒ String

Return a string containing the CIDR representation of the address.

Returns:

  • (String) 


140
141
142
 
# File 'lib/better_ipaddr/methods.rb', line 140

def cidr(cidr: nil, full: false)
  better_to_s(cidr: true, full: full)
end

#cover?(other) ⇒ Boolean

Test whether or not this address completely encloses the other address.

Returns:

  • (Boolean) 


146
147
148
 
# File 'lib/better_ipaddr/methods.rb', line 146

def cover?(other)
  first <= other.first && other.last <= last
end

#each ⇒ Enumerator

Return an enumerator with the behavior described above.

Returns:

  • (Enumerator) 


161
162
163
164
165
166
167
168
169
170
 
# File 'lib/better_ipaddr/methods.rb', line 161

def each
  if block_given?
    (0...size).each do |offset|
      yield self[offset]
    end
    self
  else
    enum_for(:each)
  end
end

#first ⇒ Object 



181
182
183
 
# File 'lib/better_ipaddr/methods.rb', line 181

def first
  self[0]
end

#grow(shift) ⇒ IPAddr

Return a new address with the prefix length reduced by the given amount. The new address will cover the original address.

Parameters:

  • shift (Integer) —

    the decrease in the prefix length

Returns:



190
191
192
 
# File 'lib/better_ipaddr/methods.rb', line 190

def grow(shift)
  mask(prefix_length - shift)
end

#hash ⇒ IPAddr

The first host address in the network.

Returns:



175
176
177
178
179
 
# File 'lib/better_ipaddr/methods.rb', line 175

def hash
  # see https://github.com/jruby/jruby/issues/4460
  # remove this override when specs still pass without it
  [self.class, @addr, @mask_addr, @family].hash
end

#host? ⇒ Boolean

Return true if the address represents a host (i.e., only one address).

Returns:

  • (Boolean) 


196
197
198
 
# File 'lib/better_ipaddr/methods.rb', line 196

def host?
  prefix_length >= address_family_bit_length
end

#inspect(cidr: true, full: false) ⇒ Object

Emits a snippet of ruby code that can be copied and pasted. Uses the string representation of the address, by default in CIDR notation, instead of the harder-to-read mask notation.

Returns:

  • String



24
25
26
 
# File 'lib/better_ipaddr/kernel_method.rb', line 24

def inspect(cidr: true, full: false)
  "#{self.class}['#{better_to_s(cidr: cidr, full: full)}']"
end

#last ⇒ IPAddr Also known as: broadcast

Return the last address in the network, which by convention is the broadcast address in IP networks.

Returns:



204
205
206
 
# File 'lib/better_ipaddr/methods.rb', line 204

def last
  self[-1]
end

#netmask ⇒ String

Return the string representation of the netmask.

Returns:

  • (String) 


26
27
28
 
# File 'lib/better_ipaddr/methods.rb', line 26

def netmask
  self.class[mask_addr].to_s
end

#overlap?(other) ⇒ Boolean

Test whether or not two networks have any addresses in common (i.e., if either entirely encloses the other).

Returns:

  • (Boolean) 


213
214
215
 
# File 'lib/better_ipaddr/methods.rb', line 213

def overlap?(other)
  cover?(other) || other.cover?(self)
end

#prefix_length ⇒ Integer Also known as: prefix, prefixlen

Return the prefix length. A more efficient form of this method is available to the specialized IPAddr child classes.

Returns:

  • (Integer) 


222
223
224
 
# File 'lib/better_ipaddr/methods.rb', line 222

def prefix_length
  NETMASK_TO_PREFIX_LENGTH[family][mask_addr]
end

#shrink(shift) ⇒ Boolean

Return a new address with the prefix length increased by the given amount. The old address will cover the new address.

Parameters:

  • shift (Integer) —

    the increase in the prefix length

Returns:

  • (Boolean) 


234
235
236
 
# File 'lib/better_ipaddr/methods.rb', line 234

def shrink(shift)
  mask(prefix_length + shift)
end

#size ⇒ Integer

Return the number of host addresses representable by the network given its size.

Returns:

  • (Integer) 


242
243
244
 
# File 'lib/better_ipaddr/methods.rb', line 242

def size
  2**(address_family_bit_length - prefix_length)
end

#summarize_with(other) ⇒ IPAddr?

Returns a summary address if the two networks can be combined into a single network without covering any other networks. Returns nil if the two networks can’t be combined this way.

Returns:



251
252
253
254
255
256
257
258
259
260
261
 
# File 'lib/better_ipaddr/methods.rb', line 251

def summarize_with(other)
  if other.nil?
    nil
  elsif cover?(other)
    self
  elsif other.cover?(self)
    other
  elsif other.grow(1) == grow(1)
    grow(1)
  end
end

#to_range ⇒ Range(IPAddr)

Return a range representing the network. A block can be given to specify a conversion procedure, for example to convert the first and last addresses to integers before building the range.

Returns:



268
269
270
271
272
273
274
 
# File 'lib/better_ipaddr/methods.rb', line 268

def to_range
  if block_given?
    (yield first)..(yield last)
  else
    first..last
  end
end

#wildcard ⇒ IPAddr

Return a wildcard mask representing the network.

Returns:



279
280
281
 
# File 'lib/better_ipaddr/methods.rb', line 279

def wildcard
  _to_string(@mask_addr.to_i ^ (2**address_family_bit_length - 1))
end