rbm 0.0.1 → 0.0.2

data/README.md

@@ -19,10 +19,12 @@ Using rbm is quite simple. Just pass in each code fragment you want to test as a
 
     rbm "sleep 1" "sleep 5"
 
-You can specify the number of times to loop. You can also provide a code fragment to be run before each time each code fragment is run.
+You can specify the number of times to run each code fragment.
+You can also provide a code fragment to be run before all code fragments or before a code fragment.
 
-    rbm --times 100 "sleep 0.01"
-    rbm --prerun "n = 5" "sleep n"
+    rbm --times 1000 "5 / 5"
+    rbm --times 1000 --init "n = 5" "n / 5"
+    rbm --times 1000 --init "n = 5" --pre "m = 5" "n / m"
 
 You may provide a name to each code fragment to be displayed on the benchmark.
 
@@ -30,16 +32,20 @@ You may provide a name to each code fragment to be displayed on the benchmark.
 
 You can see the full usage statement at any time with `rbm --help`
 
-    Usage: rbm [options] [--name name] code [[-N name] code...]
+    Usage: rbm [options] [--name name] [--pre code] code [[--name name] [--pre code] code...]
 
     Ruby Options:
         -r, --require file[,file]        Files to require before benchmarking
         -I, --load-path path[,path]      Paths to append to $LOAD_PATH
 
-    Benchmark Options:
-        -n, --times N                    Number of times to run each code fragment
-        -p, --pre code                   Code to run before each code fragment to be benchmarked
+    Code Fragment Options:
+        -n, --times n                    Number of times to run each code fragment
+        -i, --init code                  Code to run before every code fragment
+        -c, --cleanup code               Code to run after each code fragment
         -N, --name name                  Names the following code fragment
+        -p, --pre code                   Code to run before the follow code fragment
+        -P, --post code                  Code to run after the follow code fragment
 
     General Options:
-        -h, --help                       Show this message
+        -v, --version                    Print the version and exit
+        -h, --help                       Print this message and exit

data/lib/rbm.rb

@@ -1,5 +1,6 @@
-require 'optparse'
-require 'rbm/benchmarker'
+require "optparse"
+require "rbm/benchmarker"
+require "rbm/version"
 
 module RBM
   class << self
@@ -19,52 +20,52 @@ module RBM
         exit
       end
 
-      begin
-        Benchmarker.new(fragments, options).run
-      rescue BenchmarkerSyntaxError => e
-        puts e
-        exit
-      end
+      Benchmarker.new(fragments, options).run
     end
 
     private
       def parse_options(args)
-        fragments, options = [], {}
-        current_name = nil
+        fragments, options = [], { :requires => [], :load_paths => [] }
+        current_name, current_prerun, current_postrun = nil, nil, nil
 
         op = OptionParser.new do |op|
-          op.banner = "Usage: #{op.program_name} [options] [--name name] code [[-N name] code...]"
+          op.banner << " [--name name] [--pre code] code [[--name name] [--pre code] code...]"
 
-          op.separator ''
-          op.separator 'Ruby Options:'
+          op.separator ""
+          op.separator "Ruby Options:"
 
-          op.on('-r', '--require file[,file]', Array, 'Files to require before benchmarking') do |list|
-            (options[:requires] ||= []).concat(list)
-          end
+          op.on("-r", "--require file[,file]", Array, "Files to require before benchmarking") { |a| options[:requires].concat(a) }
+          op.on("-I", "--load-path path[,path]", Array, "Paths to append to $LOAD_PATH") { |a| options[:load_paths].concat(a) }
 
-          op.on('-I', '--load-path path[,path]', Array, 'Paths to append to $LOAD_PATH') do |list|
-            (options[:load_paths] ||= []).concat(list)
-          end
+          # op.separator ""
+          # op.separator "Benchmark Options:"
 
-          op.separator ''
-          op.separator 'Benchmark Options:'
+          op.separator ""
+          op.separator "Code Fragment Options:"
 
-          op.on('-n', '--times N', Integer, 'Number of times to run each code fragment') { |n| options[:times] = n }
-          op.on('-p', '--pre code', String, 'Code to run before each code fragment to be benchmarked') { |p| options[:prerun] = p }
-          op.on('-N', '--name name', String, 'Names the following code fragment') { |n| current_name = n }
+          op.on("-n", "--times n", Integer, "Number of times to run each code fragment") { |i| options[:times] = i }
+          op.on("-i", "--init code", String, "Code to run before every code fragment") { |s| options[:init] = s }
+          op.on("-c", "--cleanup code", String, "Code to run after each code fragment") { |s| options[:cleanup] = s }
+          op.on("-N", "--name name", String, "Names the following code fragment") { |s| current_name = s }
+          op.on("-p", "--pre code", String, "Code to run before the follow code fragment") { |s| current_prerun = s }
+          op.on("-P", "--post code", String, "Code to run after the follow code fragment") { |s| current_postrun = s }
 
-          op.separator ''
-          op.separator 'General Options:'
+          op.separator ""
+          op.separator "General Options:"
 
-          op.on('-h', '--help', 'Show this message') do
+          op.on("-v", "--version", "Print the version and exit") do
+            puts "RBM #{RBM::VERSION}"
+            exit
+          end
+          op.on("-h", "--help", "Print this message and exit") do
             puts op
             exit
           end
         end
         op.order!(args) do |fragment|
           # block gets run for each non-option argument
-          fragments << [current_name || '', fragment]
-          current_name = nil
+          fragments << { :name => current_name, :prerun => current_prerun, :postrun => current_postrun, :fragment => fragment }
+          current_name, current_prerun, current_postrun = nil, nil, nil
         end
 
         if fragments.empty?

data/lib/rbm/benchmarker.rb

@@ -6,68 +6,33 @@ module RBM
       :times => 1
     }
 
-    attr_reader :options
+    attr_reader :fragments, :options
 
     def initialize(fragments, options)
-      @options = DEFAULT_OPTIONS.merge(options)
-
-      compile_prerun(options[:prerun])
-      @fragments = fragments.map { |name, fragment| [name, compile_fragment(fragment, options[:prerun], name)] }
+      @fragments, @options = fragments, DEFAULT_OPTIONS.merge(options)
     end
 
     def run
-      width = @fragments.map { |name, method| name.size }.max
+      width = fragments.map { |fragment| (fragment[:name] || "").length }.max
       Benchmark.bm(width) do |bm|
-        @fragments.each do |name, method|
-          bm.report(name) do
-            # TODO: wrap errors from fragment execution
-            options[:times].times { send(method) }
-          end
-        end
-      end
-    end
+        fragments.each do |fragment|
+          name = fragment[:name] || ""
+          fragment_name = (fragment[:name] || (@unnamed_fragment ||= "fragment_0").succ!).gsub(/\s+/, "_")
 
-    private
-      def compile_prerun(prerun)
-        # TODO:
-        #   another way to check prerun syntax outside of compile_fragment so we can
-        #   give meaningful syntax errors (error in prerun not in a fragment itself)
-        wrap_syntax_errors do
-          instance_eval <<-EVAL, "prerun", -1
-            def bm_prerun
-              #{prerun}
-            end
-            undef bm_prerun
-          EVAL
-        end
-      end
+          object = Object.new
+          binding = object.send(:binding)
 
-      def compile_fragment(fragment, prerun = nil, name = nil)
-        name = (@fragment_name ||= "fragment_0").succ! unless name && !name.empty?
-        fragment_name = "bm_#{name.gsub(/\s+/, '_')}".to_sym
-        defined = instance_method(fragment_name) rescue false
-        raise "#{fragment_name} is already defined" if defined
+          bm.report(name) do
+            # TODO: figure out how to not eval each loop but still provide a better stack trace
 
-        wrap_syntax_errors do
-          # TODO: provide better runtime errors and NameError errors and cleaner stack trace
-          instance_eval <<-EVAL, name, -1
-            def #{fragment_name}
-              #{prerun}
-              #{fragment}
-            end
-          EVAL
+            eval options[:init], binding, "init", 1 if options[:init]
+            eval fragment[:prerun], binding, "#{fragment_name}_prerun", 1 if fragment[:prerun]
+            options[:times].times { eval fragment[:fragment], binding, fragment_name, 1 }
+            eval fragment[:postrun], binding, "#{fragment_name}_postrun", 1 if fragment[:postrun]
+            eval options[:cleanup], binding, "cleanup", 1 if options[:cleanup]
+          end
         end
-
-        fragment_name
-      end
-
-      def wrap_syntax_errors
-        yield
-      rescue SyntaxError => e
-        raise(BenchmarkerSyntaxError.new(e.to_s))
       end
-  end
-
-  class BenchmarkerSyntaxError < SyntaxError
+    end
   end
 end

data/lib/rbm/version.rb

@@ -1,3 +1,3 @@
 module RBM
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

metadata

@@ -2,7 +2,7 @@
 name: rbm
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Samuel Kadolph
@@ -10,11 +10,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-14 00:00:00 -04:00
+date: 2011-04-13 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
-description: Command line tool for doing quick ruby benchmarks. Provide each code fragment to run as a separate code fragment to rbm.See rbm --help for more information.
+description: Command line tool for doing quick ruby benchmarks. Provide each code fragment to run as a separate code fragment to rbm. See rbm --help for more information.
 email: 
 - samuel@kadolph.com
 executables: