statsample 1.4.1 → 1.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b3785ac7ce81dbffc75370cb51d4535a108808c4
-  data.tar.gz: eadd3e56fdcd4799bc90b6d509308d6fb683382d
+  metadata.gz: 21623aa3ff95567e88e39a61d2434421986cab0f
+  data.tar.gz: b756a2e887c54074e1bdc00463300986f7550a25
 SHA512:
-  metadata.gz: ae9452c11cd369739eaf461367ffa3e07fe59ba1ab35b93618a5466102f38bf5d387e86a81ea8bfdbb7b5f0e86053f1eebb7aa96c6f00ed38e14a85c63e86902
-  data.tar.gz: 5d17bd754f46b4db64e8b2a52ecbddcf01c13392593e365a075acbf4cf5077855b54bd9e51e495294741eec29d920b03e8e7e30fe13c87725f56bc554a6a6895
+  metadata.gz: c5862455f9174d9567ef9807fb8356d19f8ae9b13e471470da0a60c6703680f9c5da2ede368b62f1dfb59d67f18e2ac63e693f6fae242b015c831b8960d70649
+  data.tar.gz: a4b8cb9ebca8aacc221d1f32b15516c3a3d7944d8601219b88bbb531af5a83164eb957b38e62c0211c80932d80b4df670c065a942194c844a8c7b722e1c06449

data/.travis.yml

@@ -2,9 +2,10 @@ language:
   ruby
 
 rvm:
-  - '1.9.3'
-  - '2.0.0'
-  - '2.1.1'
+  - 1.9.3
+  - 2.0
+  - 2.1
+  - 2.2
 
 script:
   bundle exec rake test

data/History.txt

@@ -1,3 +1,7 @@
+=== 1.4.2 / 2015-04-07
+  * Statsample::CSV.read accepts numbers in scientific notation.
+  * Test on Ruby 2.2 via Travis CI.
+
 === 1.4.1 / 2015-03-26
   * Removed Hoe gem in order to use `statsample.gemspec`.
   * Improved readability of some files by using rubocop.

data/README.md

@@ -33,6 +33,10 @@ If you need to work on Structural Equation Modeling, you could see +statsample-s
 $ [sudo] gem install statsample-sem
 ```
 
+# Documentation
+
+You can see the latest documentation in [rubydoc.info](http://www.rubydoc.info/github/sciruby/statsample/master).
+
 # Description
 
 A suite for basic and advanced statistics on Ruby. Tested on CRuby 1.9.3, 2.0.0 and 2.1.1. See `.travis.yml` for more information.

data/lib/statsample/converter/csv.rb

@@ -1,77 +1,64 @@
+require 'csv'
+
 module Statsample
   class CSV < SpreadsheetBase
-    if RUBY_VERSION<"1.9"
-      require 'fastercsv'
-      CSV_klass=::FasterCSV  
-    else
-      require 'csv'
-      CSV_klass=::CSV  
-    end    
-    class << self
+    # Default options for processing CSV files. Accept the same options as
+    # Ruby's `CSV#new`.
+    DEFAULT_OPTIONS = {
+      converters: [:numeric]
+    }
 
-      def read19(filename,ignore_lines=0,csv_opts=Hash.new)
-        #default first line is header
-        csv_opts.merge!(:headers=>true, :header_converters => :symbol)
-        csv = CSV_klass::Table.new(CSV_klass::read(filename,'r',csv_opts))
-        csv_headers = if csv_opts[:headers]
-          csv.headers
-        else
-          #as in R, if no header we name the headers as V1,V2,V3,V4,..
-          1.upto(csv.first.length).collect { |i| "V#{i}" }
-        end
-        #we invert row -> column. It means csv[0] is the first column and not row. Similar to R
-        csv.by_col!
-        thash = {}
-        csv_headers.each_with_index do |header,idx|
-          thash[header] = Statsample::Vector.new(csv[idx].drop(ignore_lines))
-        end
-        Statsample::Dataset.new(thash)
-      end
-      # Returns a Dataset  based on a csv file
+    class << self
+      # Return a Dataset created from a csv file.
       #
       # USE:
-      #     ds=Statsample::CSV.read("test_csv.csv")
-      def read(filename, empty=[''],ignore_lines=0,csv_opts=Hash.new)        
-        first_row=true
-        fields=[]
-        #fields_data={}
-        ds=nil
-        line_number=0
-        csv=CSV_klass.open(filename,'rb', csv_opts)
+      #     ds = Statsample::CSV.read('test_csv.csv')
+      def read(filename, empty = [''], ignore_lines = 0, opts = {})
+        first_row = true
+        fields = []
+        ds = nil
+        line_number = 0
+        options = DEFAULT_OPTIONS.merge(opts)
+
+        csv = ::CSV.open(filename, 'rb', options)
+
         csv.each do |row|
-          line_number+=1
-          if(line_number<=ignore_lines)
-            #puts "Skip line"
+          line_number += 1
+
+          if (line_number <= ignore_lines)
             next
           end
-          row.collect!{|c| c.to_s }
+
           if first_row
-            fields=extract_fields(row)
-            ds=Statsample::Dataset.new(fields)
-            first_row=false
+            fields = extract_fields(row)
+            ds = Statsample::Dataset.new(fields)
+            first_row = false
           else
-            rowa=process_row(row,empty)
-            ds.add_case(rowa,false)
+            rowa = process_row(row, empty)
+            ds.add_case(rowa, false)
           end
         end
-        convert_to_scale_and_date(ds,fields)
+
+        convert_to_scale_and_date(ds, fields)
         ds.update_valid_data
         ds
       end
-      # Save a Dataset on a csv file
+
+      # Save a Dataset on a csv file.
       #
       # USE:
-      #     Statsample::CSV.write(ds,"test_csv.csv")
-      def write(dataset,filename, convert_comma=false,*opts)
-        
-        writer=CSV_klass.open(filename,'w',*opts)
+      #     Statsample::CSV.write(ds, 'test_csv.csv')
+      def write(dataset, filename, convert_comma = false, opts = {})
+        options = DEFAULT_OPTIONS.merge(opts)
+
+        writer = ::CSV.open(filename, 'w', options)
         writer << dataset.fields
-        dataset.each_array do|row|
-          if(convert_comma)
-            row.collect!{|v| v.to_s.gsub(".",",")}
-          end
+
+        dataset.each_array do |row|
+          row.collect! { |v| v.to_s.gsub('.', ',') } if convert_comma
           writer << row
         end
+
         writer.close
       end
     end

data/lib/statsample/converters.rb

@@ -31,13 +31,13 @@ module Statsample
       # Insert each case of the Dataset on the selected table
       #
       # USE:
-      #        
+      #
       #  ds={'id'=>[1,2,3].to_vector, 'name'=>["a","b","c"].to_vector}.to_dataset
       #  dbh = DBI.connect("DBI:Mysql:database:localhost", "user", "password")
       #  Statsample::Database.insert(ds,dbh,"test")
       #
       def insert(ds, dbh, table)
-        require 'dbi'            
+        require 'dbi'
         query="INSERT INTO #{table} ("+ds.fields.join(",")+") VALUES ("+((["?"]*ds.fields.size).join(","))+")"
         sth=dbh.prepare(query)
         ds.each_array{|c| sth.execute(*c) }
@@ -46,11 +46,11 @@ module Statsample
       # Create a sql, basen on a given Dataset
       #
       # USE:
-      #        
+      #
       #  ds={'id'=>[1,2,3,4,5].to_vector,'name'=>%w{Alex Peter Susan Mary John}.to_vector}.to_dataset
       #  Statsample::Database.create_sql(ds,'names')
       #   ==>"CREATE TABLE names (id INTEGER,\n name VARCHAR (255)) CHARACTER SET=UTF8;"
-      # 
+      #
       def create_sql(ds,table,charset="UTF8")
         sql="CREATE TABLE #{table} ("
         fields=ds.fields.collect{|f|
@@ -81,14 +81,14 @@ module Statsample
         fields=row.to_a.collect{|c|
           if c.nil?
             i+=1
-            "var%05d" % i 
+            "var%05d" % i
           else
             c.to_s.downcase
-          end        
+          end
         }
         fields.recode_repeated
       end
-                                         
+
       def process_row(row,empty)
         row.to_a.map do |c|
           if empty.include?(c)
@@ -115,7 +115,7 @@ module Statsample
           end
         end
       end
-    
+
     end
   end
     class PlainText < SpreadsheetBase
@@ -137,7 +137,7 @@ module Statsample
         end
       end
     end
-  class Excel < SpreadsheetBase 
+  class Excel < SpreadsheetBase
     class << self
       # Write a Excel spreadsheet based on a dataset
       # * TODO: Format nicely date values
@@ -177,7 +177,7 @@ module Statsample
         }
       end
       private :process_row, :preprocess_row
-      
+
       # Returns a dataset based on a xls file
       # USE:
       #     ds = Statsample::Excel.read("test.xls")
@@ -186,20 +186,19 @@ module Statsample
         require 'spreadsheet'
         raise "options should be Hash" unless opts.is_a? Hash
         opts_default={
-          :worksheet_id=>0, 
-          :ignore_lines=>0, 
+          :worksheet_id=>0,
+          :ignore_lines=>0,
           :empty=>['']
         }
-        
+
         opts=opts_default.merge opts
-        
+
         worksheet_id=opts[:worksheet_id]
         ignore_lines=opts[:ignore_lines]
         empty=opts[:empty]
-        
+
         first_row=true
         fields=[]
-        fields_data={}
         ds=nil
         line_number=0
         book = Spreadsheet.open filename
@@ -214,7 +213,7 @@ module Statsample
             }
             line_number+=1
             next if(line_number<=ignore_lines)
-            
+
             preprocess_row(row,dates)
             if first_row
               fields=extract_fields(row)
@@ -296,7 +295,7 @@ module Statsample
 				variables_def=dataset.fields.collect{|k|
 					variable_definition(carrier,dataset[k],k)
 				}.join("\n")
-				
+
 				indexes=carrier.categorials.inject({}) {|s,c|
 					s[dataset.fields.index(c)]=c
 					s
@@ -308,7 +307,7 @@ module Statsample
 					}
 					records << "<record>#{values_definition(c, default_opt[:missing])}</record>\n"
 				}
-				
+
 out=<<EOC
 <?xml version="1.0"?>
 <!DOCTYPE ggobidata SYSTEM "ggobi.dtd">

data/lib/statsample/version.rb

@@ -1,3 +1,3 @@
 module Statsample
-  VERSION = '1.4.1'
+  VERSION = '1.4.2'
 end

data/test/fixtures/scientific_notation.csv

@@ -0,0 +1,4 @@
+x,y
+1,9.629587310436753e+127
+2,1.9341543147883677e+129
+3,3.88485279048245e+130

data/test/helpers_tests.rb

@@ -1,5 +1,6 @@
-$:.unshift(File.expand_path(File.dirname(__FILE__)+'/../lib/'))
-$:.unshift(File.expand_path(File.dirname(__FILE__)+'/'))
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + '/../lib/'))
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + '/'))
+
 require 'minitest'
 require 'minitest/unit'
 require 'mocha/setup'
@@ -11,67 +12,65 @@ require 'fixtures/correlation_matrix'
 
 require 'statsample'
 
-
-module MiniTest
+module Minitest
   class Test
     include Shoulda::Context::Assertions
     include Shoulda::Context::InstanceMethods
     extend Shoulda::Context::ClassMethods
-      def self.should_with_gsl(name,&block)
-        should(name) do
-          if Statsample.has_gsl?
-            instance_eval(&block)
-          else
-            skip("Requires GSL")
-          end
-         
+
+    def self.should_with_gsl(name, &block)
+      should(name) do
+        if Statsample.has_gsl?
+          instance_eval(&block)
+        else
+          skip('Requires GSL')
         end
-    
-      
+      end
     end
   end
 
   module Assertions
-    def assert_similar_vector(exp, obs, delta=1e-10,msg=nil)
-      msg||="Different vectors #{exp} - #{obs}"
+    def assert_similar_vector(exp, obs, delta = 1e-10, msg = nil)
+      msg ||= "Different vectors #{exp} - #{obs}"
       assert_equal(exp.size, obs.size)
-      exp.data_with_nils.each_with_index {|v,i|
-        assert_in_delta(v,obs[i],delta)
+      exp.data_with_nils.each_with_index {|v, i|
+        assert_in_delta(v, obs[i], delta)
       }
     end
-    def assert_equal_vector(exp,obs,delta=1e-10,msg=nil)
+
+    def assert_equal_vector(exp, obs, delta = 1e-10, msg = nil)
       assert_equal(exp.size, obs.size, "Different size.#{msg}")
       exp.size.times {|i|
-        assert_in_delta(exp[i],obs[i],delta, "Different element #{i}. \nExpected:\n#{exp}\nObserved:\n#{obs}.#{msg}")
+        assert_in_delta(exp[i], obs[i], delta, "Different element #{i}. \nExpected:\n#{exp}\nObserved:\n#{obs}.#{msg}")
       }
     end
-    def assert_equal_matrix(exp,obs,delta=1e-10,msg=nil)
-       assert_equal(exp.row_size, obs.row_size, "Different row size.#{msg}")
-       assert_equal(exp.column_size, obs.column_size, "Different column size.#{msg}")
-       exp.row_size.times {|i|
-         exp.column_size.times {|j|
-           assert_in_delta(exp[i,j],obs[i,j], delta, "Different element #{i},#{j}\nExpected:\n#{exp}\nObserved:\n#{obs}.#{msg}")
-         }
-       }
+
+    def assert_equal_matrix(exp, obs, delta = 1e-10, msg = nil)
+      assert_equal(exp.row_size, obs.row_size, "Different row size.#{msg}")
+      assert_equal(exp.column_size, obs.column_size, "Different column size.#{msg}")
+      exp.row_size.times {|i|
+        exp.column_size.times {|j|
+          assert_in_delta(exp[i, j], obs[i, j], delta, "Different element #{i},#{j}\nExpected:\n#{exp}\nObserved:\n#{obs}.#{msg}")
+        }
+      }
     end
-    alias :assert_raise :assert_raises unless method_defined? :assert_raise
-    alias :assert_not_equal :refute_equal unless method_defined? :assert_not_equal
-    alias :assert_not_same :refute_same unless method_defined? :assert_not_same
+    alias_method :assert_raise, :assert_raises unless method_defined? :assert_raise
+    alias_method :assert_not_equal, :refute_equal unless method_defined? :assert_not_equal
+    alias_method :assert_not_same, :refute_same unless method_defined? :assert_not_same
     unless method_defined? :assert_nothing_raised
-      def assert_nothing_raised(msg=nil)
-        msg||="Nothing should be raised, but raised %s"
+      def assert_nothing_raised(msg = nil)
+        msg ||= 'Nothing should be raised, but raised %s'
         begin
           yield
-          not_raised=true
+          not_raised = true
         rescue Exception => e
-          not_raised=false
-          msg=sprintf(msg,e)
+          not_raised = false
+          msg = sprintf(msg, e)
         end
-        assert(not_raised,msg)
+        assert(not_raised, msg)
       end
     end
   end
 end
 
 MiniTest.autorun
-

data/test/test_analysis.rb

@@ -1,77 +1,77 @@
-require(File.expand_path(File.dirname(__FILE__)+'/helpers_tests.rb'))
+require(File.expand_path(File.dirname(__FILE__) + '/helpers_tests.rb'))
 
-class StatsampleAnalysisTestCase < MiniTest::Unit::TestCase
+class StatsampleAnalysisTestCase < Minitest::Test
   context(Statsample::Analysis) do
     setup do
       Statsample::Analysis.clear_analysis
     end
-    should "store() should create and store Statsample::Analysis::Suite" do
+    should 'store() should create and store Statsample::Analysis::Suite' do
       Statsample::Analysis.store(:first) do
-        a=1
+        a = 1
       end
       assert(Statsample::Analysis.stored_analysis[:first])
       assert(Statsample::Analysis.stored_analysis[:first].is_a? Statsample::Analysis::Suite)
     end
-    
-    should "ss_analysis should create an Statsample::Analysis" do
-      ss_analysis(:first) {a=1}
+
+    should 'ss_analysis should create an Statsample::Analysis' do
+      ss_analysis(:first) { a = 1 }
     end
-    should "store last created analysis" do
-      an=Statsample::Analysis.store(:first) do
-        a=1
+    should 'store last created analysis' do
+      an = Statsample::Analysis.store(:first) do
+        a = 1
       end
-      assert_equal(an,Statsample::Analysis.last)
+      assert_equal(an, Statsample::Analysis.last)
     end
-    
-    should "add_to_reportbuilder() add sections to reportbuilder object" do
-      rb=mock()
-      rb.expects(:add).with {|value| value.is_a? ReportBuilder::Section and value.name==:first}
-      rb.expects(:add).with {|value| value.is_a? ReportBuilder::Section and value.name==:second}
-      
+
+    should 'add_to_reportbuilder() add sections to reportbuilder object' do
+      rb = mock
+      rb.expects(:add).with { |value| value.is_a? ReportBuilder::Section and value.name == :first }
+      rb.expects(:add).with { |value| value.is_a? ReportBuilder::Section and value.name == :second }
+
       Statsample::Analysis.store(:first) do
-        echo "first","second"
+        echo 'first', 'second'
       end
       Statsample::Analysis.store(:second) do
-        echo "third"
+        echo 'third'
       end
-      Statsample::Analysis.add_to_reportbuilder(rb,:first,:second)
+      Statsample::Analysis.add_to_reportbuilder(rb, :first, :second)
     end
-    should "to_text returns the same as a normal ReportBuilder object" do
-      rb=ReportBuilder.new(:name=>:test)
-      section=ReportBuilder::Section.new(:name=>"first")
-      a=[1,2,3].to_scale
-      section.add("first")
+    should 'to_text returns the same as a normal ReportBuilder object' do
+      rb = ReportBuilder.new(name: :test)
+      section = ReportBuilder::Section.new(name: 'first')
+      a = [1, 2, 3].to_scale
+      section.add('first')
       section.add(a)
       rb.add(section)
-      exp=rb.to_text
-      an=ss_analysis(:first) {
+      exp = rb.to_text
+      an = ss_analysis(:first) {
         echo 'first'
         summary(a)
       }
-      obs=Statsample::Analysis.to_text(:first)
-      
-      assert_equal(exp.split("\n")[1,exp.size], obs.split("\n")[1,obs.size])
+      obs = Statsample::Analysis.to_text(:first)
+
+      assert_equal(exp.split("\n")[1, exp.size], obs.split("\n")[1, obs.size])
     end
-    
-    should "run() execute all analysis by default" do
-      m1=mock()
+
+    should 'run() execute all analysis by default' do
+      m1 = mock
       m1.expects(:run).once
       m1.expects(:hide).once
-      
+
       Statsample::Analysis.store(:first) do
         m1.run
       end
       Statsample::Analysis.store(:second) do
         m1.hide
       end
-      
+
       # Should run all test
       Statsample::Analysis.run
     end
-    
-    should "run() execute blocks specificed on parameters" do
-      m1=mock()
-      m1.expects(:run).once   
+
+    should 'run() execute blocks specificed on parameters' do
+      m1 = mock
+      m1.expects(:run).once
       m1.expects(:hide).never
       Statsample::Analysis.store(:first) do
         m1.run
@@ -82,78 +82,78 @@ class StatsampleAnalysisTestCase < MiniTest::Unit::TestCase
       # Should run all test
       Statsample::Analysis.run(:first)
     end
-   
+
     context(Statsample::Analysis::Suite) do
-      should "echo() uses output#puts with same arguments" do
-        an=Statsample::Analysis::Suite.new(:output)
-        obj=mock()
-        obj.expects(:puts).with(:first,:second).once
-        an.output=obj
-        an.echo(:first,:second)
-      end
-      should "summary() should call object.summary" do
-        an=Statsample::Analysis::Suite.new(:summary)
-        obj=stub('summarizable',:summary=>'summary')
-        assert_equal(obj.summary,an.summary(obj))
-      end
-      should "attach() allows to call objects on objects which respond to fields" do
-        an=Statsample::Analysis::Suite.new(:summary)
-        ds={'x'=>stub(:mean=>10),'y'=>stub(:mean=>12)}
-        ds.expects(:fields).returns(%w{x y}).at_least_once
+      should 'echo() uses output#puts with same arguments' do
+        an = Statsample::Analysis::Suite.new(:output)
+        obj = mock
+        obj.expects(:puts).with(:first, :second).once
+        an.output = obj
+        an.echo(:first, :second)
+      end
+      should 'summary() should call object.summary' do
+        an = Statsample::Analysis::Suite.new(:summary)
+        obj = stub('summarizable', summary: 'summary')
+        assert_equal(obj.summary, an.summary(obj))
+      end
+      should 'attach() allows to call objects on objects which respond to fields' do
+        an = Statsample::Analysis::Suite.new(:summary)
+        ds = { 'x' => stub(mean: 10), 'y' => stub(mean: 12) }
+        ds.expects(:fields).returns(%w(x y)).at_least_once
         an.attach(ds)
-        assert_equal(10,an.x.mean)
-        assert_equal(12,an.y.mean)
+        assert_equal(10, an.x.mean)
+        assert_equal(12, an.y.mean)
         assert_raise(RuntimeError) {
           an.z
         }
       end
-      should "attached objects should be called LIFO" do
-        an=Statsample::Analysis::Suite.new(:summary)
-        ds1={'x'=>stub(:mean=>100),'y'=>stub(:mean=>120),'z'=>stub(:mean=>13)}
-        ds1.expects(:fields).returns(%w{x y z}).at_least_once
-        ds2={'x'=>stub(:mean=>10),'y'=>stub(:mean=>12)}
-        ds2.expects(:fields).returns(%w{x y}).at_least_once
+      should 'attached objects should be called LIFO' do
+        an = Statsample::Analysis::Suite.new(:summary)
+        ds1 = { 'x' => stub(mean: 100), 'y' => stub(mean: 120), 'z' => stub(mean: 13) }
+        ds1.expects(:fields).returns(%w(x y z)).at_least_once
+        ds2 = { 'x' => stub(mean: 10), 'y' => stub(mean: 12) }
+        ds2.expects(:fields).returns(%w(x y)).at_least_once
         an.attach(ds1)
         an.attach(ds2)
-        assert_equal(10,an.x.mean)
-        assert_equal(12,an.y.mean)        
-        assert_equal(13,an.z.mean)        
-      end
-      
-      should "detach() without arguments drop latest object" do
-        an=Statsample::Analysis::Suite.new(:summary)
-        ds1={'x'=>stub(:mean=>100),'y'=>stub(:mean=>120),'z'=>stub(:mean=>13)}
-        ds1.expects(:fields).returns(%w{x y z}).at_least_once
-        ds2={'x'=>stub(:mean=>10),'y'=>stub(:mean=>12)}        
-        ds2.expects(:fields).returns(%w{x y}).at_least_once
+        assert_equal(10, an.x.mean)
+        assert_equal(12, an.y.mean)
+        assert_equal(13, an.z.mean)
+      end
+
+      should 'detach() without arguments drop latest object' do
+        an = Statsample::Analysis::Suite.new(:summary)
+        ds1 = { 'x' => stub(mean: 100), 'y' => stub(mean: 120), 'z' => stub(mean: 13) }
+        ds1.expects(:fields).returns(%w(x y z)).at_least_once
+        ds2 = { 'x' => stub(mean: 10), 'y' => stub(mean: 12) }
+        ds2.expects(:fields).returns(%w(x y)).at_least_once
         an.attach(ds1)
         an.attach(ds2)
-        assert_equal(10,an.x.mean)
+        assert_equal(10, an.x.mean)
         an.detach
         assert_equal(100, an.x.mean)
       end
-      should "detach() with argument drop select object" do
-        an=Statsample::Analysis::Suite.new(:summary)
-        ds1={'x'=>1}
-        ds1.expects(:fields).returns(%w{x}).at_least_once
-        ds2={'x'=>2,'y'=>3}
-        ds2.expects(:fields).returns(%w{x y}).at_least_once
-        ds3={'y'=>4}
-        ds3.expects(:fields).returns(%w{y}).at_least_once
-        
+      should 'detach() with argument drop select object' do
+        an = Statsample::Analysis::Suite.new(:summary)
+        ds1 = { 'x' => 1 }
+        ds1.expects(:fields).returns(%w(x)).at_least_once
+        ds2 = { 'x' => 2, 'y' => 3 }
+        ds2.expects(:fields).returns(%w(x y)).at_least_once
+        ds3 = { 'y' => 4 }
+        ds3.expects(:fields).returns(%w(y)).at_least_once
+
         an.attach(ds3)
         an.attach(ds2)
         an.attach(ds1)
-        assert_equal(1,an.x)
-        assert_equal(3,an.y)
+        assert_equal(1, an.x)
+        assert_equal(3, an.y)
         an.detach(ds2)
-        assert_equal(4,an.y)
+        assert_equal(4, an.y)
       end
-      should "perform a simple analysis" do
-        output=mock()
+      should 'perform a simple analysis' do
+        output = mock
         output.expects(:puts).with(5.5)
-        an=Statsample::Analysis.store(:simple, :output=>output) do
-          ds=data_frame(:x=>vector(1..10),:y=>vector(1..10))
+        an = Statsample::Analysis.store(:simple, output: output) do
+          ds = data_frame(x: vector(1..10), y: vector(1..10))
           attach(ds)
           echo x.mean
         end
@@ -161,17 +161,16 @@ class StatsampleAnalysisTestCase < MiniTest::Unit::TestCase
       end
     end
     context(Statsample::Analysis::SuiteReportBuilder) do
-      should "echo() use add on rb object" do
-        an=Statsample::Analysis::SuiteReportBuilder.new(:puts_to_add)
+      should 'echo() use add on rb object' do
+        an = Statsample::Analysis::SuiteReportBuilder.new(:puts_to_add)
         an.rb.expects(:add).with(:first).twice
         an.echo(:first, :first)
       end
-      should "summary() uses add on rb object" do
-        an=Statsample::Analysis::SuiteReportBuilder.new(:summary_to_add)
+      should 'summary() uses add on rb object' do
+        an = Statsample::Analysis::SuiteReportBuilder.new(:summary_to_add)
         an.rb.expects(:add).with(:first).once
         an.summary(:first)
       end
     end
-    
   end
 end