benchmeth 0.0.1 → 0.1.0

data/README.md

@@ -6,23 +6,32 @@ The super easy way to benchmark methods.
 gem "benchmeth"
 ```
 
-Just say which methods to benchmark and what you'd like to do with the results.
+Just say which methods to benchmark.
 
 ```ruby
 def compute
-  puts "CRUNCH!!"
+  sleep(1)
 end
 
-benchmeth :compute do |method_name, realtime|
-  puts "%s : %.2f ms" % [method_name, realtime * 1000]
-  # Or log them.
-end
+benchmark :compute
 
 compute
+```
+
+By default, benchmark data is written to STDOUT
+
+```
+compute : 1000 ms
+```
+
+but you can easily do whatever you want with it.
 
-# Output:
-# CRUNCH!!
-# compute : 0.09 ms
+```ruby
+Benchmeth.on_benchmark do |method, realtime|
+  logger.info "#{method} took #{realtime} seconds!"
+  # The default is:
+  # puts "%s : %d ms" % [method, realtime * 1000]
+end
 ```
 
 To call a method without benchmarking, use:
@@ -47,11 +56,20 @@ class Person
   end
 
   # This must come after the methods are defined.
-  benchmeth :work, :play do |method_name, realtime|
-    puts "%s : %.2f ms" % [method_name, realtime * 1000]
-  end
+  benchmark :work, :play
 
 end
+
+person = Person.new
+person.work(1)
+person.play
+```
+
+Like rdoc, instance methods are denoted with a pound sign (#).
+
+```
+Person#work : 1000 ms
+Person#play : 500 ms
 ```
 
 ## Class Methods
@@ -59,15 +77,21 @@ end
 ```ruby
 class Person
 
-  def self.count
-    2
+  def self.find(id)
+    puts "Found person #{id}!"
   end
 
   class << self
-    benchmeth :count do |method_name, realtime|
-      puts "%s : %.2f ms" % [method_name, realtime * 1000]
-    end
+    benchmark :find
   end
 
 end
+
+Person.find(1)
+```
+
+Like rdoc, class methods are denoted with a dot (.).
+
+```
+Person.find : 0 ms
 ```

data/lib/benchmeth.rb

@@ -1,23 +1,49 @@
 require "benchmeth/version"
 require "benchmark"
 
+# :( Global
+$benchmeth_main = self
+
 module Benchmeth
+  DEFAULT_BLOCK = lambda do |method, realtime|
+    puts "%s : %d ms" % [method, realtime * 1000]
+  end
 
   def self.included(base)
     base.send :extend, ClassMethods
     base.send :include, InstanceMethods
   end
 
+  def self.on_benchmark(&block)
+    if block_given?
+      @on_benchmark_block = block
+    else
+      @on_benchmark_block || DEFAULT_BLOCK
+    end
+  end
+
   module ClassMethods
 
-    def benchmeth(*method_names, &block)
+    def benchmark(*method_names)
       method_names.each do |method_name|
         method_name = method_name.to_sym
         self.send :alias_method, :"#{method_name}_without_benchmark", method_name
         self.send :define_method, method_name do |*args|
           result = nil
-          realtime = Benchmark.realtime { result = self.send(:"#{method_name}_without_benchmark", *args) }
-          block.call(method_name, realtime)
+          method_prefix = nil
+          realtime = Benchmark.realtime do
+            result = self.send(:"#{method_name}_without_benchmark", *args)
+            method_prefix =
+            case self
+            when $benchmeth_main
+              ""
+            when Class
+              "#{self.name}."
+            else
+              "#{self.class.name}#"
+            end
+          end
+          Benchmeth.on_benchmark.call("#{method_prefix}#{method_name}", realtime)
           result
         end
       end
@@ -27,8 +53,8 @@ module Benchmeth
 
   module InstanceMethods
 
-    def benchmeth(*method_names, &block)
-      self.class.benchmeth(*method_names, &block)
+    def benchmark(*method_names, &block)
+      self.class.benchmark(*method_names, &block)
     end
 
   end

data/lib/benchmeth/version.rb

@@ -1,3 +1,3 @@
 module Benchmeth
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: benchmeth
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors: