tduehr-libmatty 0.9.0

data/lib/libmatty/fixnum.rb

@@ -0,0 +1,25 @@
+class Fixnum
+    module FixnumExtensions
+        # Ridiculous that this isn't in the library.
+        def printable?; self >= 0x20 and self <= 0x7e; end
+
+        # Like Numeric#Step, but yields the length of each span along with
+        # the offset. Useful for stepping through data in increments:
+        # 0.stepwith(buffer.size, 4096) {|off,len| pp buffer[off,len]}
+        # The "len" parameter accounts for the inevitable short final block.
+        def stepwith(limit, stepv, &block)
+            step(limit, stepv) do |i|
+                remt = limit - i
+                yield i, remt.cap(stepv)
+            end
+        end
+
+        # you can't clone a fixnum? Why?
+        def clone; self; end
+
+        def upper?; self >= 0x41 and self <= 0x5a; end
+        def lower?; self >= 0x61 and self <= 0x7a; end
+    end
+    include FixnumExtensions
+end
+

data/lib/libmatty/hash.rb

@@ -0,0 +1,47 @@
+class Hash
+    module HashExtensions
+        # XXX does the same thing as Hash#invert i think?
+        def flip
+            map {|k,v| [v,k]}.to_hash
+        end
+        
+        # Model.create(params.deny_keys(:password, :isadmin))
+        ##
+        def allow_keys(*keys)
+            tmp = self.clone
+            tmp.delete_if {|k,v| ! keys.include?(k) }
+            tmp
+        end
+
+        def allow_keys!(*keys)
+            delete_if{|k,v| ! keys.include?(k) }
+        end
+
+        # Filter a list of keys, rejecting the ones we don't
+        # want to allow through.
+        def deny_keys(*keys)
+            tmp = self.clone
+            tmp.delete_if {|k,v| keys.include?(k) }
+            tmp
+        end
+
+        # {:foo=>"bar"}.xfrm(:foo => :meep) ==> {:meep=>"bar"}
+        def xfrm(opts={})
+            self.map do |k,v|
+                x = [opts.fetch(k, k), v]
+                pp x
+                x
+            end.to_h
+        end
+        class KeyRequired < RuntimeError; end
+
+        def demand(*args)
+            args.each do |a|
+                if not self.has_key? a
+                    raise KeyRequired, "option #{ a } required"
+                end
+            end
+        end
+    end
+    include HashExtensions
+end

data/lib/libmatty/integer.rb

@@ -0,0 +1,120 @@
+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
+
+        # 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
+
+        # 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 clear_bits(c); (self ^ (self & c)); end
+
+        def ffs
+            i = 0
+            v = self
+            while((v >>= 1) != 0)
+                i += 1
+            end
+            return i
+        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 IntegerExtensions
+end

data/lib/libmatty/ipaddr.rb

@@ -0,0 +1,113 @@
+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
+
+          # construct an IPAddr from a dotted quad string without
+          # incurring a reverse lookup.
+          def lite(str)
+            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
+
+          # 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
+        end
+
+        def self.included(klass)
+            klass.extend(ClassMethods)
+        end
+
+        # to_s with a cidr prefix at the end
+        def to_cidr_s
+            "#{ to_s }/#{ self.class.mask2mlen(@mask_addr) }"
+        end
+
+        # get the mask length
+        def to_mlen
+            mask = self.to_i
+            self.class.mask2mlen(mask)
+        end
+
+
+        # get the highest address in the range defined by the netmask
+        def top
+            IPAddr.inet_addr(self.to_i | (0xFFFFFFFF & (~self.mask_addr)))
+        end
+
+        # get the lowest address in the range defined by the netmask
+        def bottom
+            IPAddr.inet_addr(self.to_i & self.mask_addr)
+        end
+
+        # get a random address from within the range defined by the
+        # netmask.
+        def choice
+            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)
+            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/libmatty/irb.rb

@@ -0,0 +1,29 @@
+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)
+    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/libmatty/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/libmatty/module.rb

@@ -0,0 +1,67 @@
+class Module
+    module ModuleExtensions
+        def to_name_hash
+            @name_hash ||= constants.map {|k| [k.intern, const_get(k.intern)]}.to_hash
+        end
+
+        def to_key_hash
+            @key_hash ||= constants.map {|k| [const_get(k.intern), k.intern]}.to_hash
+        end
+
+        def flag_dump(i)
+            @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
+
+        # When the base class method just returns nil
+        def stub(*args)
+            opts = {}
+            if args[-1].kind_of? Hash
+                opts = args[-1]
+                args = args[0..-2]
+            end
+
+            args.each do |meth|
+                class_def(meth) do |*a|; nil; end
+            end
+        end
+
+        # Dynamically create instance methods
+        def class_def(name, &blk)
+            class_eval { define_method name, &blk }
+        end
+
+        module ClassMethods
+          # like const_get, but doesn't raise exception if sym not found.
+          def const_find(sym)
+              begin
+                  const_get(sym)
+              rescue
+                  nil
+              end
+          end
+        end
+
+        def self.included(klass)
+          klass.extend ClassMethods
+        end
+    end
+    include ModuleExtensions
+end

data/lib/libmatty/numeric.rb

@@ -0,0 +1,12 @@
+class Numeric
+    module NumericExtensions
+        # 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
+
+        # shortcut for packing a single number...
+        def pack(arg) ; [self].pack(arg) ; end
+
+    end
+    include NumericExtensions
+end

data/lib/libmatty/object.rb

@@ -0,0 +1,33 @@
+class Object
+    module ObjectExtensions
+      # don't need these if we're using 1.9
+      if not Object::RUBY_FRAMEWORK_VERSION == "1.9"
+        # 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
+
+      def pbpaste
+        `pbpaste`
+      end if RUBY_PLATFORM =~ /darwin/
+
+      ## This is from Topher Cyll's Stupd IRB tricks
+      def mymethods
+        (self.methods - self.class.superclass.methods).sort
+      end
+    end
+    include ObjectExtensions
+end