viiite 0.1.0

data/lib/viiite.rb

@@ -0,0 +1,56 @@
+require "viiite/version"
+require "viiite/loader"
+require "viiite/tms"
+require "viiite/formatter"
+require "viiite/runner"
+require "viiite/command"
+require "viiite/viiite_file"
+require "benchmark"
+
+#
+# Benchmarking and complexity analyzer utility
+#
+module Viiite
+
+  # Builds a Tms object
+  def self.Tms(*args)
+    Viiite::Tms.coerce(args)
+  end
+
+  def self.measure(&block)
+    Viiite::Tms.coerce Benchmark.measure(&block)
+  end
+
+  # Builds a runner instance via the DSL definition given by the block.
+  #
+  # Example
+  #
+  #  Viiite.runner do |b|
+  #    b.variation_point :ruby_version, Viiite.which_ruby
+  #    b.range_over([100, 1000, 10000, 100000], :runs) do |runs|
+  #      b.variation_point :test, :via_reader do
+  #        b.report{ runs.times{ foo.via_reader } }
+  #      end
+  #      b.variation_point :test, :via_method do
+  #        b.report{ runs.times{ foo.via_method } }
+  #      end
+  #    end
+  #  end
+  # 
+  def self.bm(&block)
+    Runner.new(block)
+  end
+
+  #
+  # Returns a short string with a ruby interpreter description
+  # 
+  def self.which_ruby
+    if Object.const_defined?(:RUBY_DESCRIPTION)
+      RUBY_DESCRIPTION =~ /^([^\s]+\s*[^\s]+)/
+      $1
+    else
+      "ruby #{RUBY_VERSION} (#{RUBY_PLATFORM})"
+    end
+  end
+
+end # module Viiite

data/spec/fixtures/bench_iteration.rb

@@ -0,0 +1,9 @@
+require 'viiite'
+n = 15000
+Viiite.bm do |r|
+  r.variation_point :ruby, Viiite.which_ruby
+  r.report(:for)   { for i in 1..n; a = "1"; end }
+  r.report(:times) { n.times do   ; a = "1"; end }
+  r.report(:upto)  { 1.upto(n) do ; a = "1"; end }
+end
+

data/spec/integration/raw_data.rash

@@ -0,0 +1,6 @@
+{:bench => :for, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.01,0.0,0.0,0.0,0.0111169815063477)}
+{:bench => :times, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.01,0.0,0.0,0.0,0.00408315658569336)}
+{:bench => :upto, :ruby => "ruby 1.8.7", :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.00950002670288086)}
+{:ruby => "ruby 1.9.2p136", :bench => :for, :tms => Viiite::Tms(0.010000000000000009,0.0,0.0,0.0,0.0076122283935546875)}
+{:ruby => "ruby 1.9.2p136", :bench => :times, :tms => Viiite::Tms(0.010000000000000009,0.0,0.0,0.0,0.006944417953491211)}
+{:ruby => "ruby 1.9.2p136", :bench => :upto, :tms => Viiite::Tms(0.0,0.0,0.0,0.0,0.003862142562866211)}

data/spec/integration/report/viiite_report_1.cmd

@@ -0,0 +1 @@
+viiite report raw_data

data/spec/integration/report/viiite_report_1.stdout

@@ -0,0 +1,7 @@
++--------+-----------------------------------------------+
+| :bench | :measure                                      |
++--------+-----------------------------------------------+
+| :for   |   0.010000   0.000000   0.010000 (  0.009365) |
+| :times |   0.010000   0.000000   0.010000 (  0.005514) |
+| :upto  |   0.000000   0.000000   0.000000 (  0.006681) |
++--------+-----------------------------------------------+

data/spec/integration/report/viiite_report_2.cmd

@@ -0,0 +1 @@
+viiite report raw_data --regroup=ruby,bench

data/spec/integration/report/viiite_report_2.stdout

@@ -0,0 +1,10 @@
++----------------+--------+-----------------------------------------------+
+| :ruby          | :bench | :measure                                      |
++----------------+--------+-----------------------------------------------+
+| ruby 1.8.7     | :for   |   0.010000   0.000000   0.010000 (  0.011117) |
+| ruby 1.8.7     | :times |   0.010000   0.000000   0.010000 (  0.004083) |
+| ruby 1.8.7     | :upto  |   0.000000   0.000000   0.000000 (  0.009500) |
+| ruby 1.9.2p136 | :for   |   0.010000   0.000000   0.010000 (  0.007612) |
+| ruby 1.9.2p136 | :times |   0.010000   0.000000   0.010000 (  0.006944) |
+| ruby 1.9.2p136 | :upto  |   0.000000   0.000000   0.000000 (  0.003862) |
++----------------+--------+-----------------------------------------------+

data/spec/integration/report/viiite_report_3.cmd

@@ -0,0 +1 @@
+viiite report raw_data --hierarchy --regroup=ruby,bench

data/spec/integration/report/viiite_report_3.stdout

@@ -0,0 +1,18 @@
++----------------+------------------------------------------------------------+
+| :ruby          | :measure                                                   |
++----------------+------------------------------------------------------------+
+| ruby 1.8.7     | +--------+-----------------------------------------------+ |
+|                | | :bench | :measure                                      | |
+|                | +--------+-----------------------------------------------+ |
+|                | | :for   |   0.010000   0.000000   0.010000 (  0.011117) | |
+|                | | :times |   0.010000   0.000000   0.010000 (  0.004083) | |
+|                | | :upto  |   0.000000   0.000000   0.000000 (  0.009500) | |
+|                | +--------+-----------------------------------------------+ |
+| ruby 1.9.2p136 | +--------+-----------------------------------------------+ |
+|                | | :bench | :measure                                      | |
+|                | +--------+-----------------------------------------------+ |
+|                | | :for   |   0.010000   0.000000   0.010000 (  0.007612) | |
+|                | | :times |   0.010000   0.000000   0.010000 (  0.006944) | |
+|                | | :upto  |   0.000000   0.000000   0.000000 (  0.003862) | |
+|                | +--------+-----------------------------------------------+ |
++----------------+------------------------------------------------------------+

data/spec/integration/report/viiite_report_4.cmd

@@ -0,0 +1 @@
+viiite report raw_data --hierarchy --regroup=bench,ruby

data/spec/integration/report/viiite_report_4.stdout

@@ -0,0 +1,22 @@
++--------+--------------------------------------------------------------------+
+| :bench | :measure                                                           |
++--------+--------------------------------------------------------------------+
+| :for   | +----------------+-----------------------------------------------+ |
+|        | | :ruby          | :measure                                      | |
+|        | +----------------+-----------------------------------------------+ |
+|        | | ruby 1.8.7     |   0.010000   0.000000   0.010000 (  0.011117) | |
+|        | | ruby 1.9.2p136 |   0.010000   0.000000   0.010000 (  0.007612) | |
+|        | +----------------+-----------------------------------------------+ |
+| :times | +----------------+-----------------------------------------------+ |
+|        | | :ruby          | :measure                                      | |
+|        | +----------------+-----------------------------------------------+ |
+|        | | ruby 1.8.7     |   0.010000   0.000000   0.010000 (  0.004083) | |
+|        | | ruby 1.9.2p136 |   0.010000   0.000000   0.010000 (  0.006944) | |
+|        | +----------------+-----------------------------------------------+ |
+| :upto  | +----------------+-----------------------------------------------+ |
+|        | | :ruby          | :measure                                      | |
+|        | +----------------+-----------------------------------------------+ |
+|        | | ruby 1.8.7     |   0.000000   0.000000   0.000000 (  0.009500) | |
+|        | | ruby 1.9.2p136 |   0.000000   0.000000   0.000000 (  0.003862) | |
+|        | +----------------+-----------------------------------------------+ |
++--------+--------------------------------------------------------------------+

data/spec/integration/test_command.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+describe "viiite command / " do
+
+  Dir[File.expand_path('../**/*.cmd', __FILE__)].each do |input|
+    cmd = File.readlines(input).first
+    specify{ cmd.should =~ /^viiite / }
+  
+    describe "#{File.basename(input)}: #{cmd}" do
+      let(:argv)     { Quickl.parse_commandline_args(cmd)[1..-1] }
+      let(:stdout)   { File.join(File.dirname(input), "#{File.basename(input, ".cmd")}.stdout") }
+      let(:stderr)   { File.join(File.dirname(input), "#{File.basename(input, ".cmd")}.stderr") }
+      let(:stdout_expected) { File.exists?(stdout) ? File.read(stdout) : "" }
+      let(:stderr_expected) { File.exists?(stderr) ? File.read(stderr) : "" }
+
+      before{ redirect_io }
+      after { restore_io  }
+      
+      specify{
+        begin
+          if i = argv.index("raw_data")
+            argv[i] = File.expand_path('../raw_data.rash', __FILE__)
+          end
+          Viiite::Command.run(argv)
+        rescue SystemExit
+          $stdout << "SystemExit" << "\n"
+        end
+        $stdout.string.should(eq(stdout_expected)) unless RUBY_VERSION < "1.9"
+        $stderr.string.should(eq(stderr_expected)) unless RUBY_VERSION < "1.9"
+      }
+    end
+  end
+    
+end

data/spec/integration/viiite/viiite_help.cmd

@@ -0,0 +1 @@
+viiite --help

data/spec/integration/viiite/viiite_help.stdout

@@ -0,0 +1,25 @@
+
+viiite - Benchmark ruby scripts the easy way
+
+SYNOPSIS
+  viiite [--version] [--help] COMMAND [cmd opts] ARGS...
+
+OPTIONS
+  -Idirectory                      specify $LOAD_PATH directory (may be used more than once)
+  -rlibrary                        require the library, before executing viiite
+      --help                       Show help
+      --version                    Show version
+
+COMMANDS
+  help       Show help about a specific command
+  run        Run a benchmark and output raw data
+  report     Report benchmarking results as a table
+  plot       Report benchmarking results as a plot
+
+DESCRIPTION
+  This command helps you benchmarking ruby applications and manipulating
+  benchmark results very simply.
+
+See 'viiite help COMMAND' for more information on a specific command.
+
+SystemExit

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'viiite'
+
+def redirect_io
+  $oldstdout = $stdout 
+  $oldstderr = $stderr
+  $stdout = StringIO.new
+  $stderr = StringIO.new
+  [$stdout, $stderr]
+end
+
+def restore_io
+  $stdout = $oldstdout
+  $stderr = $oldstderr
+  $oldstdout = nil 
+  $oldstderr = nil 
+end
+
+def bench_iteration
+  File.expand_path('../fixtures/bench_iteration.rb', __FILE__)
+end
+
+

data/spec/unit/command/test_run.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+module Viiite
+  class Command
+    describe Run do
+
+      subject{ Run.run(argv) }
+
+      before{ redirect_io }
+      after { restore_io  }
+
+      describe "when passed a benchmark file" do
+        let(:argv){ [bench_iteration] }
+        specify{
+          subject
+          $stdout.string.each_line do |line|
+            h = eval(line)
+            h.should be_a(Hash)
+            h[:tms].should be_a(Viiite::Tms)
+          end
+        }
+      end
+
+    end
+  end
+end

data/spec/unit/formatter/plot/test_to_data.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+module Viiite
+  class Formatter::Plot
+    describe "to_data" do
+
+      let(:data) { [ {:x => 1, :y => 10}, {:x => 2, :y => 20} ] }
+
+      subject{ Formatter::Plot.to_data(data) }
+
+      it "should return the expected array" do
+        subject.should == [ [1,2], [10,20] ]
+      end
+
+    end
+  end  
+end

data/spec/unit/formatter/plot/test_to_dataset.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+module Viiite
+  class Formatter::Plot
+    describe "to_dataset" do
+
+      let(:tuple) {
+        {:title => "serie", 
+         :linewidth => 4,
+         :data => [ {:x => 1, :y => 10}, {:x => 2, :y => 20} ] }
+      }
+      subject{ Formatter::Plot.to_dataset(tuple) }
+
+      it "should return a correct dataset instance" do
+        subject.should be_a(Gnuplot::DataSet)
+        subject.title.should == "serie"
+        subject.linewidth.should == 4
+        subject.data.should == [ [1,2], [10,20] ]
+      end
+
+    end
+  end  
+end

data/spec/unit/formatter/plot/test_to_plot.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+module Viiite
+  class Formatter::Plot
+    describe "to_plot" do
+
+      let(:data)    { [ {:x => 1, :y => 10}, {:x => 2, :y => 20} ] }
+
+      let(:dataset) { {:title => "serie", :linewidth => 4, :data =>  data } }
+
+      let(:plot)    { {:title => "plot", :series => [ dataset ] } }
+
+      subject{ Formatter::Plot.to_plot(plot) }
+
+      it "should return a correct plot instance" do
+        subject.is_a?(Gnuplot::Plot).should be_true
+        subject["title"].should == '"plot"'
+      end
+
+    end
+  end  
+end

data/spec/unit/test_runner.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+module Viiite
+  describe Runner do
+    
+    it "should be definable with Viiite.bm" do
+      b = Viiite.bm do |viiite|
+        viiite.report{ 1 + 1 }
+      end
+      b.should be_kind_of(Viiite::Runner)
+    end
+
+    it "should be executable" do
+      b = Viiite.bm do |viiite|
+        viiite.report{ 1 + 1 }
+      end
+      res = []
+      b.each do |tuple|
+        tuple.should have_key(:tms)
+        res << tuple
+      end
+      res.should be_kind_of(Array)
+      res.size.should == 1
+      res.first[:tms].should be_kind_of(Viiite::Tms)
+    end
+
+    it "should be enumerable" do
+      b = Viiite.bm do |viiite|
+        viiite.report{ 1 + 1 }
+      end
+      res = b.to_a
+      res.should be_kind_of(Array)
+      res.size.should == 1
+      res.first[:tms].should be_kind_of(Viiite::Tms)
+    end
+    
+    it "should support variation points" do
+      b = Viiite.bm do |viiite|
+        2.times do |i| 
+          viiite.variation_point(:"#run", i)
+          viiite.report do end
+        end
+      end
+      res = b.to_a
+      res.collect{|t| t[:"#run"]}.should == [0, 1]
+    end
+
+    it "should support ranging over values" do
+      b = Viiite.bm do |viiite|
+        viiite.range_over [10, 100, 1000], :times do |t|
+          viiite.report do end
+        end
+      end
+      b.to_a.collect{|t| t[:times]}.should == [10, 100, 1000]
+    end
+
+  end
+end

data/spec/unit/test_viiite.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+describe Viiite do
+  
+  it "should have a version number" do
+    Viiite.const_defined?(:VERSION).should be_true
+  end
+
+  it "should provide a way to have short ruby descr" do
+    Viiite.which_ruby.should_not be_empty
+  end
+  
+end

data/spec/unit/tms/test_coerce.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+module Viiite
+  describe Tms, ".coerce" do
+
+    subject{ Tms.coerce(arg) }
+
+    describe "from zero" do
+      let(:arg){ 0.0 }
+      specify{ 
+        subject.should be_a(Tms)
+        subject.to_a.should eq([0.0, 0.0, 0.0, 0.0, 0.0]) 
+      }
+    end
+
+    describe "from one" do
+      let(:arg){ 1.0 }
+      specify{ 
+        subject.should be_a(Tms)
+        subject.to_a.should eq([1.0, 0.0, 0.0, 0.0, 0.0]) 
+      }
+    end
+
+    describe "from a complete hash" do
+      let(:arg){ {
+        :utime => 1.0, 
+        :stime => 2.0, 
+        :cutime => 3.0, 
+        :cstime => 4.0, 
+        :real => 5.0, 
+      } } 
+      specify{ 
+        subject.should be_a(Tms)
+        subject.to_a.should eq([1.0, 2.0, 3.0, 4.0, 5.0]) 
+      }
+    end
+
+    describe "from an array" do
+      let(:arg){ [1.0, 2.0, 3.0, 4.0, 5.0] } 
+      specify{ 
+        subject.should be_a(Tms)
+        subject.to_a.should eq([1.0, 2.0, 3.0, 4.0, 5.0]) 
+      }
+    end
+
+  end
+end

data/spec/unit/tms/test_divide.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+module Viiite
+  describe Tms, "#divide" do
+  
+    subject{ tms / operand }
+    let(:tms){ Viiite::Tms.new([1.0, 2.0, 3.0, 4.0, 5.0]) }
+
+    describe "with an integer" do
+      let(:operand){ 2 }
+      specify{ 
+        subject.should be_a(Tms)
+        subject.to_a.should eq([0.5, 1.0, 1.5, 2.0, 2.5])
+      }
+    end
+
+    describe "with another tms" do
+      let(:operand){ tms }
+      specify{ 
+        subject.should be_a(Tms)
+        subject.to_a.should eq([1.0, 1.0, 1.0, 1.0, 1.0])
+      }
+    end
+
+  end
+end
+

data/spec/unit/tms/test_minus.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+module Viiite
+  describe Tms, "#minus" do
+  
+    subject{ tms - operand }
+    let(:tms){ Viiite::Tms.new([1.0, 2.0, 3.0, 4.0, 5.0]) }
+
+    describe "with an integer" do
+      let(:operand){ 1 }
+      specify{ 
+        subject.should be_a(Tms)
+        subject.to_a.should eq([0.0, 1.0, 2.0, 3.0, 4.0])
+      }
+    end
+
+    describe "with another tms" do
+      let(:operand){ tms }
+      specify{ 
+        subject.should be_a(Tms)
+        subject.to_a.should eq([0.0, 0.0, 0.0, 0.0, 0.0])
+      }
+    end
+
+  end
+end
+

data/spec/unit/tms/test_plus.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+module Viiite
+  describe Tms, "#plus" do
+  
+    subject{ tms + operand }
+    let(:tms){ Viiite::Tms.new([1.0, 2.0, 3.0, 4.0, 5.0]) }
+
+    describe "with an integer" do
+      let(:operand){ 2 }
+      specify{ 
+        subject.should be_a(Tms)
+        subject.to_a.should eq([3.0, 4.0, 5.0, 6.0, 7.0])
+      }
+    end
+
+    describe "with another tms" do
+      let(:operand){ tms }
+      specify{ 
+        subject.should be_a(Tms)
+        subject.to_a.should eq([2.0, 4.0, 6.0, 8.0, 10.0])
+      }
+    end
+
+    describe "the other way around" do
+      subject{ 2 + tms }
+      specify{ 
+        subject.should be_a(Tms)
+        subject.to_a.should eq([3.0, 4.0, 5.0, 6.0, 7.0])
+      }
+    end
+
+  end
+end
+

data/spec/unit/tms/test_times.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+module Viiite
+  describe Tms, "#times" do
+  
+    subject{ tms * operand }
+    let(:tms){ Viiite::Tms.new([1.0, 2.0, 3.0, 4.0, 5.0]) }
+
+    describe "with an integer" do
+      let(:operand){ 2 }
+      specify{ 
+        subject.should be_a(Tms)
+        subject.to_a.should eq([2.0, 4.0, 6.0, 8.0, 10.0])
+      }
+    end
+
+    describe "with another tms" do
+      let(:operand){ tms }
+      specify{ 
+        subject.should be_a(Tms)
+        subject.to_a.should eq([1.0, 4.0, 9.0, 16.0, 25.0])
+      }
+    end
+
+  end
+end
+

data/spec/unit/tms/test_to_a.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+module Viiite
+  describe Tms, "#to_a" do
+
+    subject{ tms.to_a }
+    let(:tms){ Tms.coerce([1.0, 2.0, 3.0, 4.0, 5.0]) }
+
+    it{ should eq([1.0, 2.0, 3.0, 4.0, 5.0]) }
+
+  end
+end

data/spec/unit/tms/test_to_ruby_literal.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+module Viiite
+  describe Tms, "#to_ruby_literal" do
+
+    it "should be such that eval leads the same value" do
+      tms = Viiite::Tms.new([1.0, 2.0, 3.0, 4.0, 5.0])
+      eval(tms.to_ruby_literal).should eql(tms)
+    end
+
+  end
+end

data/spec/unit/tms/test_to_s.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+module Viiite
+  describe Tms, "#to_s" do
+
+    subject{ tms.to_s }
+    let(:tms){ Tms.coerce([1.0, 2.0, 3.0, 4.0, 5.0]) }
+
+    it{ should eq("  1.000000   2.000000  10.000000 (  5.000000)") }
+
+  end
+end

data/tasks/clean.rake

@@ -0,0 +1,3 @@
+task :clean do
+  Dir["**/*.rbc"].each{|f| FileUtils.rm_rf(f)}
+end