miketracy-wwmd 0.2.11

data/lib/wwmd/mixins.rb

@@ -0,0 +1,318 @@
+=begin rdoc
+mixins all around
+=end
+
+alias putd puts#:nodoc:
+alias putx puts#:nodoc:
+alias putw puts#:nodoc:
+
+# I really hate this
+class NilClass#:nodoc:
+  def empty?; return true; end
+  def size;   return 0;    end
+  def to_form; return FormArray.new([]); end
+  def clop; return nil; end
+  def inner_html; return nil; end
+  def get_attribute(*args); return nil; end
+  def grep(*args); return []; end
+  def escape(*args); return nil; end
+end
+
+class Numeric
+  # return binary representation of <tt>length</tt> size padded with \x00
+  #  length:  length in bytes to return (padded with least signficant \x00
+  #  reverse: reverse the byte order
+  def to_bin (len,rev = false)
+    str = ""
+    bignum = self
+    1.upto(len) do |i|
+      str << (bignum & 0xFF).to_n8
+      bignum = bignum >> 8  
+    end
+    return str.reverse if rev
+    return str
+  end
+
+  # integer to ip address
+  def int_to_ip
+    [24, 16, 8, 0].map { |b| (self >> b) & 255 }.join('.')
+  end
+
+  # integer to mac address [uses ':' as delimiter]
+  def int_to_mac
+    [40,32,24,16,8,0].map { |b| ((self >> b) & 255).to_s(16).rjust(2,"0") }.join(":")
+  end
+end
+
+class String
+
+  @@he = HTMLEntities.new
+
+  # ip address to int
+  def ip_to_int
+    self.split('.').inject(0) { |a,e| (a << 8) + e.to_i }
+  end
+
+  # mac address to int [uses ':' as delimiter]
+  def mac_to_int
+    self.split(':').inject(0) { |a,e| (a << 8) + e.to_i(16) }
+  end
+
+  # return true or false for <tt>string.match</tt>  
+  def contains?(rexp)
+    return !self.match(rexp).nil?
+  end
+
+  # strip the string and return true if empty
+  def empty?
+    return self.strip == ''
+  end
+
+  # return everything in the string (url) before the first get param
+  ## "http://foo.bar.com/page.asp?somearg=foo&otherarg=bar".clip  
+  ## => "http://foo.bar.com/page.asp"
+  def clip(pref="?")
+    if (v = self.index(pref))
+      return self[0..(v-1)]
+    end
+    return self
+  end
+
+  # return everything in the string (url) after the first get parameter
+  # without the leading '?'
+  #
+  # pass true as the second param to also get back the ?
+  ## "http://foo.bar.com/page.asp?somearg=foo&otherarg=bar".clop 
+  ## => "somearg=foo&otherarg=bar"
+  def clop(pref="?",preftoo=false)
+    (preftoo == false) ? add = "" : add = pref
+    if (v = self.index(pref))
+      return add + self[(v+1)..-1]
+    end
+    return nil
+  end
+
+  def clopp; self.clop("?",true); end #:nodoc:
+
+  def clopa
+    return [self.clip,self.clop]
+  end
+
+  # base 64 decode
+  def b64d
+    self.unpack("m").first
+  end
+
+  # base 64 encode
+  def b64e
+    [self].pack("m").chomp
+  end
+
+  # URI.escape using defaults or passed regexp
+  def escape(reg=WWMD::ESCAPE[:default],unicodify=false)
+    if reg == WWMD::ESCAPE[:none]
+      return self
+    elsif reg == WWMD::ESCAPE[:default]
+      ret = URI.escape(self)
+    elsif reg.kind_of?(Symbol)
+      ret = URI.escape(self,WWMD::ESCAPE[reg])
+      reg = WWMD::ESCAPE[reg]
+    else
+      ret = URI.escape(self,reg)
+    end
+    if unicodify
+      ret.gsub!(/%/,"%u00")
+    end
+    return ret
+  end
+
+  # URI.escape
+  def escape_url(reg=WWMD::ESCAPE[:url])#:nodoc:
+    self.escape(reg)
+  end
+
+  def escape_xss(reg=WWMD::ESCAPE[:xss])#:nodoc:
+    self.escape(reg)
+  end
+
+  def escape_default(reg=WWMD::ESCAPE[:default])
+    self.escape(reg)
+  end
+  # URI.escape all characters in string
+  def escape_all#:nodoc:
+    self.escape(/.*/)
+  end
+
+  # URI.unescape
+  def unescape
+    URI.unescape(self)
+  end
+
+  # encode the string using Encoding.to_utf7(self,false)
+  # (encode non [:alnum:] characters).  Set <tt>all</tt> true
+  # to encode all characters in the string.
+  def to_utf7(all=false)
+    Encoding.to_utf7(self,all)
+  end
+
+  # File.dirname with a trailing slash
+  def dirname
+    return self if self.match(/\/$/)
+    File.dirname(self) + "/"
+  end
+
+  # File.basename
+  def basename
+    File.basename(self)
+  end
+
+  def extname
+    self.split('.').last
+  end
+
+  # write string to passed filename
+  # if filename is nil? will raise an error
+  def write(fname=nil)
+    raise "filename required" if fname.nil?
+    File.write(fname,self)
+    return fname
+  end
+
+  def to_form_from_show
+    self.split("\n").map { |a|
+      key,val = a.split("=",2)
+      key = key.split(" ")[-1]
+      val = val.strip if val
+      ["#{key}=#{val}"]
+    }.join("&").to_form.squeeze_keys!
+  end
+
+  def mform
+    return self.gsub("\n","").to_form
+  end
+
+  # parse passed GET param string into a form and return the FormArray object
+  def to_form
+    if self.split("\n").size > 1
+      return self.to_form_from_show
+    end
+    ret = FormArray.new
+    self.split("&").each do |x|
+      y = x.split("=",2)
+      ret.extend!(y[0].to_s,y[1].to_s)
+    end
+    return ret
+  end
+
+  # create filename from url changing "/" to "_"
+  def to_fn(ext=nil)
+    ret = self.clip.split("/")[3..-1].join("_")
+    ret += ".#{ext}" if not ext.nil?
+    return ret
+  end
+
+  # html entity encode string
+  #  sym = :basic :named :decimal :hexadecimal
+  def eencode(sym=nil)
+    sym = :named if sym.nil?
+    @@he.encode(self,sym)
+  end
+
+  # decode html entities in string
+  def edecode
+    return @@he.decode(self)
+  end
+
+  def edecode!
+    self.replace(@@he.decode(self))
+  end
+
+  # strip html tags from string
+  def strip_html
+    self.gsub(/<\/?[^>]*>/, "")
+  end
+
+  # range or int
+  def head(c=5)
+    if c.kind_of?(Range) then
+      range = c
+    else
+      range = (0..(c - 1))
+    end
+    self.split("\n")[range].join("\n")
+  end
+
+  # return a literal regexp object for this string
+  #
+  # escape regexp operators
+  def to_regexp
+    return Regexp.new(self.gsub(/([\[\]\{\}\(\)\*\$\?])/) { |x| '\\' + x })
+  end
+
+  # check if this string is a guid
+  def is_guid?
+    begin
+      Guid.from_s(self)
+    rescue => e
+      return false
+    end
+    return true
+  end
+
+  def md5
+    Digest::MD5.digest(self).hexify
+  end
+
+  def sha1
+    Digest::SHA1.digest(self).hexify
+  end
+
+  def sha256
+    Digest::SHA256.digest(self).hexify
+  end
+
+  def sha512
+    Digest::SHA512.digest(self).hexify
+  end
+
+  def to_qp
+    [self].pack("M")
+  end
+
+  def from_qp
+    self.unpack("M").first
+  end
+end
+
+class Array
+  # grep each element of an array for the passed regular expression
+  # and return an Array of matches
+  # (only works one deep)
+  def each_grep(regex)
+    ret = []
+    self.each { |e| ret << e.grep(regex) }
+    return ret
+  end
+
+  # join the array with "\n" and write to a file
+  def to_file(filename)
+    File.write(filename,self.join("\n"))
+  end
+end
+
+class Hash#:nodoc:
+  # no idea what I was doing here
+  def to_f#:nodoc:
+    self.each_key { |l| puts "#{l} = " + self[l] }
+    return nil
+  end
+end
+
+class File
+  # write string to file
+  def self.write(filename,contents)
+    fout = File.open(filename,"w")
+    fout.print contents
+    fout.close
+  end
+end

data/lib/wwmd/mixins_extends.rb

@@ -0,0 +1,188 @@
+# Author Eric Monti (emonti@matasano.com)
+require "base64"
+require "stringio"
+require 'zlib'
+require 'open3'
+require 'sha1'
+
+HEXCHARS = [("0".."9").to_a, ("a".."f").to_a].flatten unless defined?(HEXCHARS)
+
+#-----------------------------------------------------------------------------
+# Mixins and class-specific items
+
+class Fixnum#:nodoc:
+  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
+  def to_l8;  chr; end
+  def to_n8;  chr; end
+  alias to_n32 to_b32
+  alias to_n16 to_b16
+  def to_n32; [self].pack "N"; end
+  def to_n16; [self].pack "n"; end
+
+  def self.from_l8(str); str[0]; end
+  def self.from_l16(str); (str.unpack "v")[0]; end
+  def self.from_l32(str); (str.unpack "V")[0]; end
+  def self.from_n8(str); str[0]; end
+  def self.from_n16(str); (str.unpack "n")[0]; end
+  def self.from_n32(str); (str.unpack "N")[0]; end
+end
+
+class String
+
+  # shortcut for hex sanity with regex
+  def ishex? ; (self =~ /^[a-f0-9]+$/i)? true : false ; end 
+
+  # Convert a string to ASCII hex string
+  # supports a few options for format:
+  #   :delim - delimter between each hex byte
+  #   :prefix - prefix before each hex byte
+  #   :suffix - suffix after each hex byte
+  # 
+  def hexify(opts={})
+    s=self
+    delim = opts[:delim]
+    pre = (opts[:prefix] || "")
+    suf = (opts[:suffix] || "")
+
+    if (rx=opts[:rx]) and not rx.kind_of? Regexp
+      raise "rx must be a regular expression for a character class"
+    end
+
+    out=Array.new
+
+    s.each_byte do |c| 
+      hc = if (rx and not rx.match c.chr)
+             c.chr 
+           else
+             pre + (HEXCHARS[(c >> 4)] + HEXCHARS[(c & 0xf )]) + suf
+           end
+      out << (hc)
+    end
+    out.join(delim)
+  end
+
+
+  # Convert ASCII hex string to raw
+  # supports only 'delimiter' between hex bytes
+  def unhexify(d=/\s*/)
+    s=self.strip
+    out=StringIO.new
+    while m = s.match(/^([A-Fa-f0-9]{1,2})#{d}?/) do
+      out.write m[1].hex.chr
+      s = m.post_match
+    end
+    out.string
+  end
+  alias_method :dehexify, :unhexify
+
+  # ==========================================================================
+  # Extends String class to return a hexdump in the style of 'hexdump -C'
+  #
+  # :len => optionally specify a length other than 16 for a wider or thinner 
+  # dump. If length is an odd number, it will be rounded up.
+  #
+  # :out => optionally specify an alternate IO object for output. By default,
+  # hexdump will output to STDOUT.  Pass a StringIO object and it will return 
+  # it as a string.
+  #
+  # Example:
+  # xxd = dat.hexdump(:len => 16, :out => StringIO.new)
+  # xxd => a hexdump
+  #
+  # xxd = dat.hexdump(:len => 16, :out => STDERR)
+  # xxd => nil
+  # ==========================================================================
+  def hexdump(opt={})
+    s=self
+    out = opt[:out] || StringIO.new
+    len = (opt[:len] and opt[:len] > 0)? opt[:len] + (opt[:len] % 2) : 16
+
+    off = opt[:start_addr] || 0
+    offlen = opt[:start_len] || 8
+
+    hlen=len/2
+
+    s.scan(/(?:.|\n){1,#{len}}/) do |m|
+      out.write(off.to_s(16).rjust(offlen, "0") + '  ')
+
+      i=0
+      m.each_byte do |c|
+        out.write c.to_s(16).rjust(2,"0") + " "
+        out.write(' ') if (i+=1) == hlen
+      end
+
+      out.write("   " * (len-i) ) # pad
+      out.write(" ") if i < hlen
+
+      out.write(" |" + m.tr("\0-\37\177-\377", '.') + "|\n")
+      off += m.length
+    end
+
+    out.write(off.to_s(16).rjust(offlen,'0') + "\n")
+
+    if out.class == StringIO
+      out.string
+    end
+  end
+
+
+  # ==========================================================================
+  # converts a hexdump back to binary - takes the same options as hexdump()
+  # fairly flexible. should work both with 'xxd' and 'hexdump -C' style dumps
+  def dehexdump(opt={})
+    s=self
+    out = opt[:out] || StringIO.new
+    len = (opt[:len] and opt[:len] > 0)? opt[:len] : 16
+
+    hcrx = /[A-Fa-f0-9]/
+    dumprx = /^(#{hcrx}+):?\s*((?:#{hcrx}{2}\s*){0,#{len}})/
+    off = opt[:start_addr] || 0
+
+    i=1
+    # iterate each line of hexdump
+    s.split(/\r?\n/).each do |hl|
+      # match and check offset
+      if m = dumprx.match(hl) and $1.hex == off
+        i+=1
+        # take the data chunk and unhexify it
+        raw = $2.unhexify
+        off += out.write(raw)
+      else
+        raise "Hexdump parse error on line #{i} #{s}"
+      end
+    end
+
+    if out.class == StringIO
+      out.string
+    end
+  end
+  alias_method :dedump, :dehexdump
+
+  # Does string "start with" dat?
+  # no clue whether/when this is faster than a regex, but it is easier 
+  # than escaping regex characters
+  def starts_with?(dat)
+    self[0,dat.size] == dat
+  end
+
+  # returns CRC32 checksum for the string object
+  def crc32
+    Zlib.crc32 self
+  end
+
+  def swap16; unpack("v*").pack("n*"); end
+  def to_utf16; Kconv.kconv(self, NKF::UTF16, NKF::ASCII).swap16; end
+  def to_ascii; Kconv.kconv(swap16, NKF::ASCII, NKF::UTF16); end
+
+end # class String
+
+
+class Float
+  def log2; Math.log(self)/Math.log(2); end
+end
+
+__END__