optimus-ep 0.6.91 → 0.8.0

data/spec/transformers/column_calculator_spec.rb

@@ -1,437 +1,182 @@
 # Part of the Optimus package for managing E-Prime data
 # 
-# Copyright (C) 2008 Board of Regents of the University of Wisconsin System
+# Copyright (C) 2008-09 Board of Regents of the University of Wisconsin System
 # 
 # Written by Nathan Vack <njvack@wisc.edu>, at the Waisman Laborotory for Brain
 # Imaging and Behavior, University of Wisconsin - Madison
 
 require File.join(File.dirname(__FILE__),'../spec_helper')
-require File.join(File.dirname(__FILE__), '../../lib/eprime')
+require File.join(File.dirname(__FILE__), '../../lib/optimus')
 
 require 'transformers/column_calculator'
-require 'transformers/row_filter'
 
-include EprimeTestHelper
+include OptimusTestHelper
 
 NEW_COLUMN = 'NEW_COLUMN'
 
-shared_examples_for "Eprime::Transformers::ColumnCalculator with edata" do
-  it "should have the proper size" do
-    @calc.size.should == @edata.size
-  end
-  
-  it "should not be nil" do
-    @calc[0].should_not be_nil
-  end
-  
-  it "should allow accessing rows" do
-    @calc[0].should be_a_kind_of(Eprime::Data::Row)
-  end
-  
-  it "should return data" do
-    @calc[0]['stim_time'].should == @edata[0]['stim_time']
-  end
-  
-  it "should compute column indexes for data column names" do
-    @calc.column_index('stim_time').should == 0
-    @calc.column_index('run_start').should == 1
-  end
-  
-  it "should find column indexes for data columns" do
-    @calc.column_index(0).should == 0
-    @calc.column_index(1).should == 1
-  end
-  
-  it "should return nil when searching for out-of-bound named indexes" do
-    @calc.column_index('not_present').should be_nil
-  end
-  
-  it "should return nil when searching for out-of-bound numeric indexes" do
-    @calc.column_index(@calc.columns.size).should be_nil
-  end
-  
-  it "should allow setting a computed column" do
-    lambda {
-      @calc.computed_column NEW_COLUMN, "1"
-    }.should_not raise_error
+describe Optimus::Transformers::ColumnCalculator do
+  before :each do
+    @edata = mock_edata
+    @pc = Optimus::Transformers::ColumnCalculator.new
+    @pc.data = @edata
   end
   
-  it "should allow setting a copydown column" do
+  it "should allow adding a computed column" do
     lambda {
-      @calc.copydown_column 'sparse_copy', 'sparse'
+      @pc.computed_column NEW_COLUMN, "1+1"
     }.should_not raise_error
   end
   
-  it "should contain new name when setting computed column" do
-    @calc.computed_column NEW_COLUMN, "1"
-    @calc.columns.should include(NEW_COLUMN)
-  end
-  
-  it "should contain the new name when setting copydown column" do
-    @calc.copydown_column 'sparse_copy', 'sparse'
-    @calc.columns.should include('sparse_copy')
-  end
-  
-  it "should increse in column size when setting computed column" do
-    s1 = @calc.columns.size
-    @calc.computed_column NEW_COLUMN, "1"
-    s2 = @calc.columns.size
-    s2.should == s1+1
+  it "should be enumerable" do
+    @pc.should be_a_kind_of(Enumerable)
   end
   
-  it "should compute the proper column index for computed columns" do
-    prev_max_index = @calc.columns.size-1
-    @calc.computed_column NEW_COLUMN, "1"
-    @calc.column_index(NEW_COLUMN).should == prev_max_index+1
+  it "should have columns" do
+    @pc.columns.sort.should == @edata.columns.sort
   end
   
-  it "should find numeric indexes for computed columns" do
-    get_index = @calc.columns.size
-    @calc.computed_column NEW_COLUMN, '1'
-    @calc.column_index(get_index).should == get_index
+  it "should add new columns" do
+    @pc.computed_column NEW_COLUMN, "1"
+    @pc.columns.should include(NEW_COLUMN)
   end
   
-  it "should allow named indexing for computed columns" do
-    @calc.computed_column NEW_COLUMN, "1"
+  it "should raise an error when adding bad columns" do
     lambda {
-      @calc[0][NEW_COLUMN]
-    }.should_not raise_error
+      @pc.computed_column NEW_COLUMN, "FIAL"
+    }.should raise_error(RParsec::ParserException)
   end
   
-  it "should allow numeric indexing for computed columns" do
-    @calc.computed_column NEW_COLUMN, "1"
-    lambda {
-      @calc[0][NEW_COLUMN]
-    }.should_not raise_error
+  it "should bring forth existing data" do
+    col = @edata.columns[0]
+    @pc.map {|row| row[col]}.should == @edata.map {|row| row[col]}
   end
   
-  it "should raise when name-indexing nonexistent column" do
-    lambda {
-      @calc[0][NEW_COLUMN]
-    }.should raise_error(IndexError)
+  it "should return values for columns based on literals" do
+    @pc.computed_column NEW_COLUMN, "1"
+    @pc.each do |row|
+      row[NEW_COLUMN].should == 1
+    end
   end
   
-  it "should raise when numerically indexing nonexistent column" do
-    lambda {
-      @calc[0][@calc.columns.size]
-    }.should raise_error(IndexError)
+  it "should return values for columns based on lambdas" do
+    @pc.computed_column NEW_COLUMN, lambda {|row| row['stim_time'] }
+    @pc.computed_column "NEW_COL2", lambda {|row| 1}
+    @pc.each do |row|
+      row[NEW_COLUMN].should == row['stim_time']
+      row["NEW_COL2"].should == 1
+    end
   end
   
-  it "should raise when adding computed column with existing column name" do
-    lambda {
-      @calc.computed_column @edata.columns[0], '1'
-    }.should raise_error(Eprime::Transformers::ColumnCalculator::ComputationError)
+  it "should return computed columns based on literal columns" do
+    @pc.computed_column NEW_COLUMN, "{stim_time}"
+    @pc.each do |row|
+      row[NEW_COLUMN].should == row['stim_time'].to_f
+    end
   end
   
-  it "should work in a RowFilter" do
-    d = mock_edata
-    cc = Eprime::Transformers::ColumnCalculator.new
-    cc.data = d
-    cc.sort_expression = '1'
-    filtered = Eprime::Transformers::RowFilter.new(cc, lambda {|r| true})
-    filtered.each do |r|
-      r.should_not be_nil
+  it "should return computed columns based on other computed columns" do
+    @pc.computed_column "FOO2", "{#{NEW_COLUMN}}"
+    @pc.computed_column NEW_COLUMN, "{stim_time}"
+    @pc.each do |row|
+      row["FOO2"].should == row['stim_time'].to_f
     end
   end
   
-end
-
-describe Eprime::Transformers::ColumnCalculator do
-  before :each do
-    @edata = mock_edata
-    @calc = Eprime::Transformers::ColumnCalculator.new
-    @calc.data = @edata
+  it "should raise a loop error when detecting a loop" do
+    @pc.computed_column "nc1", "{nc2}"
+    @pc.computed_column "nc2", "{nc1}"
+    lambda {
+      @pc[0]
+    }.should raise_error(Optimus::EvaluationLoopError)
   end
   
-  describe "(with no computed columns)" do
-    it "should should have only static columns" do
-      @calc.columns.should == @edata.columns
+  it "should pass a somewhat arbitrary test" do
+    @pc.computed_column "result", "({stim_time} - {run_start})+ 100 / 2"
+    @pc.each do |row|
+      row['result'].should == (
+        (row['stim_time'].to_f - row['run_start'].to_f)+100/2)
     end
-    
-    it_should_behave_like "Eprime::Transformers::ColumnCalculator with edata"
   end
   
-  describe "(statically computing columns)" do
-
-    it "should return data for data columns" do
-      @edata[0]['stim_time'].should_not be_nil
-      @calc[0]['stim_time'].should == @edata[0]['stim_time']
-    end
-    
-    it "should compute static columns on single rows" do
-      @calc.computed_column "always_1", "1"
-      @calc[0]["always_1"].should == "1"
-    end
-    
-    it "should compute on single rows with some math" do
-      @calc.computed_column "test", "(3+2)*4"
-      @calc[0]["test"].should == ((3+2)*4).to_s
-    end
-    
-    it "should allow adding two columns" do 
-      @calc.computed_column "always_1", "1"
-      @calc.computed_column "test", "(3+2)*4"
-      @calc[0]["always_1"].should == "1"
-      @calc[0]["test"].should == ((3+2)*4).to_s
-    end
-    
-    it "should raise when computing nonexistent column" do
-      lambda {
-        @calc[0]['nonexistent']
-      }.should raise_error(IndexError)
-    end
-    
-    it "should allow computing via lambda" do
-      @calc.computed_column "always_1", lambda {|r| "1"}
-      @calc[0]["always_1"].should == "1"
-    end
-
-    it "should compute constants via indexing" do 
-      @calc.computed_column "always_1", "1"
-       @calc[0]["always_1"].should == "1"
-    end
-    
-    it "should compute with add, mul, and grouping via indexing" do
-      # See calculator_spec.rb for exhaustive testing of the parser
-      @calc.computed_column "add_mul", "5*(6+2)"
-      @calc.each do |row|
-        row["add_mul"].should == (5*(6+2)).to_s
-      end
-    end
-    
-    it "should work with multiple computed columns via indexing" do
-      @calc.computed_column "always_1", "1"
-      @calc.computed_column "add_mul", "5*(6+2)"
-      
-      @calc.each do |row|
-        row["always_1"].should == "1"
-        row["add_mul"].should == (5*(6+2)).to_s
-      end
-    end
+  it "should not allow adding a column with an existing name" do
+    lambda {
+      @pc.computed_column "stim_time", "1"
+    }.should raise_error(Optimus::DuplicateColumnError)
   end
   
-  describe "(with computed columns)" do
-    
-    it "should compute based on data columns" do
-      @calc.computed_column "stim_time_s", "{stim_time}/1000"
-      @calc.each do |row|
-        row["stim_time_s"].should == (row["stim_time"].to_f/1000.0).to_s
-      end
-    end
-    
-    it "should compute based on data columns by lambda" do
-      @calc.computed_column "stim_time_s", lambda { |row|
-        row['stim_time'].to_f/1000
-      }
-      @calc.columns.should include('stim_time_s')
-      @calc.each do |row|
-        row['stim_time_s'].should == row['stim_time'].to_f/1000
-      end
-    end
-    
-    it "should allow math between two columns" do
-      @calc.computed_column "stim_from_run", "{stim_time}-{run_start}"
-      @calc.each do |row|
-        row['stim_from_run'].should == (row['stim_time'].to_i - row['run_start'].to_i).to_s
-      end
-    end
-    
-    it "should allow columns based on other computed columns" do
-      @calc.computed_column "stim_from_run", "{stim_time}-{run_start}"
-      @calc.computed_column "stim_run_s", "{stim_from_run} / 1000"
-      @calc.each do |row|
-        row['stim_run_s'].should == ((row['stim_time'].to_f - row['run_start'].to_f)/1000.0).to_s
-      end
-    end
-    
-    it "should fail to compute with nonexistent columns" do
-      @calc.computed_column "borked", "{stim_time} - {not_there}"
+  describe "with reset logic" do
+    it "should allow setting a column with reset_when logic" do
       lambda {
-        @calc[0]["borked"]
-      }.should raise_error(IndexError)
-    end
-    
-    it "should assume zero when a column has blank values" do
-      @calc.computed_column "sparse_plus_0", "{sparse} + 0"
-      @calc.each do |row|
-        row["sparse"].to_f.should == row["sparse_plus_0"].to_f
-      end
-    end
-    
-    it "should detect loops in column computation" do
-      @calc.computed_column "loop1", "{stim_time} - {run_start} - {loop3}"
-      @calc.computed_column "loop2", "{loop1}"
-      @calc.computed_column "loop3", "{loop2}"
-      @calc.computed_column "loop4", "{loop3}"
-      lambda {
-        @calc[0]['loop4']
-      }.should raise_error(Eprime::Transformers::ColumnCalculator::ComputationError)
-    end
-    
-    it "should compute columns when there are two paths to a node" do
-      @calc.computed_column "c1", "{stim_time} - {run_start}"
-      @calc.computed_column "c2", "{c1}"
-      @calc.computed_column "c3", "{c1} - {c2}"
-      lambda {
-        @calc[0]["c3"]
+        @pc.computed_column NEW_COLUMN, "{stim_time}", :reset_when => "1"
       }.should_not raise_error
     end
     
-  end
-  
-  describe "(with sort column)" do
-    it "should sort normally by an increasing column" do
-      @calc.sort_expression = '{stim_time}'
-      @calc.sort.each_index do |row_index|
-        @calc[row_index]['stim_time'].should == @edata[row_index]['stim_time']
+    it "should reset only when condition passes" do
+      @pc.computed_column NEW_COLUMN, "{stim_time}", 
+        :reset_when => "{sparse}"
+      val = ''
+      @pc.each do |row|
+        val = row['stim_time'] if row['sparse'].to_s != ''
+        row[NEW_COLUMN].to_f.should == val.to_f
       end
     end
     
-    it "should sort in reverse when negating increasing column" do
-      flipped = @edata.sort_by { |row| (row['stim_time'].to_i*-1)}
-      @calc.sort_expression = '-{stim_time}'
-      sorted = @calc.sort
-      sorted.each_index do |row_index|
-        sorted[row_index]['stim_time'].should == flipped[row_index]['stim_time']
+    it "should reset with an always true condition" do
+      @pc.computed_column NEW_COLUMN, "{stim_time}", :reset_when => "1"
+      @pc.each do |row|
+        row[NEW_COLUMN].to_f.should == row['stim_time'].to_f
       end
     end
     
-    it "should maintain sort order when becoming eprime data" do
-      @calc.sort_expression = '{stim_time}'
-      ed = @calc.to_eprime_data
-      @calc.to_a.each_index do |i|
-        ed[i].sort_value.should == @calc[i].sort_value
+    it "should never update when false condition" do
+      @pc.computed_column NEW_COLUMN, "{stim_time}", :reset_when => "''"
+      @pc.each do |row|
+        row[NEW_COLUMN].should be_nil
       end
     end
-  end
-  
-  describe "(with copydown columns)" do
-    before :each do
-      @calc.copydown_column 'sparse_copy', 'sparse'
-    end
     
-    it "should work" do
-      last_val = ''
-      @calc.each do |row|
-        if !row['sparse'].to_s.empty?
-          last_val = row['sparse'].to_s
-        end
-        row['sparse_copy'].should == last_val
+    it "should accept :once as a reset condition" do
+      @pc.computed_column NEW_COLUMN, "{stim_time}", :reset_when => :once
+      val = @pc[0]['stim_time']
+      @pc.each do |row|
+        row[NEW_COLUMN].to_f.should == val.to_f
       end
     end
   end
   
-  describe "(with counter columns)" do
-    it "should count up with no options" do
-      @calc.counter_column "count_up"
-      i = 0;
-      @calc.each do |row|
-        i += 1
-        row["count_up"].should == i
-      end
-    end
-  
-    it "should count from 1 when :start_value is set" do
-      @calc.counter_column "count_up", :start_value => 1
-      i = 1
-      @calc.each do |row|
-        i += 1
-        row["count_up"].should == i
+  describe "with counting logic" do
+    it "should count" do
+      init = 0
+      @pc.computed_column NEW_COLUMN, init, :count_when => "1", 
+        :count_by => :next, :reset_when => :once
+      @pc.each do |row|
+        init += 1
+        row[NEW_COLUMN].to_f.should == init.to_f
       end
     end
     
-    it "should count down when :count_by is -1" do
-      @calc.counter_column "count_down", :count_by => -1
-      i = 0
-      @calc.each do |row|
-        i -= 1
-        row['count_down'].should == i
-      end
-    end
-    
-    it "should count by a proc when specified" do
-      @calc.counter_column "count_succ", :count_by => lambda {|val| val.succ}
-      i = 0
-      @calc.each do |row|
-        i = i.succ
-        row["count_succ"].should == i
-      end
-    end
-    
-    it "should count by a symbol when specified" do
-      @calc.counter_column "count_succ", :count_by => :succ
-      i = 0
-      @calc.each do |row|
-        i = i.succ
-        row['count_succ'].should == i
-      end
-    end
-    
-    it "count by a string when specified" do
-      @calc.counter_column "count_succ", :count_by => 'succ'
-      i = 0
-      @calc.each do |row|
-        i = i.succ
-        row['count_succ'].should == i
-      end
-    end
-    
-    it "should count only when :count_when is true" do
-      @calc.counter_column "count_on_sparse", :count_when => lambda {|row| !row['sparse'].to_s.empty? }
+    it "should count sometimes" do
+      init= 0
+      @pc.computed_column NEW_COLUMN, init, :count_when => "{sparse}",
+        :reset_when => :once, :count_by => :next
       
-      i = 0
-      @calc.each do |row|
-        i += 1 if !row['sparse'].to_s.empty?
-        row['count_on_sparse'].should == i
-      end
-    end
-    
-    it "should reset when :reset_when is true" do
-      @calc.counter_column "reset_on_sparse", :reset_when => lambda {|row| !row['sparse'].to_s.empty? }
-      i = 0
-      @calc.each do |row|
-        i = 0 if !row['sparse'].to_s.empty?
-        i += 1
-        row['reset_on_sparse'].should == i
+      @pc.each do |row|
+        if row['sparse'].to_s != ''
+          init += 1
+        end
+        
+        row[NEW_COLUMN].to_f.should == init.to_f
       end
     end
     
-    it "should accept a Proc as a :start_value" do
-      @calc.counter_column "scan_delay", :start_value => lambda {|row|
-        row['stim_time'].to_i - row['run_start'].to_i
-      }
-      sd = @calc[0]['scan_delay']
-      i = 0
-      @calc.each do |row|
-        row['scan_delay'].should == sd+i
-        i += 1
+    it "should reset sometimes" do
+      init = 0
+      @pc.computed_column NEW_COLUMN, init, :count_when => "1", 
+        :count_by => :next, :reset_when => "{sparse}"
+      
+      @pc.each do |row|
+        
       end
     end
   end
-end
-
-describe Eprime::Transformers::ColumnCalculator::Expression do
-  before :each do
-    @expr_str = "({stim_time}-{run_start}) / 1000"
-    @expr = Eprime::Transformers::ColumnCalculator::Expression.new(@expr_str)
-  end
-  
-  it "should find two columns" do
-    @expr.columns.size.should == 2
-  end
-  
-  it "should split into stim_time and run_start" do
-    @expr.columns.sort.should == %w(stim_time run_start).sort
-  end
-  
-  it "should not allow changing columns" do
-    lambda {
-      @expr.columns << 'wakka'
-    }.should raise_error(TypeError)
-  end
-  
-  it "should convert to a string" do
-    @expr.to_s.should == @expr_str
-  end
-end
-
+end

data/spec/transformers/multipasser_spec.rb

@@ -1,18 +1,18 @@
 # Part of the Optimus package for managing E-Prime data
 # 
-# Copyright (C) 2008 Board of Regents of the University of Wisconsin System
+# Copyright (C) 2008-09 Board of Regents of the University of Wisconsin System
 # 
 # Written by Nathan Vack <njvack@wisc.edu>, at the Waisman Laborotory for Brain
 # Imaging and Behavior, University of Wisconsin - Madison
 
 require File.join(File.dirname(__FILE__),'../spec_helper')
-require File.join(File.dirname(__FILE__), '../../lib/eprime')
+require File.join(File.dirname(__FILE__), '../../lib/optimus')
 require 'transformers/multipasser'
 
-include Eprime::Transformers
-include EprimeTestHelper
+include Optimus::Transformers
+include OptimusTestHelper
 
-describe Eprime::Transformers::Multipasser do
+describe Optimus::Transformers::Multipasser do
   before :each do
     @mpass = Multipasser.new(mock_edata)
   end
@@ -62,13 +62,20 @@ describe Eprime::Transformers::Multipasser do
       end
     end
     
+    it "should allow multiple passes" do
+      pass = @mpass.add_pass("{fix_time}")
+      pass.computed_column "presented_time", "{fix_time}"
+      pass.computed_column "presented_name", "'fixation'"
+      @mpass.to_a.size.should == @data.size
+    end
+    
     it "should sort multiple passes together" do
       pass = @mpass.add_pass("{fix_time}")
       pass.computed_column "presented_time", "{fix_time}"
-      pass.computed_column "presented_name", "fixation"
+      pass.computed_column "presented_name", "'fixation'"
       pass = @mpass.add_pass("{stim_time}")
       pass.computed_column "presented_time", "{stim_time}"
-      pass.computed_column "presented_name", "stimulus"
+      pass.computed_column "presented_name", "'stimulus'"
       @mpass.to_a.size.should == @data.size*2
       ps = @mpass.to_a.sort_by{|row| row['presented_time'].to_f}
       @mpass.to_a.each_index do |i|

data/spec/transformers/row_filter_spec.rb

@@ -1,29 +1,34 @@
 # Part of the Optimus package for managing E-Prime data
 # 
-# Copyright (C) 2008 Board of Regents of the University of Wisconsin System
+# Copyright (C) 2008-09 Board of Regents of the University of Wisconsin System
 # 
 # Written by Nathan Vack <njvack@wisc.edu>, at the Waisman Laborotory for Brain
 # Imaging and Behavior, University of Wisconsin - Madison
 
 require File.join(File.dirname(__FILE__),'../spec_helper')
-require File.join(File.dirname(__FILE__), '../../lib/eprime')
+require File.join(File.dirname(__FILE__), '../../lib/optimus')
 require 'transformers/row_filter'
-include EprimeTestHelper
+require 'parsed_calculator'
+include OptimusTestHelper
 
-describe Eprime::Transformers::RowFilter do
+describe Optimus::Transformers::RowFilter do
+  before :all do
+    @parser = Optimus::ParsedCalculator::ExpressionParser.new
+  end
   before :each do
     @edata = mock_edata
   end
   
   it "should allow filtering based on a proc" do
-    filter = Eprime::Transformers::RowFilter.new(@edata, lambda { |row| !row['sparse'].to_s.empty? })
+    filter = Optimus::Transformers::RowFilter.new(@edata, lambda { |row| !row['sparse'].to_s.empty? })
     filter.each do |row|
       row['sparse'].to_s.should_not be_empty
     end
   end
   
   it "should filter based on column equal test" do
-    filter = Eprime::Transformers::RowFilter.new(@edata, ['run_start', 'equals', 2400])
+    exp = @parser.parse("{run_start} = 2400")
+    filter = Optimus::Transformers::RowFilter.new(@edata, exp)
     filter.to_a.size.should_not == 0
     filter.each do |row|
       row['run_start'].should == '2400'