emonti-rbkb 0.6.2.1 → 0.6.6

data/lib/rbkb/cli/unhexify.rb

@@ -40,13 +40,9 @@ class Rbkb::Cli::Unhexify < Rbkb::Cli::Executable
     @opts[:indat] ||= @stdin.read() 
 
     @opts[:indat].delete!("\r\n")
-    @opts[:delim] ||= /\s*/
+    @opts[:delim] ||= Regexp.new('\s*')
 
-    unless out = @opts[:indat].unhexify(@opts[:delim])
-      bail "Error: Failed parsing as hex"
-    end
-
-    @stdout << out
+    @stdout << @opts[:indat].unhexify(@opts[:delim])
 
     self.exit(0)
   end

data/lib/rbkb/cli/urldec.rb

@@ -29,6 +29,7 @@ class Rbkb::Cli::Urldec < Rbkb::Cli::Executable
     # Default to standard input
     @opts[:indat] ||= @stdin.read()
     @stdout << @opts[:indat].urldec(:noplus => @opts[:noplus])
+    self.exit(0)
   end
 end
 

data/lib/rbkb/cli/urlenc.rb

@@ -30,5 +30,6 @@ class Rbkb::Cli::Urlenc < Rbkb::Cli::Executable
     # Default to standard input
     @opts[:indat] ||= @stdin.read()
     @stdout << @opts[:indat].urlenc(:plus => @opts[:plus]) + "\n"
+    self.exit(0)
   end
 end

data/lib/rbkb/extends.rb

@@ -390,11 +390,9 @@ class String
   #   If strings are null terminated, the trailing null *IS* included
   #   in the end_offset. Unicode matches will also include null bytes.
   #
-  # TODO? 
+  # Todos?
   #    - better unicode support (i.e. not using half-assed unicode)
   #    - support other encodings such as all those the binutils strings does?
-  #    - not sure if we want the trailing null in null terminated strings
-  #    - not sure if we want wide characters to include their null bytes
   def strings(opts={})
     opts[:encoding] ||= :both
     prx = (opts[:valid] || /[\r\n [:print:]]/)
@@ -466,7 +464,7 @@ class String
 
   # returns CRC32 checksum for the string object
   def crc32
-    ## XXX slower, but here for reference (found on some forum)
+    ## pure ruby version. slower, but here for reference (found on some forum)
     #  r = 0xFFFFFFFF
     #  self.each_byte do |b|
     #    r ^= b
@@ -493,6 +491,34 @@ class String
     ret
   end
 
+  # Converts a '_' delimited string to CamelCase like 'foo_class' into 
+  # 'FooClass'.
+  # See also: camelize_meth, decamelize
+  def camelize
+    self.gsub(/(^|_)([a-z])/) { $2.upcase }
+  end
+
+  # Converts a '_' delimited string to method style camelCase like 'foo_method'
+  # into 'fooMethod'.
+  # See also: camelize, decamelize
+  def camelize_meth
+    self.gsub(/_([a-z])/) { $1.upcase }
+  end
+  
+
+  # Converts a CamelCase or camelCase string into '_' delimited form like
+  # 'FooBar' or 'fooBar' into 'foo_bar'. 
+  #
+  # Note: This method only handles camel humps. Strings with consecutive 
+  # uppercase chars like 'FooBAR' will be converted to 'foo_bar'
+  #
+  # See also: camelize, camelize_meth
+  def decamelize
+    self.gsub(/(^|[a-z])([A-Z])/) do 
+      ($1.empty?)? $2 : "#{$1}_#{$2}"
+    end.downcase
+  end
+
   # convert a string to its idiomatic ruby class name
   def class_name
     r = ""
@@ -523,8 +549,14 @@ class String
     end
   end
 
+  # Return a self encapsulated in a StringIO object. This is handy.
+  def to_stringio
+    StringIO.new(self)
+  end
+
 end # class String
 
+
 class Symbol
   # looks up this symbol as a constant defined in 'ns' (Object by default)
   def const_lookup(ns=Object)
@@ -535,8 +567,11 @@ end
 class Array
   # randomizes the order of contents in the Array (self)
   def randomize  ; self.sort_by { rand } ; end
-end
 
+  # Returns a randomly chosen element from self.
+  # Drew *is* sparta.
+  def rand_elem;  self[rand(self.length)] ; end
+end
 
 class Float
   def log2; Math.log(self)/Math.log(2); end
@@ -612,7 +647,7 @@ class Numeric
     }.join
   end
 
-  # XXX TODO Fixme for new to_bytes/char etc.
+  # TODO Fix Numeric.to_guid for new to_bytes/char etc.
 #  def to_guid(order=Rbkb::DEFAULT_BYTE_ORDER)
 #    raw = self.to_bytes(order, 16)
 #    a,b,c,d,*e = raw.unpack("VvvnC6").map{|x| x.to_hex}

data/lib/rbkb/http.rb

@@ -0,0 +1,20 @@
+
+# ???Why???? would anyone create their own HTTP implementation in ruby with 
+# so many options out there? Short answer: Net:HTTP and others just don't cut 
+# it in lots of edge cases. I needed something I could control completely.
+
+module Rbkb
+  module Http
+    VERSION = "0.0.2"
+  end
+end
+
+require "rbkb/http/common.rb"
+require "rbkb/http/base.rb"
+require "rbkb/http/request.rb"
+require "rbkb/http/response.rb"
+require "rbkb/http/headers.rb"
+require "rbkb/http/body.rb"
+require "rbkb/http/parameters.rb"
+
+

data/lib/rbkb/http/base.rb

@@ -0,0 +1,172 @@
+module Rbkb::Http
+
+  # A base class containing some common features for Request and Response 
+  # objects.
+  #
+  # Don't use this class directly, it's intended for being overridden
+  # from its derived classes or mixins.
+  class Base
+    include CommonInterface
+
+    def self.parse(*args)
+      new(*args)
+    end
+
+    # Initializes a new Base object
+    def initialize(*args)
+      _common_init(*args)
+    end
+
+    # This method parses just HTTP message body. Expects body to be split
+    # from the headers before-hand.
+    def capture_body(bstr)
+      self.body ||= default_body_obj
+      @body.capture(bstr)
+    end
+
+    # XXX stub
+    def first_entity
+      @first_entity
+    end
+
+    # XXX stub
+    def first_entity=(f)
+      @first_entity=(f)
+    end
+
+    # This method parses only HTTP response headers. Expects headers to be 
+    # split from the body before-hand.
+    def capture_headers(hstr)
+      self.headers ||= default_headers_obj
+
+      if @body and not @body.capture_complete?
+        return 
+      elsif @headers.capture_complete?
+        self.first_entity, @headers = default_headers_obj.capture_full_headers(hstr)
+      else 
+        @headers.capture(hstr)
+      end
+    end
+
+    # This method returns the content length from Headers. This is
+    # mostly useful if you are using a BoundBody object for the body.
+    # 
+    # Returns nil if no "Content-Length" is not found.
+    #
+    # The opts parameter :ignore_content_length affects this method and 
+    # will cause it always to return nil. This is useful, for example,
+    # for the responses to the HTTP HEAD request method, which return
+    # a Content-Length without actual content.
+    #
+    def content_length(hdrs=@headers)
+      raise "headers is nil?" if not hdrs
+      if( (not @opts[:ignore_content_length]) and 
+          hdrs.get_header_value("Content-Length").first =~ /^(\d+)$/ )
+
+        $1.to_i
+      end
+    end
+
+    def attach_new_header(hdr_obj=nil)
+      self.headers = hdr_obj
+      return hdr_obj
+    end
+
+    def attach_new_body(body_obj=nil)
+      self.body = body_obj
+      return body_obj
+    end
+
+    # XXX doc override!
+    def default_headers_obj(*args)
+      Header.new(*args)
+    end
+
+    # XXX doc override!
+    def default_body_obj(*args)
+      Body.new(*args)
+    end
+
+    # This method will non-destructively reset the capture state on this 
+    # object and all child entities. Note, however, If child entities are not 
+    # defined, it may instantiate new ones. 
+    # See also: capture_complete?, reset_capture!
+    def reset_capture
+      if @headers
+        @headers.reset_capture if not @headers.capture_complete?
+      else
+        attach_new_header()
+      end
+
+      if @body
+        @body.reset_capture if not @body.capture_complete? 
+      else
+        attach_new_body()
+      end
+      @capture_state = nil
+      self
+    end
+
+    # This method will destructively reset the capture state on this object.
+    # It does so by initializing fresh child entities and discarding the old
+    # ones. See also: capture_complete?, reset_capture
+    def reset_capture!
+      attach_new_header()
+      attach_new_body()
+      @capture_state = nil
+      self
+    end
+
+    # Indicates whether this object is ready to capture fresh data, or is
+    # waiting for additional data or a reset from a previous incomplete or 
+    # otherwise broken capture. See also: reset_capture, reset_capture!
+    def capture_complete?
+      if( (@headers and not @headers.capture_complete?) or
+          (@body and not @body.capture_complete?) )
+        return false
+      else
+        true
+      end
+    end
+
+    attr_reader :body, :headers
+
+    # This accessor will attempt to always do the "right thing" while
+    # setting this object's body entity. 
+    #
+    # See also: default_body_obj
+    def body=(b)
+      if @body
+        @body.data = b
+      elsif b.kind_of? Body
+        @body = b.dup
+        @body.opts = b.opts
+      else
+        @body = default_body_obj(b)
+      end
+      @body.base = self
+      return @body
+    end
+
+    # This accessor will attempt to always do the "right thing" while
+    # setting this object's headers entity. 
+    #
+    # See also: default_headers_obj
+    def headers=(h)
+      if @headers
+        @headers.data = h
+      elsif h.kind_of? Headers
+        @headers = h.dup
+        @headers.opts = h.opts
+      else
+        @headers = default_headers_obj(h)
+      end
+      @headers.base = self
+      return @body
+    end
+
+  end
+
+
+end
+

data/lib/rbkb/http/body.rb

@@ -0,0 +1,214 @@
+require 'stringio'
+
+module Rbkb::Http
+  class Body < String
+    include CommonInterface
+
+    def self.parse(str)
+      new().capture(str)
+    end
+
+    attr_reader :expect_length
+
+    def initialize(str=nil, opts=nil)
+      self.opts = opts
+      if Body === str
+        self.replace(str)
+        @opts = str.opts.merge(@opts)
+      elsif String === str 
+        super(str)
+      else
+        super()
+      end
+
+      yield(self) if block_given?
+    end
+
+    # The capture method is used when parsing HTTP requests/responses.
+    # This can and probably should be overridden in derived classes.
+    def capture(str)
+      yield(str) if block_given?
+      self.data=(str)
+    end
+
+    # The to_raw method is used when writing HTTP requests/responses.
+    # This can and probably should be overridden in derived classes.
+    def to_raw
+      (block_given?) ? yield(self.data) : self.data
+    end
+
+    attr_reader :base
+
+    def base=(b)
+      if b.nil? or b.is_a? Base
+        @base = b
+      else
+        raise "base must be a Response or Request object or nil" 
+      end
+    end
+
+    def data
+      self
+    end
+
+    # Sets internal raw string data without any HTTP decoration.
+    def data=(str)
+      self.replace(str.to_s)
+    end
+
+    # Returns the content length from the HTTP base object if
+    # there is one and content-length is available.
+    def get_content_length
+      @base.content_length if @base
+    end
+
+    # This method will non-destructively reset the capture state on this object.
+    # It is non-destructive in that it will not affect existing captured data 
+    # if present.
+    def reset_capture
+      @expect_length = nil
+      @base.reset_capture() if @base and @base.capture_complete?
+    end
+
+    # This method will destructively reset the capture state on this object.
+    # This method is destructive in that it will clear any previously captured
+    # data.
+    def reset_capture!
+      reset_capture()
+      self.data=""
+    end
+
+    def capture_complete?
+      not @expect_length
+    end
+  end
+
+
+  # BoundBody is designed for handling an HTTP body when using the usual
+  # "Content-Length: NNN" HTTP header.
+  class BoundBody < Body
+
+    # This method may throw :expect_length with one of the following values
+    # to indicate certain content-length conditions:
+    #
+    #   > 0 :   Got incomplete data in this capture. The object expects
+    #           capture to be called again with more body data.
+    #
+    #   < 0 :   Got more data than expected, the caller should truncate and 
+    #           handle the extra data in some way. Note: Calling capture again
+    #           on this instance will start a fresh body capture.
+    #
+    # Caller can also detect the above conditions by checking the expect_length 
+    # attribute but should still be prepared handle the throw().
+    #
+    #  0/nil:  Got exactly what was expected. Caller can proceed with fresh
+    #          captures on this or other Body objects.
+    #
+    # See also reset_capture and reset_capture!
+    def capture(str)
+      raise "arg 0 must be a string" unless String === str
+
+      # Start fresh unless we're expecting more data
+      self.data="" unless @expect_length and @expect_length > 0
+
+      if not clen=get_content_length()
+        raise "content-length is unknown. aborting capture"
+      else
+        @expect_length = clen - (self.size + str.size)
+        self << str[0, clen - self.size]
+        if @expect_length > 0
+          throw(:expect_length, @expect_length)
+        elsif @expect_length < 0
+          throw(:expect_length, @expect_length)
+        else
+          reset_capture()
+        end
+      end
+      return self
+    end
+
+    def to_raw(*args)
+      if @base
+        @base.headers.set_header("Content-Length", self.size)
+      end
+      super(*args)
+    end
+  end
+
+
+  # ChunkedBody is designed for handling an HTTP body when using a
+  # "Transfer-Encoding: chunked" HTTP header.
+  class ChunkedBody < Body
+    DEFAULT_CHUNK_SIZE = 2048
+
+    # Throws :expect_length with 'true' when given incomplete data and expects 
+    # to be called again with more body data to parse. 
+    #
+    # The caller can also detect this condition by checking the expect_length 
+    # attribute but must still handle the throw().
+    #
+    # See also reset_capture and reset_capture!
+    def capture(str)
+      # chunked encoding is gross...
+      if @expect_length
+        sio = StringIO.new(@last_chunk.to_s + str)
+      else
+        sio = StringIO.new(str)
+        self.data=""
+      end
+      @last_chunk = nil
+
+      @expect_length = true
+      while not sio.eof?
+        unless m=/^([a-fA-F0-9]+)\s*(;[[:print:]\s]*)?\r?\n$/.match(line=sio.readline)
+          raise "invalid chunk at #{line.chomp.inspect}"
+        end
+        if (chunksz = m[1].hex) == 0
+          @expect_length = false
+          # XXX ignore Trailer headers
+          break
+        end
+
+        if ( (not sio.eof?) and 
+             (chunk=sio.read(chunksz)) and 
+             chunk.size == chunksz and 
+             (not sio.eof?) and (extra = sio.readline) and
+             (not sio.eof?) and (extra << sio.readline)
+           )
+          if extra =~ /^\r?\n\r?\n$/
+            yield(chunk) if block_given?
+            self << chunk
+          else
+            raise "expected CRLF"
+          end
+        else
+          @last_chunk = line + chunk.to_s + extra.to_s
+          break
+        end
+      end
+      throw(:expect_length, @expect_length) if @expect_length
+      return self
+    end
+
+
+    def to_raw(csz=nil)
+      csz ||= (@opts[:output_chunk_size] || DEFAULT_CHUNK_SIZE)
+      unless csz.kind_of? Integer and csz > 0
+        raise "chunk size must be an integer >= 1"
+      end
+
+      out=[]
+      i=0
+      while i <= self.size
+        chunk = self[i, csz]
+        out << "#{chunk.size.to_s(16)}\r\n#{chunk}\r\n\r\n"
+        yield(self, out.last) if block_given?
+        i+=csz
+      end
+      out << "0\r\n"
+      yield(self, out.last) if block_given?
+      return out.join
+    end
+  end
+end
+