rbkb 0.7.2 → 0.7.3

data/lib/rbkb/cli.rb

@@ -2,16 +2,14 @@ require 'rbkb'
 require 'rbkb/extends'
 require 'optparse'
 
-# Copyright 2009 emonti at matasano.com 
+# Copyright 2009 emonti at matasano.com
 # See README.rdoc for license information
 #
 module Rbkb::Cli
-
   # Rbkb::Cli::Executable is an abstract class for creating command line
   # executables using the Ruby Black Bag framework.
   class Executable
-
-    def self.run(param={})
+    def self.run(param = {})
       new(param).go
     end
 
@@ -26,42 +24,39 @@ module Rbkb::Cli
     #  :argv   - An array of cli arguments (default ARGV)
     #  :opts    - executable/function options for use when running 'go'
     #  :stdout, - IO redirection (mostly for unit tests)
-    #  :stderr,   
+    #  :stderr,
     #  :stdin
     #
     #
     # The above keys are deleted from the 'param' hash and stored as instance
     # variables with attr_accessors.  All other parameters are ignored.
-    def initialize(param={})
+    def initialize(param = {})
       @argv   ||= param.delete(:argv) || ARGV
       @stdout ||= param.delete(:stdout) || STDOUT
       @stderr ||= param.delete(:stderr) || STDERR
       @stdin  ||= param.delete(:stdin) || STDIN
       @opts   ||= param.delete(:opts) || {}
-      @parser_got_range=nil
+      @parser_got_range = nil
       yield self if block_given?
-      make_parser()
+      make_parser
     end
 
-
     # Wrapper for Kernel.exit() so we can unit test cli tools
     def exit(ret)
       @exit_status = ret
       if defined? Rbkb::Cli::TESTING
-        throw(((ret==0)? :exit_zero : :exit_err), ret)
+        throw((ret == 0 ? :exit_zero : :exit_err), ret)
       else
         Kernel.exit(ret)
       end
     end
 
-
     # This method exits with a message on stderr
     def bail(msg)
       @stderr.puts msg if msg
       self.exit(1)
     end
 
-
     # This method wraps a 'bail' with a basic argument error mesage and hint
     # for the '-h or --help' flag
     # The 'arg_err'  parameter is a string with the erroneous arguments
@@ -69,62 +64,63 @@ module Rbkb::Cli
       bail "Error: bad arguments - #{arg_err}\n  Hint: Use -h or --help"
     end
 
-
     # Prepares an OptionsParser object with blackbag standard options
     # This is called from within initialize() and should be overridden in
     # inherited classes to add additional OptionParser-based parsers.
     #
     # See parse for actual parsing.
     def make_parser
-      @oparse ||= OptionParser.new 
+      @oparse ||= OptionParser.new
       @oparse.banner = "Usage: #{File.basename $0} [options]"
 
-      @oparse.on("-h", "--help", "Show this message") do
+      @oparse.on('-h', '--help', 'Show this message') do
         bail(@oparse)
       end
 
-      @oparse.on("-v", "--version", "Show version and exit") do
+      @oparse.on('-v', '--version', 'Show version and exit') do
         @stdout.puts("Ruby BlackBag version #{Rbkb::VERSION}")
         self.exit(0)
       end
 
-      return @oparse
+      @oparse
     end
 
-
-    # Abstract argument parser. Override this method with super() from 
+    # Abstract argument parser. Override this method with super() from
     # inherited executables. The base method just calls OptionParser.parse!
     # on the internal @oparse object.
     def parse
       # parse flag arguments
-      @oparse.parse!(@argv) rescue(bail_args($!))
-      @parsed=true
+      begin
+        @oparse.parse!(@argv)
+      rescue StandardError
+        (bail_args($!))
+      end
+      @parsed = true
 
       # the overriding class may implement additional arguments from here
     end
-    
 
     # Abstract 'runner'. Override this method with super() from inherited
     # executables. The base method just slurps in an optional argv and
     # runs 'parse' if it hasn't already
-    def go(argv=nil)
+    def go(argv = nil)
       @exit_status = nil
-      @argv = argv if argv 
+      @argv = argv if argv
 
       parse
 
       # the overriding class implements actual functionality beyond here
     end
 
-
     private
 
     # Wraps a file read with a standard bail error message
     def do_file_read(f)
-      File.read(f) rescue(bail "File Read Error: #{$!}")
+      File.read(f)
+    rescue StandardError
+      (bail "File Read Error: #{$!}")
     end
 
-
     # Implements a basic input file argument. File reading is handled
     # by do_file_read().
     #
@@ -132,13 +128,12 @@ module Rbkb::Cli
     # the file data into.
     # (Used commonly throughout several executables)
     def add_std_file_opt(inkey)
-      @oparse.on("-f", "--file FILENAME", "Input from FILENAME") do |f|
+      @oparse.on('-f', '--file FILENAME', 'Input from FILENAME') do |f|
         @opts[inkey] = do_file_read(f)
       end
-      return @oparse
+      @oparse
     end
 
-
     # Implements numeric and hex range options via '-r' and '-x'
     #
     # Takes two arguments which are the @opts hash key names for
@@ -146,64 +141,58 @@ module Rbkb::Cli
     #
     # (Used commonly throughout several executables)
     def add_range_opts(fkey, lkey)
-      @oparse.on("-r", "--range=START[:END]", 
-                 "Start and optional end range") do |r|
+      @oparse.on('-r', '--range=START[:END]',
+                 'Start and optional end range') do |r|
+        raise '-x and -r are mutually exclusive' if @parser_got_range
 
-        raise "-x and -r are mutually exclusive" if @parser_got_range
-        @parser_got_range=true
+        @parser_got_range = true
 
-        unless /^(-?[0-9]+)(?::(-?[0-9]+))?$/.match(r)
-          raise "invalid range #{r.inspect}"
-        end
+        raise "invalid range #{r.inspect}" unless /^(-?[0-9]+)(?::(-?[0-9]+))?$/.match(r)
 
-        @opts[fkey] = $1.to_i
-        @opts[lkey] = $2.to_i if $2
+        @opts[fkey] = ::Regexp.last_match(1).to_i
+        @opts[lkey] = ::Regexp.last_match(2).to_i if ::Regexp.last_match(2)
       end
 
-      @oparse.on("-x", "--hexrange=START[:END]", 
-                 "Start and optional end range in hex") do |r|
+      @oparse.on('-x', '--hexrange=START[:END]',
+                 'Start and optional end range in hex') do |r|
+        raise '-x and -r are mutually exclusive' if @parser_got_range
 
-        raise "-x and -r are mutually exclusive" if @parser_got_range
-        @parser_got_range=true
+        @parser_got_range = true
 
-        unless /^(-?[0-9a-f]+)(?::(-?[0-9a-f]+))?$/i.match(r)
-          raise "invalid range #{r.inspect}"
-        end
+        raise "invalid range #{r.inspect}" unless /^(-?[0-9a-f]+)(?::(-?[0-9a-f]+))?$/i.match(r)
 
-        @opts[fkey] = 
-          if ($1[0,1] == '-')
-            ($1[1..-1]).hex_to_num * -1
+        @opts[fkey] =
+          if ::Regexp.last_match(1)[0, 1] == '-'
+            ::Regexp.last_match(1)[1..-1].hex_to_num * -1
           else
-            $1.hex_to_num
+            ::Regexp.last_match(1).hex_to_num
           end
 
-        if $2
-          @opts[lkey] = 
-            if($2[0,1] == '-')
-              $2[1..-1].hex_to_num * -1
+        if ::Regexp.last_match(2)
+          @opts[lkey] =
+            if ::Regexp.last_match(2)[0, 1] == '-'
+              ::Regexp.last_match(2)[1..-1].hex_to_num * -1
             else
-              $2.hex_to_num
+              ::Regexp.last_match(2).hex_to_num
             end
         end
       end
     end
 
-
-    # Conditionally parses a string argument. Uses 'key' to first check for 
+    # Conditionally parses a string argument. Uses 'key' to first check for
     # then store it in @opts hash if it is not yet there.
     # (Used commonly throughout several executables)
     def parse_string_argument(key)
-      if @opts[key].nil? and s=@argv.shift
-        @opts[key] = s.dup 
+      if @opts[key].nil? and s = @argv.shift
+        @opts[key] = s.dup
       end
     end
 
-
-    # Conditionally parses a file argument. Uses 'key' to first check for 
+    # Conditionally parses a file argument. Uses 'key' to first check for
     # then store it in @opts hash if it is not yet there.
     # (Used commonly throughout several executables)
     def parse_file_argument(key)
-      if @opts[key].nil? and f=@argv.shift
+      if @opts[key].nil? and f = @argv.shift
         @opts[key] = do_file_read(f)
       end
     end
@@ -212,9 +201,7 @@ module Rbkb::Cli
     # arguments if there are extra arguments.
     # (Used commonly throughout several executables)
     def parse_catchall
-      bail_args(@argv.join(' ')) if(@argv.length != 0)
+      bail_args(@argv.join(' ')) if @argv.length != 0
     end
-
   end
 end
-

data/lib/rbkb/extends/array.rb

@@ -1,6 +1,4 @@
-
 class Array
-
   # Should be in the std library.
   #
   #   keys = [:one, :two, :three]
@@ -11,19 +9,20 @@ class Array
   #
   #   keys.to_hash(vals)
   #   #=> {:two=>2, :three=>3, :one=>1}})
-  def to_hash(vals=nil)
-    a = vals ? self.zip(vals) : self
-    a.inject({}) {|hash, i| hash[i[0]] = i[1]; hash}
+  def to_hash(vals = nil)
+    a = vals ? zip(vals) : self
+    a.each_with_object({}) do |i, hash|
+      hash[i[0]] = i[1]
+    end
   end
 
   # randomizes the order of contents in the Array (self)
   def randomize
-    self.sort_by{ rand }
+    sort_by { rand }
   end
 
   # Returns a randomly chosen element from self.
   def rand_elem
-    self[rand(self.count)]
+    self[rand(count)]
   end
 end
-

data/lib/rbkb/extends/common.rb

@@ -1,13 +1,11 @@
-require "stringio"
+require 'stringio'
 require 'zlib'
 require 'open3'
-require 'enumerator'
 require 'digest/md5'
 require 'digest/sha1'
 require 'digest/sha2'
 
 module Rbkb
-  DEFAULT_BYTE_ORDER=:big
-  HEXCHARS = [("0".."9").to_a, ("a".."f").to_a].flatten
+  DEFAULT_BYTE_ORDER = :big
+  HEXCHARS = [('0'..'9').to_a, ('a'..'f').to_a].flatten
 end
-

data/lib/rbkb/extends/enumerable.rb

@@ -1,27 +1,27 @@
-
 module Enumerable
   def each_recursive(&block)
-    self.each do |n|
+    each do |n|
       block.call(n)
-      n.each_recursive(&block) if Enumerable === n
+      n.each_recursive(&block) if n.is_a?(Enumerable)
     end
   end
 
   def sum
-    return self.inject(0){|accum, i| accum + i }
+    inject(0) { |accum, i| accum + i }
   end
 
   def mean
-    return self.sum / self.length.to_f
+    sum / length.to_f
   end
 
   def sample_variance
-    m = self.mean
-    sum = self.inject(0){|accum, i| accum + (i - m) ** 2 }
-    return sum / (self.length - 1).to_f
+    m = mean
+    sum = inject(0) { |accum, i| accum + (i - m)**2 }
+    sum / (length - 1).to_f
   end
 
   def standard_deviation
-    return Math.sqrt(self.sample_variance)
+    Math.sqrt(sample_variance)
   end
 end
+

data/lib/rbkb/extends/float.rb

@@ -4,7 +4,7 @@ module Rbkb
   module Extends
     module Float
       def log2
-        Math.log(self)/Math.log(2)
+        Math.log(self) / Math.log(2)
       end
     end
   end
@@ -14,4 +14,3 @@ end
 class Float
   include Rbkb::Extends::Float
 end
-

data/lib/rbkb/extends/numeric.rb

@@ -1,15 +1,17 @@
 require 'rbkb/extends/common'
 
 class Numeric
-
   # calculate padding based on alignment(a)
   def pad(a)
-    raise "bad alignment #{a.inspect}" unless a.kind_of? Numeric and a > 0
-    return self < 1 ? a + self : (a-1) - (self-1) % a
+    raise "bad alignment #{a.inspect}" unless a.is_a? Numeric and a > 0
+
+    self < 1 ? a + self : (a - 1) - (self - 1) % a
   end
 
   # tells you whether a number is within printable range
-  def printable?; self >= 0x20 and self <= 0x7e; end
+  def printable?
+    self >= 0x20 and self <= 0x7e
+  end
 
   # shortcut for packing a single number... wtf...
   def pack(arg)
@@ -24,34 +26,34 @@ class Numeric
   # Accepts a block for some transformation on each byte.
   # (used by to_bytes and to_hex under the hood)
   #
-  # args: 
+  # args:
   #   order: byte order - :big or :little
   #                       (only :big has meaning)
   #   siz:  pack to this size. larger numbers will wrap
-  def to_chars(order=nil, siz=nil)
+  def to_chars(order = nil, siz = nil)
     order ||= Rbkb::DEFAULT_BYTE_ORDER
-    n=self
-    siz ||= self.size
-    ret=[]
-    siz.times do 
+    n = self
+    siz ||= size
+    ret = []
+    siz.times do
       c = (n % 256)
       if block_given? then (c = yield(c)) end
       ret << c
-      n=(n >> 8)
+      n = (n >> 8)
     end
-    return ((order == :big)? ret.reverse  : ret)
+    (order == :big ? ret.reverse : ret)
   end
 
   # "packs" a number into bytes using bit-twiddling instead of pack()
   #
   # Uses to_chars under the hood. See also: to_hex
   #
-  # args: 
+  # args:
   #   siz:  pack to this size. larger numbers will wrap
   #   order: byte order - :big or :little
   #                       (only :big has meaning)
-  def to_bytes(order=nil, siz=nil)
-    to_chars(order,siz) {|c| c.chr }.join
+  def to_bytes(order = nil, siz = nil)
+    to_chars(order, siz) { |c| c.chr }.join
   end
 
   # Converts a number to hex string with width and endian options.
@@ -59,25 +61,22 @@ class Numeric
   #
   # Uses to_chars under the hood. See also: to_bytes
   #
-  # args: 
+  # args:
   #   siz:  pack to this size. larger numbers will wrap
   #   order: byte order - :big or :little
   #                       (only :big has meaning)
   #
-  def to_hex(o=nil, s=nil)
-    to_chars(o,s) {|c| 
-      Rbkb::HEXCHARS[c.clear_bits(0xf) >> 4]+Rbkb::HEXCHARS[c.clear_bits(0xf0)]
-    }.join
+  def to_hex(o = nil, s = nil)
+    to_chars(o, s) do |c|
+      Rbkb::HEXCHARS[c.clear_bits(0xf) >> 4] + Rbkb::HEXCHARS[c.clear_bits(0xf0)]
+    end.join
   end
 
-  # 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}
-#    e = e.join
-#    [a,b,c,d,e].join("-").upcase
-#  end
-
+  # 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}
+  #    e = e.join
+  #    [a,b,c,d,e].join("-").upcase
+  #  end
 end # class Numeric
-
-

data/lib/rbkb/extends/object.rb

@@ -1,7 +1,6 @@
-
 class Object
   ## This is from Topher Cyll's Stupd IRB tricks
   def mymethods
-    (self.methods - self.class.superclass.methods).sort
+    (methods - self.class.superclass.methods).sort
   end
 end