wwmd 0.2.20.3

data/lib/wwmd/class_extensions/extensions_encoding.rb

@@ -0,0 +1,79 @@
+require 'wwmd/class_extensions/mixins_string_encoding'
+class String
+  include WWMD::Encoding
+
+  @@he = HTMLEntities.new
+
+  # base 64 decode
+  def b64d
+    self.unpack("m").first
+  end
+
+  # base 64 encode
+  def b64e
+    [self].pack("m").gsub("\n","")
+  end
+
+  # URI.escape using defaults or passed regexp
+  def escape(reg=nil,unicodify=false)
+    if reg.nil?
+      ret = URI.escape(self)
+    elsif reg.kind_of?(Symbol)
+      case reg
+        when :none; return self
+        when :default; ret =  URI.escape(self)
+        else; ret =  URI.escape(self,WWMD::ESCAPE[reg])
+      end
+    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
+
+  # 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
+
+  # quoted printable
+  def to_qp
+    [self].pack("M")
+  end
+
+  def from_qp
+    self.unpack("M").first
+  end
+
+end

data/lib/wwmd/class_extensions/extensions_external.rb

@@ -0,0 +1,18 @@
+module REXML
+  class Element
+
+    # pretty print (indent=0) to stdout or filename [fn]
+    def pp(fn=nil)
+      tmp = ""
+      self.write(tmp,0)
+      if fn
+        tmp.write(fn)
+        return fn
+      else
+        return tmp
+      end
+      nil
+    end
+
+  end
+end

data/lib/wwmd/class_extensions/extensions_nilclass.rb

@@ -0,0 +1,11 @@
+# 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

data/lib/wwmd/class_extensions/extensions_rbkb.rb

@@ -0,0 +1,193 @@
+# 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 
+
+=begin
+  # 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
+=end
+
+  # ==========================================================================
+  # 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
+
+  def hdp
+    puts hexdump
+  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__

data/lib/wwmd/class_extensions/mixins_string_encoding.rb

@@ -0,0 +1,40 @@
+=begin rdoc
+Place methods to character encodings here
+=end
+
+module WWMD
+  # This is where character encodings should go as module methods
+  # to be used as mixins for the String class
+  module Encoding
+
+    # String.to_utf7 mixin
+    # (complete hack but it works)
+    #
+    # if all=true, encode all characters.
+    # if all.class=Regexp encode only characters in the passed
+    # regular expression else default to /[^0-9a-zA-Z]/
+    #
+    # used by:
+    #  String.to_utf7
+    #  String.to_utf7!
+    def to_utf7(all=nil)
+      if all.kind_of?(Regexp)
+        reg = all
+      elsif all.kind_of?(TrueClass)
+        reg = ESCAPE[:all]
+      else
+        reg = ESCAPE[:nalnum] || /[^a-zA-Z0-9]/
+      end
+      putd "DEBG:" + reg.inspect
+      ret = ''
+      self.each_byte do |b|
+        if b.chr.match(reg)
+          ret += "+" + Base64.encode64(b.chr.toutf16)[0..2] + "-"
+        else
+          ret += b.chr
+        end
+      end
+      return ret
+    end
+  end
+end

data/lib/wwmd/guid.rb

@@ -0,0 +1,155 @@
+=begin rdoc
+Guid - Ruby library for portable GUID/UUID generation.
+
+Copyright (c) 2004 David Garamond <davegaramond at icqmail com>
+
+This library is free software; you can redistribute it and/or modify it
+under the same terms as Ruby itself.
+
+(small hack to fix for mac mtracy@matasano.com)
+=end
+
+if RUBY_PLATFORM =~ /win/i && ! RUBY_PLATFORM =~ /darwin/i
+  module Guid_Win32_#:nodoc:
+    require 'Win32API'
+          
+    PROV_RSA_FULL       = 1
+    CRYPT_VERIFYCONTEXT = 0xF0000000
+    FORMAT_MESSAGE_IGNORE_INSERTS  = 0x00000200
+    FORMAT_MESSAGE_FROM_SYSTEM     = 0x00001000
+  
+    CryptAcquireContext = Win32API.new("advapi32", "CryptAcquireContext",
+                                       'PPPII', 'L')
+    CryptGenRandom = Win32API.new("advapi32", "CryptGenRandom", 
+                                  'LIP', 'L')
+    CryptReleaseContext = Win32API.new("advapi32", "CryptReleaseContext",
+                                       'LI', 'L')
+    GetLastError = Win32API.new("kernel32", "GetLastError", '', 'L')
+    FormatMessageA = Win32API.new("kernel32", "FormatMessageA",
+                                  'LPLLPLPPPPPPPP', 'L')
+  
+    def lastErrorMessage
+      code = GetLastError.call
+      msg = "\0" * 1024
+      len = FormatMessageA.call(FORMAT_MESSAGE_IGNORE_INSERTS +
+                                FORMAT_MESSAGE_FROM_SYSTEM, 0,
+                                code, 0, msg, 1024, nil, nil,
+                                nil, nil, nil, nil, nil, nil)
+      msg[0, len].tr("\r", '').chomp
+    end
+  
+    def initialize
+      hProvStr = " " * 4
+      if CryptAcquireContext.call(hProvStr, nil, nil, PROV_RSA_FULL,
+                                  CRYPT_VERIFYCONTEXT) == 0
+        raise SystemCallError, "CryptAcquireContext failed: #{lastErrorMessage}"
+      end
+      hProv, = hProvStr.unpack('L')
+      @bytes = " " * 16
+      if CryptGenRandom.call(hProv, 16, @bytes) == 0
+        raise SystemCallError, "CryptGenRandom failed: #{lastErrorMessage}"
+      end
+      if CryptReleaseContext.call(hProv, 0) == 0
+        raise SystemCallError, "CryptReleaseContext failed: #{lastErrorMessage}"
+      end
+    end
+  end
+end
+
+module Guid_Unix_#:nodoc:
+  @@random_device = nil
+  
+  def initialize
+    if !@@random_device
+      if File.exists? "/dev/urandom"
+        @@random_device = File.open "/dev/urandom", "r"
+      elsif File.exists? "/dev/random"
+        @@random_device = File.open "/dev/random", "r"
+      else
+        raise RuntimeError, "Can't find random device"
+      end
+    end
+
+    @bytes = @@random_device.read(16)
+  end
+end
+  
+class Guid
+  if RUBY_PLATFORM =~ /win/ && ! RUBY_PLATFORM =~ /darwin/i
+    include Guid_Win32_
+  else
+    include Guid_Unix_
+  end
+
+  def hexdigest
+    @bytes.unpack("h*")[0]
+  end
+  
+  def to_s
+    @bytes.unpack("h8 h4 h4 h4 h12").join "-"
+  end
+  
+  def inspect
+    to_s
+  end
+  
+  def raw
+    @bytes
+  end
+  
+  def self.from_s(s)
+    raise ArgumentError, "Invalid GUID hexstring" unless
+      s =~ /\A[0-9a-f]{8}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{12}\z/i
+    guid = Guid.allocate
+    guid.instance_eval { @bytes = [s.gsub(/[^0-9a-f]+/i, '')].pack "h*" }
+    guid
+  end
+
+  def self.from_raw(bytes)
+    raise ArgumentError, "Invalid GUID raw bytes, length must be 16 bytes" unless
+      bytes.length == 16
+    guid = Guid.allocate
+    guid.instance_eval { @bytes = bytes }
+    guid
+  end
+  
+  def ==(other)
+    @bytes == other.raw
+  end
+end
+
+if __FILE__ == $0
+  require 'test/unit'
+  
+  class GuidTest < Test::Unit::TestCase#:nodoc:
+    def test_new
+      g = Guid.new
+      
+      # different representations of guid: hexdigest, hex+dashes, raw bytes
+      assert_equal(0, g.to_s =~ /\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/)
+      assert_equal(16, g.raw.length)
+      assert_equal(0, g.hexdigest =~ /\A[0-9a-f]{32}\z/)
+      assert_equal(g.hexdigest, g.to_s.gsub(/-/, ''))
+
+      # must be different each time we produce (this is just a simple test)
+      g2 = Guid.new
+      assert_equal(true, g != g2)
+      assert_equal(true, g.to_s != g2.to_s)
+      assert_equal(true, g.raw != g2.raw)
+      assert_equal(true, g.hexdigest != g2.hexdigest)
+      assert_equal(1000, (1..1000).select { |i| g != Guid.new }.length)
+    end
+    
+    def test_from_s
+      g = Guid.new
+      g2 = Guid.from_s(g.to_s)
+      assert_equal(g, g2)
+    end
+    
+    def test_from_raw
+      g = Guid.new
+      g2 = Guid.from_raw(g.raw)
+      assert_equal(g, g2)
+    end
+  end
+end