ruckus 0.5.4

data/lib/ruckus/extensions/hash.rb

@@ -0,0 +1,10 @@
+class Hash
+    module HashExtensions
+        # XXX does the same thing as Hash#invert i think?
+        def flip
+            # XXX not used
+            map {|k,v| [v,k]}.to_hash
+        end
+    end
+    include HashExtensions
+end

data/lib/ruckus/extensions/integer.rb

@@ -0,0 +1,26 @@
+class Integer
+    module IntegerExtensions
+        # Convert integers to binary strings
+        def to_l32; [self].pack "L"; end
+        def to_b32; [self].pack "N"; end
+        def to_l16; [self].pack "v"; end
+        def to_b16; [self].pack "n"; end
+        def to_u8; [self].pack "C"; end
+
+        # Print a number in hex
+        def to_hex(pre="0x"); pre + to_s(16); end
+
+        # Print a number in binary
+        def to_b(pre=""); pre + to_s(2); end
+
+        def ffs
+            i = 0
+            v = self
+            while((v >>= 1) != 0)
+                i += 1
+            end
+            return i
+        end
+    end
+    include IntegerExtensions
+end

data/lib/ruckus/extensions/ipaddr.rb

@@ -0,0 +1,155 @@
+require 'ipaddr'
+
+class IPAddr
+    attr_reader :mask_addr
+
+    module IPAddrExtensions
+
+        # ---------------------------------------------------------
+
+        # make an IP address take the int32 value provided
+
+        def set_int(ip)
+            set(ip, Socket::AF_INET)
+        end
+
+        # ---------------------------------------------------------
+
+        # randomize the "host" part of the IP address (destructive)
+
+        def random(mask=0xFFFFFFFF)
+            r = rand(0xFFFFFFFF) & mask
+            i = self.to_i & (~mask)
+            self.set_int(i | r)
+        end
+
+        alias_method :random!, :random
+
+        # ---------------------------------------------------------
+
+        # convert a string to IP
+
+        def inet_addr(str)
+            in_addr(str)
+        end
+
+        module ClassMethods
+            # ---------------------------------------------------------
+
+            # construct an IPAddr from a dotted quad string or integer
+
+            def inet_addr(str)
+                if str.kind_of? String
+                    IPAddr.lite(str).to_i
+                else
+                    i = IPAddr.new(0, Socket::AF_INET)
+                    i.set_int(str)
+                    return i
+                end
+            end
+
+            # ---------------------------------------------------------
+            # Convert 255.255.255.0 to 24
+            def mask2mlen(mask)
+                len = 0
+                while len < 32 && mask & 0x80000000 != 0
+                    mask <<= 1
+                    mask &= 0xFFFFFFFF
+                    len += 1
+                end
+                return len
+            end
+
+            # ---------------------------------------------------------
+
+            # construct an IPAddr from a dotted quad string without
+            # incurring a reverse lookup.
+
+            def lite(str)
+                # XXX self.new(0, Socket::AF_Inet, *args) instead?
+                ip = IPAddr.new(0, Socket::AF_INET)
+
+                parts = str.split "/"
+
+                ip.set_int(ip.inet_addr(parts[0]))
+                ip = ip.mask parts[1] if parts[1]
+                return ip
+            end
+        end
+
+        def self.included(klass)
+            klass.extend(ClassMethods)
+        end
+        # ---------------------------------------------------------
+
+        # to_s with a cidr prefix at the end
+
+        def to_cidr_s
+            # XXX not used
+            "#{ to_s }/#{ self.class.mask2mlen(@mask_addr) }"
+        end
+
+        # ---------------------------------------------------------
+
+        # get the mask length
+
+        def to_mlen
+            # XXX not used
+            mask = self.to_i
+            self.class.mask2mlen(mask)
+        end
+
+        # ---------------------------------------------------------
+
+        # get the highest address in the range defined by the netmask
+
+        def top
+            # XXX not used
+            # XXX should use self.class.inet_addr instead?
+            IPAddr.inet_addr(self.to_i | (0xFFFFFFFF & (~self.mask_addr)))
+        end
+
+        # ---------------------------------------------------------
+
+        # get the lowest address in the range defined by the netmask
+
+        def bottom
+            # XXX not used
+            # XXX should use self.class instead of IPAddr
+            IPAddr.inet_addr(self.to_i & self.mask_addr)
+        end
+
+        # ---------------------------------------------------------
+
+        # get a random address from within the range defined by the
+        # netmask.
+
+        def choice
+            # XXX not used
+            return self.clone if self.mask_addr == 0xFFFFFFFF
+
+            span = self.top.to_i - self.bottom.to_i
+            x = self.clone
+            x.set_int(self.bottom.to_i + rand(span))
+            return x
+        end
+
+        # ---------------------------------------------------------
+
+        # test if the address provided is in the range defined by the
+        # netmask
+
+        def contains(i)
+            # XXX not used
+            # XXX should use self.class instead of IPAddr
+            if not i.kind_of? IPAddr
+                i = IPAddr.inet_addr i
+            end
+
+            i.to_i >= self.bottom.to_i and i.to_i <= self.top.to_i
+        end
+
+        alias_method :contains?, :contains
+    end
+    include IPAddrExtensions
+end

data/lib/ruckus/extensions/irb.rb

@@ -0,0 +1,30 @@
+require 'irb'
+
+module IRB
+  # Lifted from http://errtheblog.com/posts/9-drop-to-irb
+  # Starts an IRB session with a specific binding. To use type:
+  # IRB.start_session(binding)
+  def self.start_session(binding)
+    # XXX not used
+    IRB.setup(nil)
+
+    workspace = WorkSpace.new(binding)
+
+    if @CONF[:SCRIPT]
+      irb = Irb.new(workspace, @CONF[:SCRIPT])
+    else
+      irb = Irb.new(workspace)
+    end
+
+    @CONF[:IRB_RC].call(irb.context) if @CONF[:IRB_RC]
+    @CONF[:MAIN_CONTEXT] = irb.context
+
+    trap("SIGINT") do
+      irb.signal_handle
+    end
+
+    catch(:IRB_EXIT) do
+      irb.eval_input
+    end
+  end
+end

data/lib/ruckus/extensions/math.rb

@@ -0,0 +1,6 @@
+module Math
+  # Ick. Why isn't this in the standard library? Ick.
+  def log2(x); log(x) / log(2); end
+  module_function :log2
+end
+

data/lib/ruckus/extensions/module.rb

@@ -0,0 +1,37 @@
+class Module
+    module ModuleExtensions
+        def to_name_hash
+            # XXX not used
+            @name_hash ||= constants.map {|k| [k.intern, const_get(k.intern)]}.to_hash
+        end
+
+        def to_key_hash
+            # XXX not used
+            @key_hash ||= constants.map {|k| [const_get(k.intern), k.intern]}.to_hash
+        end
+
+        def flag_dump(i)
+            # XXX not used
+            @bit_map ||= constants.map do |k|
+                [k, const_get(k.intern).ffs]
+            end.sort {|x, y| x[1] <=> y[1]}
+
+            last = 0
+            r = ""
+            @bit_map.each do |tup|
+                if((v = (tup[1] - last)) > 1)
+                    r << ("." * (v-1))
+                end
+
+                if((i & (1 << tup[1])) != 0)
+                    r << tup[0][0].chr
+                else
+                    r << tup[0][0].chr.downcase
+                end
+                last = tup[1]
+            end
+            return r.reverse
+        end
+    end
+    include ModuleExtensions
+end

data/lib/ruckus/extensions/numeric.rb

@@ -0,0 +1,117 @@
+class Numeric
+    module NumericExtensions
+        # XXX likely these should be moved to Integer
+
+        # This HAS TO BE in the library somewhere already, but: give a fixnum,
+        # cap it at some number (ie, max(x, y) -> x). 10.cap(9) => 9.
+        def cap(limit); self > limit ? limit : self; end
+
+        def to_x; to_s(16).rjust(8, "0"); end
+
+        def to_l32
+            [self].pack("L")
+        end
+
+        def to_l16
+            [self].pack("v")
+        end
+
+        def to_l8
+            (self&0xFF).chr
+        end
+
+        # sign extend
+        def sx8; ([self].pack "c").unpack("C").first; end
+        def sx16; ([self].pack "s").unpack("S").first; end
+        def sx32; ([self].pack "l").unpack("L").first; end
+
+        module ClassMethods
+            # Make a bitmask with m-many bits, as an Integer
+            def mask_for(m)
+                # This is just table lookup for values less than 65
+
+                @@mask ||= {
+                    1 => 0x1,
+                    2 => 0x3,
+                    3 => 0x7,
+                    4 => 0xf,
+                    5 => 0x1f,
+                    6 => 0x3f,
+                    7 => 0x7f,
+                    8 => 0xff,
+                    9 => 0x1ff,
+                    10 => 0x3ff,
+                    11 => 0x7ff,
+                    12 => 0xfff,
+                    13 => 0x1fff,
+                    14 => 0x3fff,
+                    15 => 0x7fff,
+                    16 => 0xffff,
+                    17 => 0x1ffff,
+                    18 => 0x3ffff,
+                    19 => 0x7ffff,
+                    20 => 0xfffff,
+                    21 => 0x1fffff,
+                    22 => 0x3fffff,
+                    23 => 0x7fffff,
+                    24 => 0xffffff,
+                    25 => 0x1ffffff,
+                    26 => 0x3ffffff,
+                    27 => 0x7ffffff,
+                    28 => 0xfffffff,
+                    29 => 0x1fffffff,
+                    30 => 0x3fffffff,
+                    31 => 0x7fffffff,
+                    32 => 0xffffffff,
+                    33 => 0x1ffffffff,
+                    34 => 0x3ffffffff,
+                    35 => 0x7ffffffff,
+                    36 => 0xfffffffff,
+                    37 => 0x1fffffffff,
+                    38 => 0x3fffffffff,
+                    39 => 0x7fffffffff,
+                    40 => 0xffffffffff,
+                    41 => 0x1ffffffffff,
+                    42 => 0x3ffffffffff,
+                    43 => 0x7ffffffffff,
+                    44 => 0xfffffffffff,
+                    45 => 0x1fffffffffff,
+                    46 => 0x3fffffffffff,
+                    47 => 0x7fffffffffff,
+                    48 => 0xffffffffffff,
+                    49 => 0x1ffffffffffff,
+                    50 => 0x3ffffffffffff,
+                    51 => 0x7ffffffffffff,
+                    52 => 0xfffffffffffff,
+                    53 => 0x1fffffffffffff,
+                    54 => 0x3fffffffffffff,
+                    55 => 0x7fffffffffffff,
+                    56 => 0xffffffffffffff,
+                    57 => 0x1ffffffffffffff,
+                    58 => 0x3ffffffffffffff,
+                    59 => 0x7ffffffffffffff,
+                    60 => 0xfffffffffffffff,
+                    61 => 0x1fffffffffffffff,
+                    62 => 0x3fffffffffffffff,
+                    63 => 0x7fffffffffffffff,
+                    64 => 0xffffffffffffffff
+                }
+
+                if (v = @@mask[m])
+                    return v
+                end
+
+                # Compute it for crazy values.
+
+                r = 0
+                0.upto(m-1) {|q| r |= (1 << q)}
+                return r
+            end
+        end
+
+        def self.included(klass)
+            klass.extend(ClassMethods)
+        end
+    end
+    include NumericExtensions
+end

data/lib/ruckus/extensions/object.rb

@@ -0,0 +1,22 @@
+class Object
+    module ObjectExtensions
+        # Every object has a "singleton" class, which you can think
+        # of as the class (ie, 1.metaclass =~ Fixnum) --- but that you
+        # can modify and extend without fucking up the actual class.
+
+        def metaclass; class << self; self; end; end
+        def meta_eval(&blk) metaclass.instance_eval &blk; end
+        def meta_def(name, &blk) meta_eval { define_method name, &blk }; end
+        def try(meth, *args); send(meth, *args) if respond_to? meth; end
+
+        def through(meth, *args)
+            if respond_to? meth
+                send(meth, *args)
+            else
+                self
+            end
+        end
+    end
+    include ObjectExtensions
+end
+

data/lib/ruckus/extensions/range.rb

@@ -0,0 +1,16 @@
+class Range
+    module RangeExtensions
+        # again, surprised this isn't in the library
+        def each_backwards
+            max.to_i.downto(min) {|i| yield i}
+        end
+
+        # Take a random number out of a range
+        #
+        def choice
+            rand(self.last - self.first) + self.first
+        end
+        alias_method :choose, :choice
+    end
+    include RangeExtensions
+end

data/lib/ruckus/extensions/socket.rb

@@ -0,0 +1,20 @@
+class Socket
+    module SocketExtensions
+        module ClassMethods
+            def addr(host, port=nil)
+                if not port
+                    raise "bad!" if not host =~ /(.*):(.*)/
+                    host = $1
+                    port = $2
+                end
+                port = port.to_i
+                Socket.pack_sockaddr_in(port, host)
+            end
+        end
+
+        def self.included(klass)
+            klass.extend(ClassMethods)
+        end
+    end
+    include SocketExtensions
+end