ronin-support 0.2.0.rc1 → 0.2.0.rc2

data/ChangeLog.md

@@ -14,9 +14,13 @@
 * Added {Net.smtp_send_message}.
 * Added {Net.http_status}.
 * Added YARD `@api` tags to define the public, semi-public and private APIs.
+* Renamed `Kernel#attempt` to {Kernel#try}.
 * Allow `:method` to be used with {Net.http_ok?}.
 * Fixed a bug in {Ronin::Network::HTTP.expand_url} where `:host` and `:port`
   options were being overridden.
+* Improved the performance of {Integer#bytes}.
+* Only redefine {String#dump} for Ruby 1.8.x.
+  * Ruby >= 1.9.1 correctly hex-escapes special characters.
 * Fixed a bug in {String#format_chars}, where it was not using `each_char`
   for unicode characters.
 * Deprecated {String#common_postfix}, in favor of {String#common_suffix}.

data/README.md

@@ -22,8 +22,9 @@ or payloads over many common Source-Code-Management (SCM) systems.
     * Binary
     * Text
     * HTTP
-    * HTML
     * URIs
+    * HTML
+    * JavaScript
   * Generating random text.
   * Networking:
     * TCP

data/gemspec.yml

@@ -22,4 +22,4 @@ dependencies:
 
 development_dependencies:
   bundler: ~> 1.0.10
-  yard: ~> 0.6.4
+  yard: ~> 0.7.0

data/lib/ronin/extensions/kernel.rb

@@ -35,11 +35,13 @@ module Kernel
   #
   # @api public
   #
-  def attempt
+  def try
     begin
       yield() if block_given?
     rescue Exception
       return nil
     end
   end
+
+  alias attempt try
 end

data/lib/ronin/extensions/string.rb

@@ -185,53 +185,52 @@ class String
     return self[prefix.length...(length - postfix.length)]
   end
 
-  #
-  # Dumps the string as a C-style string.
-  #
-  # @return [String]
-  #   The C-style encoded version of the String.
-  #
-  # @example
-  #   "hello\x00\073\x90\r\n".dump
-  #   # => "hello\0;\x90\r\n"
-  #
-  # @api public
-  #
-  def dump
-    c_string = ''
-
-    each_byte do |b|
-      c_string << case b
-                  when 0x00
-                    "\\0"
-                  when 0x07
-                    "\\a"
-                  when 0x08
-                    "\\b"
-                  when 0x09
-                    "\\t"
-                  when 0x0a
-                    "\\n"
-                  when 0x0b
-                    "\\v"
-                  when 0x0c
-                    "\\f"
-                  when 0x0d
-                    "\\r"
-                  when 0x22
-                    "\\\""
-                  when 0x5c
-                    "\\\\"
-                  when (0x20..0x7e)
-                    b.chr
-                  else
-                    ("\\x%.2x" % b)
-                  end
+  if RUBY_VERSION < '1.9.'
+    ESCAPE_BYTES = {
+      0x00 => '\0',
+      0x07 => '\a',
+      0x08 => '\b',
+      0x09 => '\t',
+      0x0a => '\n',
+      0x0b => '\v',
+      0x0c => '\f',
+      0x0d => '\r',
+      0x22 => '\"',
+      0x5c => '\\'
+    }
+
+    #
+    # Dumps the string as a C-style string.
+    #
+    # @return [String]
+    #   The C-style encoded version of the String.
+    #
+    # @example
+    #   "hello\x00\073\x90\r\n".dump
+    #   # => "hello\0;\x90\r\n"
+    #
+    # @note
+    #   This method is only defined on Ruby 1.8.x.
+    #
+    # @api public
+    #
+    def dump
+      dumped_string = ''
+
+      each_byte do |b|
+        dumped_string << if (b >= 0x20 && b <= 0x7e)
+                           b.chr
+                         elsif ESCAPE_BYTES.has_key?(b)
+                           ESCAPE_BYTES[b]
+                         else
+                           ("\\x%.2X" % b)
+                         end
+      end
+
+      return "\"#{dumped_string}\""
     end
 
-    return "\"#{c_string}\""
+    alias inspect dump
   end
 
-  alias inspect dump
-
 end

data/lib/ronin/formatting/extensions/binary/integer.rb

@@ -53,17 +53,23 @@ class Integer
     case endian
     when :little, :net
       mask = 0xff
+      shift = 0
 
       address_length.times do |i|
-        buffer << ((self & mask) >> (i*8))
+        buffer << ((self & mask) >> shift)
+
         mask <<= 8
+        shift += 8
       end
     when :big
-      mask = (0xff << ((address_length-1)*8))
+      shift = ((address_length - 1) * 8)
+      mask = (0xff << shift)
 
       address_length.times do |i|
-        buffer << ((self & mask) >> ((address_length-i-1)*8))
+        buffer << ((self & mask) >> shift)
+
         mask >>= 8
+        shift -= 8
       end
     else
       raise(ArgumentError,"invalid endian #{endian}")

data/lib/ronin/formatting/extensions/binary/string.rb

@@ -220,8 +220,6 @@ class String
 
     self.bytes.inject('') { |result,b| result << (b ^ key.next).chr }
   end
-  
-  
 
   #
   # Base64 encodes a string.

data/lib/ronin/support/version.rb

@@ -20,6 +20,6 @@
 module Ronin
   module Support
     # ronin-support version
-    VERSION = '0.2.0.rc1'
+    VERSION = '0.2.0.rc2'
   end
 end

data/spec/extensions/kernel_spec.rb

@@ -2,28 +2,28 @@ require 'spec_helper'
 require 'ronin/extensions/kernel'
 
 describe Kernel do
-  it "should provide Kernel#attempt" do
-    Kernel.should respond_to('attempt')
+  it "should provide Kernel#try" do
+    Kernel.should respond_to('try')
   end
 
-  describe "#attempt" do
+  describe "#try" do
     it "should return the result of the block if nothing is raised" do
-      attempt { 2 + 2 }.should == 4
+      try { 2 + 2 }.should == 4
     end
 
     it "should return nil if an exception is raised" do
-      attempt { 2 + 'a' }.should be_nil
+      try { 2 + 'a' }.should be_nil
     end
 
     it "should rescue RuntimeError exceptions" do
       lambda {
-        attempt { raise(RuntimeError,"something happened",caller) }
+        try { raise(RuntimeError,"something happened",caller) }
       }.should_not raise_error(RuntimeError)
     end
 
     it "should rescue StandardError exceptions" do
       lambda {
-        attempt { raise(StandardError,"not allowed to do that",caller) }
+        try { raise(StandardError,"not allowed to do that",caller) }
       }.should_not raise_error(StandardError)
     end
   end

data/spec/extensions/string_spec.rb

@@ -167,11 +167,11 @@ describe String do
     end
 
     it "should dump strings containing non-printable characters" do
-      "hello\x90\x05\xef".dump.should == '"hello\x90\x05\xef"'
+      "hello\x90\x05\xEF".dump.should == '"hello\x90\x05\xEF"'
     end
 
     it "should dump the string when calling the inspect method" do
-      "hello\x90\x05\xef".inspect.should == '"hello\x90\x05\xef"'
+      "hello\x90\x05\xEF".inspect.should == '"hello\x90\x05\xEF"'
     end
   end
 end

metadata

@@ -2,7 +2,7 @@
 name: ronin-support
 version: !ruby/object:Gem::Version 
   prerelease: 6
-  version: 0.2.0.rc1
+  version: 0.2.0.rc2
 platform: ruby
 authors: 
 - Postmodern
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-14 00:00:00 Z
+date: 2011-06-07 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: chars
@@ -88,7 +88,7 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        version: 0.6.4
+        version: 0.7.0
   type: :development
   prerelease: false
   version_requirements: *id007