elapse 0.1.0

data/.gitignore

@@ -0,0 +1,12 @@
+# General Ruby.
+/.bundle
+.ref-*
+.old*
+*-old*
+/.rvmrc
+
+# Project-specific.
+/*.rb
+/doc/
+/pkg/
+/.yardoc

data/.rspec

@@ -0,0 +1,2 @@
+--color
+-fn         # Tree-like progress.

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem dependencies in `PROJECT.gemspec`.
+gemspec

data/Gemfile.lock

@@ -0,0 +1,26 @@
+PATH
+  remote: .
+  specs:
+    elapse (0.1.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    rspec (2.8.0)
+      rspec-core (~> 2.8.0)
+      rspec-expectations (~> 2.8.0)
+      rspec-mocks (~> 2.8.0)
+    rspec-core (2.8.0)
+    rspec-expectations (2.8.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.8.0)
+    yard (0.7.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  elapse!
+  rspec
+  yard

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Alex Fortuna
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,119 @@
+
+Elapsed time measurement tool
+=============================
+
+Introduction
+------------
+
+`Elapse` is a simple tool to measure time taken by various parts of your program.
+
+
+Setup
+-----
+
+~~~
+$ gem install elapse
+~~~
+
+, or via Bundler's `Gemfile`:
+
+~~~
+gem "elapse"
+#gem "elapse", :git => "git://github.com/dadooda/elapse.git"     # Edge version.
+~~~
+
+
+Usage
+-----
+
+The most common use is the "stacked" (or "unnamed") mode. In stacked mode you invoke `Elapse.start` and `Elapse.took` without arguments:
+
+~~~
+puts "Fetching page (url:'#{url}')"; Elapse.start
+content = open(url).read
+puts "Fetching page ok (took:%.2fs)" % Elapse.took
+~~~
+
+In stacked mode time is **pushed to the stack** on `Elapse.start` and **popped from the stack** on `Elapse.took`/`Elapse.stop`. Thus you can nest unnamed measurements as deep as you like:
+
+~~~
+puts "Processing"; Elapse.start
+  puts "Loading data"; Elapse.start
+  load_data
+  puts "Loading data ok (took:%.2fs)" % Elapse.took
+
+  puts "Converting data"; Elapse.start
+  process_data
+  puts "Converting data ok (took:%.2fs)" % Elapse.took
+puts "Processing ok (took:%.2fs)" % Elapse.took
+
+# Output:
+
+Processing
+Loading data
+Loading data ok (took:2.00s)
+Converting data
+Converting data ok (took:3.00s)
+Processing ok (took:5.00s)
+~~~
+
+"Named" mode. See the stopwatch name argument to `Elapse.start`, `Elapse.stop` and `Elapse.took`:
+
+~~~
+Elapse.start(:load_data)
+load_data
+Elapse.stop(:load_data)
+
+Elapse.start(:process_data)
+process_data
+Elapse.stop(:process_data)
+
+puts "Time took:"
+[:load_data, :process_data].each do |stopwatch|
+  puts "* #{stopwatch}: %.2fs" % Elapse.took(stopwatch)
+end
+
+# Output:
+
+Time took:
+* load_data: 2.00s
+* process_data: 3.00s
+~~~
+
+In named mode you cat get **cumulative time** measured by the stopwatch:
+
+~~~
+filenames.each do |fn|
+  puts "Processing file (fn:'#{fn}')"; Elapse.start(:process_file)
+  process_file(fn)
+  puts "Processing file ok (took:%.2fs)" % Elapse.took(:process_file)
+end
+
+puts "Total file processing took %.2fs" % Elapse.cumulative(:process_file)
+~~~
+
+That's it for the basic intro. See the full [RDoc documentation](http://rubydoc.info/github/dadooda/elapse/master/frames) for more details.
+
+
+Compatibility
+-------------
+
+Tested to run on:
+
+* Ruby 1.9.2-p180, Linux, RVM
+
+Compatibility issue reports will be greatly appreciated.
+
+
+Copyright
+---------
+
+Copyright © 2012 Alex Fortuna.
+
+Licensed under the MIT License.
+
+
+Feedback
+--------
+
+Send bug reports, suggestions and criticisms through [project's page on GitHub](http://github.com/dadooda/elapse).

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+desc "Run all specs"
+RSpec::Core::RakeTask.new do |t|
+  #t.pattern = "./spec/**/*_spec.rb"    # Should be the default pattern.
+end

data/elapse.gemspec

@@ -0,0 +1,22 @@
+require File.expand_path("../lib/elapse/version", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name = "elapse"
+  s.version = Elapse::VERSION
+  s.authors = ["Alex Fortuna"]
+  s.email = ["alex.r@askit.org"]
+  s.homepage = "http://github.com/dadooda/elapse"
+
+  # Copy these from class's description, adjust markup.
+  s.summary = %q{Elapsed time measurement tool}
+  s.description = %q{Elapsed time measurement tool}
+  # end of s.description=
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables = `git ls-files -- bin/*`.split("\n").map {|f| File.basename(f)}
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "yard"
+end

data/lib/elapse.rb

@@ -0,0 +1,88 @@
+
+# Load all stuff.
+[
+  "elapse/**/*.rb",
+].each do |fmask|
+  Dir[File.expand_path("../#{fmask}", __FILE__)].each do |fn|
+    require fn
+  end
+end
+
+# == Elapsed time measurement tool
+#
+# See {rubydoc documentation}[http://rubydoc.info/github/dadooda/elapse/master/frames] for basic usage examples.
+module Elapse
+  # Clear everything.
+  def self.clear
+    instance.clear
+    nil
+  end
+
+  # Return sum of all measurements made by the stopwatch.
+  #
+  #   Elapse.start(:mytime); sleep 0.01; Elapse.stop(:mytime)
+  #   Elapse.cumulative(:mytime)   # => 0.01
+  #   Elapse.start(:mytime); sleep 0.02; Elapse.stop(:mytime)
+  #   Elapse.cumulative(:mytime)   # => 0.03
+  def self.cumulative(sw_key)
+    instance.cumulative(sw_key)
+  end
+
+  # Reset the named stopwatch.
+  #
+  #   Elapse.reset(:mytime)
+  def self.reset(sw_key)
+    instance.reset(sw_key)
+  end
+
+  # Start the stopwatch. Return Time::now.
+  #
+  #   start             # Stacked mode.
+  #   start(:mytime)    # Named mode.
+  def self.start(sw_key = nil)
+    instance.start(sw_key)
+  end
+
+  # Stop the stopwatch. Return Time::now.
+  #
+  #   stop            # Stacked mode.
+  #   stop(:mytime)   # Named mode.
+  def self.stop(sw_key = nil)
+    instance.stop(sw_key)
+  end
+
+  # Return time of the last stopwatch measurement. If the stopwatch is running, stop it.
+  #
+  # Stacked mode:
+  #
+  #   start
+  #   sleep 0.01
+  #   took        # => 0.01
+  #
+  # Named mode:
+  #
+  #   start(:mytime)
+  #   sleep 0.01
+  #   took(:mytime)   # => 0.01
+  #
+  # Block execution, stacked mode:
+  #
+  #   took {sleep 0.01}    # => 0.01
+  #
+  # Block execution, named mode:
+  #
+  #   took(:mytime) {sleep 0.01}    # => 0.01
+  def self.took(sw_key = nil, &block)
+    instance.took(sw_key, &block)
+  end
+
+  class << self
+    private
+
+    # Return Elapse::Instance.
+    def instance
+      # We need not publish the instance object. Everything should be made via the API methods.
+      @instance ||= Instance.new
+    end
+  end # class << self
+end

data/lib/elapse/instance.rb

@@ -0,0 +1,112 @@
+module Elapse
+  # An instance of the system.
+  class Instance
+    # Stacked stopwatches.
+    attr_accessor :stack
+
+    # Named stopwatches.
+    attr_accessor :stopwatches
+
+    def initialize(attrs = {})
+      clear
+      attrs.each {|k, v| send("#{k}=", v)}
+    end
+
+    # Clear everything.
+    def clear
+      @stack = []
+      @stopwatches = {}
+      self    # By convention.
+    end
+
+    # Return sum of all measurements made by the stopwatch.
+    #
+    # See Elapse::cumulative.
+    def cumulative(sw_key)
+      sw = find_stopwatch(sw_key)
+
+      begin
+        sw.cumulative
+      rescue RuntimeError => e
+        # Append stopwatch name.
+        raise "#{e.message}: #{sw_key.inspect}"
+      end
+    end
+
+    # Reset the named stopwatch.
+    #
+    # See Elapse::reset.
+    def reset(sw_key)
+      # Let's be strict.
+      find_stopwatch(sw_key).reset
+    end
+
+    # Start the stopwatch. Return Time::now.
+    #
+    # See Elapse::start.
+    def start(sw_key = nil)
+      sw = if sw_key
+        # Named mode.
+        @stopwatches[sw_key] ||= Stopwatch.new
+      else
+        # Stacked mode.
+        Stopwatch.new
+      end
+
+      begin
+        out = sw.start
+      rescue RuntimeError => e
+        # Append stopwatch name.
+        raise "#{e.message}: #{sw_key.inspect}"
+      end
+
+      if not sw_key
+        # Stacked mode.
+        @stack.push(sw)
+      end
+
+      out
+    end
+
+    # Stop the stopwatch. Return Time::now.
+    #
+    # See Elapse::stop.
+    def stop(sw_key = nil)
+      fetch_stopwatch(sw_key).stop
+    end
+
+    # Return time of the last stopwatch measurement. If the stopwatch is running, stop it.
+    #
+    # See Elapse::took.
+    def took(sw_key = nil, &block)
+      if block
+        start(sw_key)
+        yield
+        return took(sw_key)
+      end
+
+      fetch_stopwatch(sw_key).took
+    end
+
+    private
+
+    # Find or pop stopwatch for the given <tt>sw_key</tt>.
+    def fetch_stopwatch(sw_key)
+      if sw_key
+        # Named mode.
+        find_stopwatch(sw_key)
+      else
+        # Stacked mode.
+        @stack.pop or raise "Stopwatch stack underflow (you called `stop` more times than `start`)"
+      end
+    end
+
+    def find_stopwatch(sw_key)
+      # NOTES:
+      #
+      # * Message looks okay.
+      # * Error is actually more `RuntimeError` than `ArgumentError`.
+      @stopwatches[sw_key] or raise "Stopwatch not found: #{sw_key.inspect}"
+    end
+  end
+end

data/lib/elapse/stopwatch.rb

@@ -0,0 +1,68 @@
+module Elapse
+  # Our stopwatch class.
+  class Stopwatch
+    attr_reader :started_at
+
+    def initialize
+      clear
+    end
+
+    # Clear object.
+    def clear
+      @cumulative = nil
+      @started_at = nil
+      @took = nil
+      self    # By convention.
+    end
+
+    # Stop the stopwatch and return cumulative time.
+    def cumulative
+      stop
+      @cumulative
+    end
+
+    # Reset stopwatch.
+    def reset
+      clear
+      nil
+    end
+
+    # Return true if the stopwatch is running.
+    def running?
+      !!@started_at
+    end
+
+    # Start the stopwatch. Return Time::now.
+    def start
+      raise "Stopwatch already started" if @started_at
+      @started_at = Time.now
+    end
+
+    # Stop the stopwatch. Return Time::now.
+    def stop
+      now = Time.now
+
+      # We can stop multiple times. We cannot stop if never started.
+      if @started_at
+        @cumulative ||= 0.0
+        @took = now - @started_at
+        @cumulative += @took
+        @started_at = nil
+      elsif not @cumulative
+        raise "Stopwatch was never started"
+      end
+
+      now
+    end
+
+    # Stop the stopwatch and return the last measurement.
+    #
+    #   start
+    #   sleep 0.1
+    #   took      # => 0.100393978
+    def took
+      stop
+      @took
+    end
+  end # Stopwatch
+end

data/lib/elapse/version.rb

@@ -0,0 +1,4 @@
+module Elapse
+  # Gem version.
+  VERSION = "0.1.0"
+end

data/spec/elapse/instance_spec.rb

@@ -0,0 +1,29 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+describe Elapse::Instance do
+  before :each do
+    @r = described_class.new
+  end
+
+  # Shared examples.
+  it_behaves_like Elapse::Instance
+
+  describe "#took block mode" do
+    it "should work stacked" do
+      took = @r.took {sleep 0.01}
+      @r.stack.should be_empty
+    end
+  end
+
+  describe "stacked mode" do
+    describe "#start" do
+      it "should add a stopwatch to the stack" do
+        @r.stack.size.should == 0
+        @r.start
+        @r.stack.size.should == 1
+        @r.start
+        @r.stack.size.should == 2
+      end
+    end
+  end
+end

data/spec/elapse/spec_helper.rb

@@ -0,0 +1,3 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+# Custom stuff for this group.

data/spec/elapse/stopwatch_spec.rb

@@ -0,0 +1,104 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+describe Elapse::Stopwatch do
+  before :each do
+    @r = described_class.new
+  end
+
+  it "should generally work" do
+    @r.start
+    sleep 0.01
+    ("%.2f" % @r.took).should == "0.01"
+
+    @r.start
+    sleep 0.01
+    @r.stop
+    ("%.2f" % @r.took).should == "0.01"
+
+    @r.start
+    @r.reset
+    lambda do
+      @r.stop
+    end.should raise_error RuntimeError
+  end
+
+  describe "#cumulative" do
+    it "should generally work" do
+      @r.start; sleep 0.01; @r.stop
+      @r.start; sleep 0.02; @r.stop
+      ("%.2f" % @r.cumulative).should == "0.03"
+    end
+
+    it "should stop the timer" do
+      @r.start
+      @r.cumulative
+      @r.running?.should == false
+    end
+
+    it "should allow multimple invocations and retain the last value" do
+      @r.start
+      sleep 0.01
+      took1 = @r.cumulative
+      sleep 0.02
+      took2 = @r.cumulative
+      took1.should == took2
+    end
+  end
+
+  describe "#start" do
+    it "should return a Time object" do
+      @r.start.should be_a Time
+    end
+
+    it "should raise if already started" do
+      lambda do
+        @r.start
+        @r.start
+      end.should raise_error RuntimeError
+    end
+  end
+
+  describe "#stop" do
+    it "should return a Time object" do
+      @r.start
+      @r.stop.should be_a Time
+    end
+
+    it "should raise if never started" do
+      lambda do
+        @r.stop
+      end.should raise_error RuntimeError
+    end
+
+    it "should not raise if called more than once" do
+      lambda do
+        @r.start
+        @r.stop
+        @r.stop
+      end.should_not raise_error
+    end
+  end
+
+  describe "#took" do
+    it "should stop the timer" do
+      @r.start
+      @r.took
+      @r.running?.should == false
+    end
+
+    it "should allow multimple invocations and retain the last value" do
+      @r.start
+      sleep 0.01
+      took1 = @r.took
+      sleep 0.01
+      took2 = @r.took
+      took1.should == took2
+    end
+
+    it "should raise if never started" do
+      lambda do
+        @r.took
+      end.should raise_error RuntimeError
+    end
+  end
+end

data/spec/elapse_spec.rb

@@ -0,0 +1,14 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+describe Elapse do
+  before :each do
+    @r = described_class
+    @r.instance_eval {@instance = nil}
+  end
+
+  # Shared examples.
+  it_behaves_like Elapse::Instance
+
+  it "should generally work" do
+  end
+end

data/spec/shared_examples.rb

@@ -0,0 +1,169 @@
+shared_examples_for Elapse::Instance do
+  describe "#took block mode" do
+    it "should work stacked" do
+      took = @r.took {sleep 0.01}
+      ("%.2f" % took).should == "0.01"
+
+      took = @r.took {sleep 0.01; @r.took {sleep 0.02}}
+      ("%.2f" % took).should == "0.03"
+    end
+
+    it "should work named" do
+      @r.took(:mytime) {sleep 0.01}
+      ("%.2f" % @r.took(:mytime)).should == "0.01"
+      @r.took(:mytime) {sleep 0.02}
+      ("%.2f" % @r.took(:mytime)).should == "0.02"
+      ("%.2f" % @r.cumulative(:mytime)).should == "0.03"
+    end
+  end
+
+  describe "named mode" do
+    it "should generally work" do
+      @r.start(:mytime)
+      sleep 0.01
+      ("%.2f" % @r.took(:mytime)).should == "0.01"
+
+      # Overlapping stopwatches.
+      @r.start(:sw1)
+      sleep 0.01
+      @r.start(:sw2)
+      sleep 0.02
+      ("%.2f" % @r.took(:sw1)).should == "0.03"
+      ("%.2f" % @r.took(:sw2)).should == "0.02"
+    end
+
+    describe "#cumulative" do
+      it "should generally work" do
+        @r.start(:mytime); sleep 0.01; @r.stop(:mytime)
+        @r.took(:mytime) {sleep 0.02}
+        ("%.2f" % @r.cumulative(:mytime)).should == "0.03"
+
+        @r.reset(:mytime)
+        lambda do
+          @r.cumulative(:mytime)
+        end.should raise_error RuntimeError   # "Stopwatch was never started"
+
+        message = @r.cumulative(:mytime) rescue $!.message
+        message.should be_a String
+        message.should match /\s*:mytime\s*/
+      end
+
+      it "should validate presence" do
+        lambda do
+          @r.cumulative(:mytime)
+        end.should raise_error RuntimeError
+      end
+
+      it "should report name in exception message" do
+        message = @r.cumulative(:mytime) rescue $!.message
+        message.should be_a String
+        message.should match /\s*:mytime\s*/
+      end
+    end
+
+    describe "#reset" do
+      it "should validate presence" do
+        lambda do
+          @r.reset(:mytime)
+        end.should raise_error RuntimeError
+      end
+
+      it "should report name in exception message" do
+        message = @r.reset(:mytime) rescue $!.message
+        message.should be_a String
+        message.should match /\s*:mytime\s*/
+      end
+    end
+
+    describe "#start" do
+      it "should raise if already started" do
+        @r.start(:mytime)
+        lambda do
+          @r.start(:mytime)
+        end.should raise_error RuntimeError
+      end
+
+      it "should report name in exception message" do
+        @r.start(:mytime)
+        message = @r.start(:mytime) rescue $!.message
+        message.should be_a String
+        message.should match /\s*:mytime\s*/
+      end
+
+      it "should return a Time object" do
+        @r.start(:mytime).should be_a Time
+      end
+    end
+
+    describe "#stop" do
+      it "should return a Time object" do
+        @r.start(:mytime)
+        @r.stop(:mytime).should be_a Time
+      end
+
+      it "should validate presence" do
+        lambda do
+          @r.stop(:mytime)
+        end.should raise_error RuntimeError
+      end
+
+      it "should report name in exception message" do
+        message = @r.stop(:mytime) rescue $!.message
+        message.should be_a String
+        message.should match /\s*:mytime\s*/
+      end
+    end
+  end # describe "named mode"
+
+  describe "stacked mode" do
+    it "should generally work" do
+      @r.start
+      sleep 0.01
+      ("%.2f" % @r.took).should == "0.01"
+
+      @r.start
+      sleep 0.01
+        @r.start
+        sleep 0.02
+        ("%.2f" % @r.took).should == "0.02"
+      ("%.2f" % @r.took).should == "0.03"
+    end
+
+    describe "#start" do
+      it "should return a Time object" do
+        @r.start.should be_a Time
+      end
+    end
+
+    describe "#stop" do
+      it "should return a Time object" do
+        @r.start
+        @r.stop.should be_a Time
+      end
+
+      it "should raise if stack underflow" do
+        lambda do
+          @r.stop
+        end.should raise_error RuntimeError
+
+        lambda do
+          2.times {@r.start}
+          3.times {@r.stop}
+        end.should raise_error RuntimeError
+      end
+    end
+
+    describe "#took" do
+      it "should raise if stack underflow" do
+        lambda do
+          @r.took
+        end.should raise_error RuntimeError
+
+        lambda do
+          2.times {@r.start}
+          3.times {@r.took}
+        end.should raise_error RuntimeError
+      end
+    end
+  end # describe "stacked mode"
+end # shared_examples_for Elapse::Instance

data/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+# NOTE: I usually support `STANDALONE` mode in specs for Rails projects' components
+#       to be able to test them without loading the environment. This project does not
+#       depend on Rails *BUT* I still want a consistent RSpec file structure.
+#       If this is confusing, feel free to propose something better. :)
+
+# No Rails, we're always standalone... and free! :)
+STANDALONE = 1
+
+if STANDALONE
+  # Provide root path object.
+  module Standalone
+    eval <<-EOT
+      def self.root
+        # This is an absolute path, it's perfectly safe to do a `+` and then `require`.
+        Pathname("#{File.expand_path('../..', __FILE__)}")
+      end
+    EOT
+  end
+
+  # Load stuff.
+  [
+    "lib/**/*.rb",
+  ].each do |fmask|
+    Dir[Standalone.root + fmask].each do |fn|
+      require fn
+    end
+  end
+end
+
+require File.expand_path("../shared_examples", __FILE__)

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: elapse
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Alex Fortuna
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-12 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &81559990 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *81559990
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: &81559720 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *81559720
+description: Elapsed time measurement tool
+email:
+- alex.r@askit.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- Gemfile.lock
+- MIT-LICENSE
+- README.md
+- Rakefile
+- elapse.gemspec
+- lib/elapse.rb
+- lib/elapse/instance.rb
+- lib/elapse/stopwatch.rb
+- lib/elapse/version.rb
+- spec/elapse/instance_spec.rb
+- spec/elapse/spec_helper.rb
+- spec/elapse/stopwatch_spec.rb
+- spec/elapse_spec.rb
+- spec/shared_examples.rb
+- spec/spec_helper.rb
+homepage: http://github.com/dadooda/elapse
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Elapsed time measurement tool
+test_files: []
+has_rdoc: