optimus-ep 0.6.0 → 0.6.5

data/Manifest.txt

@@ -13,6 +13,7 @@ lib/eprime_reader.rb
 lib/eprimetab_parser.rb
 lib/excel_parser.rb
 lib/log_file_parser.rb
+lib/raw_tab_parser.rb
 lib/runners/generic_runner.rb
 lib/tabfile_parser.rb
 lib/tabfile_writer.rb

data/bin/eprime2tabfile

@@ -84,7 +84,7 @@ module Eprime
       opts.on('-o', '--outfile=OUTFILE', String,
         'The name of the file to create. If this',
         'isn\'t specified, print to the standard',
-        "output"
+        "output."
       ) { |val|
         option_hash[:outfile] = val
       }
@@ -92,14 +92,14 @@ module Eprime
   
       opts.on('-c', '--columns=COLUMN_FILE', String, 
         'A tab-separated file containing the columns',
-        "in the order you want your output"
+        "in the order you want your output."
       ) { |val|
         option_hash[:column_file] = val
       }
       opts.separator ""
       
       opts.on('--filter-columns', TrueClass,
-        'Write out only the columns in COLUMN_FILE',
+        'Write out only the columns in COLUMN_FILE.',
         'Requires the use of --columns'
       ) {
         option_hash[:filter_columns] = true
@@ -109,21 +109,21 @@ module Eprime
 
       opts.on('-a', '--add-filename-line', TrueClass,
         'Print the filename as the first line of',
-        "your output, just like E-DataAid"
+        "your output, just like E-DataAid."
       ) { 
         option_hash[:add_filename_line] = true
       }
       opts.separator ""
 
       opts.on('-f', '--force', TrueClass,
-        "Continue processing even there are errors"
+        "Continue processing even there are errors."
       ) {
         option_hash[:force] = true
       }
       opts.separator ""
 
       opts.on('-h', '--help', TrueClass,
-        'Print this message'
+        'Print this message.'
       ) {
         option_hash[:help] = true
       }

data/bin/extract_timings

@@ -12,10 +12,8 @@ require 'optparse'
 gem 'optimus-ep'
 require 'runners/generic_runner'
 
-script_name = File.basename(__FILE__)
-
 begin
-  txr = Eprime::Runners::GenericRunner.new(Eprime::Transformers::TimingExtractor, script_name, ARGV)
+  txr = Eprime::Runners::GenericRunner.new(Eprime::Transformers::TimingExtractor, ARGV)
   txr.process!
 rescue ArgumentError => e
   STDERR.puts e.message
@@ -23,4 +21,4 @@ rescue ArgumentError => e
 rescue Exception => e
   STDERR.puts e.message
   exit 2
-end
+end

data/lib/eprime_data.rb

@@ -52,9 +52,7 @@ module Eprime
       @column_hash = {}
       @columns_set_in_initialize = false
       if (columns && columns.length > 0)
-        columns.each do |col|
-          idx = self.find_or_add_column_index(col)
-        end
+        add_columns!(columns)
         @columns_set_in_initialize = true
       end
     end
@@ -62,19 +60,31 @@ module Eprime
     # Returns a new Eprime::Data object containing the data from this
     # and all other data sets
     def merge(*datasets)
-      d = Eprime::Data.new
+      cols = [self, *datasets].map { |d| d.columns }.flatten.uniq
+      d = Eprime::Data.new(cols)
       return d.merge!(self, *datasets)
     end
     
     # Combine more Eprime::Data objects into this one, in-place
     def merge!(*datasets)
       datasets.each do |source|
-        source.each do |row|
-          r = self.add_row
-          row.columns.each do |col|
-            r[col] = row[col]
+        add_columns!(source.columns)
+        if source.columns == self.columns
+          # The fast option
+          source.each do |row|
+            r = self.add_row
+            r.sort_value = row.sort_value
+            r.values = row.values
+          end
+        else
+          # The general case option
+          source.each do |row|
+            r = self.add_row
+            row.columns.each do |col|
+              r[col] = row[col]
+            end
+            r.sort_value = row.sort_value
           end
-          r.sort_value = row.sort_value
         end
       end
       return self
@@ -99,18 +109,18 @@ module Eprime
       @rows.send method, *args, &block
     end
     
-    def add_row
+    def add_row()
       row = Row.new(self)
       @rows << row
       return row
     end
     
+    #def add_row_values(values, sort_value = 1)
+    #  r = Row.new(self, values, sort_value)
+    #end
+    
     def find_column_index(col_id)
-      if col_id.is_a? Fixnum
-        return (col_id < @columns.size) ? col_id : nil
-      end
-      # Short-circuit this 
-      @column_hash[col_id] if @column_hash[col_id]
+      @column_hash[col_id]
     end
     
     def find_or_add_column_index(col_id)
@@ -120,23 +130,31 @@ module Eprime
       # indexes.
       return index_id if index_id or col_id.is_a?(Fixnum)
       # In this case, we're adding a column...
+      index = @columns.size
       @columns << col_id
-      index = @columns.length - 1
       @column_hash[col_id] = index
+      @column_hash[index] = index
       if @columns_set_in_initialize and not @options[:ignore_warnings]
         raise ColumnAddedWarning.new("Error: Added column #{col_id} after specifying columns at init", index)
       end
       return index
     end
     
+    private
+    def add_columns!(col_arr)
+      col_arr.each do |c|
+        find_or_add_column_index(c)
+      end
+    end
+    
     class Row
       attr_accessor :sort_value
       
-      def initialize(parent)
-        @data = []
+      def initialize(parent, data = [], sort_value = 1)
         @parent = parent
+        @data = data
         # Ensure it's comparable
-        @sort_value = 1
+        @sort_value = sort_value
       end
       
       def [](index)
@@ -164,13 +182,12 @@ module Eprime
       end
       
       def values
-        vals = []
-        @parent.columns.each_index do |i|
-          vals[i] = @data[i]
-        end
-        return vals
+        return @data
       end
       
+      def values=(ar)
+        @data = ar
+      end
     end
   end
   

data/lib/eprime_reader.rb

@@ -8,6 +8,7 @@
 require 'log_file_parser'
 require 'excel_parser'
 require 'eprimetab_parser'
+require 'raw_tab_parser'
 
 module Eprime
   
@@ -19,7 +20,8 @@ module Eprime
     attr_reader :type, :parser, :input
     attr_accessor :options
     
-    TYPES = {:log => LogfileParser, :excel => ExcelParser, :eprime => EprimetabParser}
+    PARSERS = [LogfileParser, ExcelParser, EprimetabParser, RawTabParser]
+
     def initialize(input = nil, options = {})
       @options = options || {}
       set_input(input) unless input.nil?
@@ -36,7 +38,6 @@ module Eprime
     
     def options=(options)
       @options = options || {}
-      set_parser!
     end
     
     private
@@ -72,17 +73,12 @@ module Eprime
       if @type.nil?
         raise UnknownTypeError.new("Can't determine the type of #{file.path}")
       end
-      set_parser!
-    end
-    
-    def set_parser!
       @eprime_data = nil
-      return unless @type && TYPES[@type]
-      @parser = TYPES[@type].new(@file, @options)
+      @parser = @type.new(@file, @options)
     end
     
     # Determines the type of an eprime file, based on its first two lines.
-    # Returns one of [:log, :eprime_csv, :excel_csv, nil]
+    # Returns one of the elements of PARSERS or nil
     def determine_file_type(first_lines)
       # Log files start with *** Header Start ***
       #
@@ -91,15 +87,9 @@ module Eprime
       #
       # eprime CSV files will have at least three tab-delimited elements on the first line
       
-      if first_lines[0].index("*** Header Start ***")
-        return :log
-      elsif (first_lines[0]["\t"].nil? and first_lines[1].split("\t").size >= 3)
-        return :excel
-      elsif (first_lines[0].split("\t").size >= 3 and first_lines[1].split("\t").size >= 3)
-        return :eprime
-      end
-      # Don't know? Return nil.
-      return nil
+      return PARSERS.detect { |parser_class| 
+        parser_class.can_parse?(first_lines)
+      }
     end
   end
 end

data/lib/eprimetab_parser.rb

@@ -16,6 +16,16 @@ module Eprime
         options = options.merge(:skip_lines => 3)
         super(file, options)
       end
+      
+      def self.can_parse?(lines)
+        divided = lines.map { |l| l.strip.split("\t") }
+        return (
+          divided[0].size >= 3 and 
+          divided[0].size == divided[1].size and
+          divided[0][0] == 'STRING' and
+          divided[1][0] == 'EXPNAME'
+        )
+      end
     end
   end
 end

data/lib/excel_parser.rb

@@ -16,6 +16,11 @@ module Eprime
         options = options.merge(:skip_lines => 1)
         super(file, options)
       end
+      
+      def self.can_parse?(lines)
+        ary = lines.map {|l| l.strip.split("\t")}
+        ary[0].size == 1 and ary[1].size >= 3
+      end
     end
   end
 end

data/lib/log_file_parser.rb

@@ -11,6 +11,7 @@ module Eprime
     # Reads and parses E-Prime log files (the ones that start with 
     # *** Header Start ***) and transforms them into an Eprime::Data structure
     
+    
     class LogfileParser
       # Handles parsing eprime log files, which are essentially a blow-by-blow
       # log of everything that happened during an eprime run.
@@ -93,6 +94,10 @@ module Eprime
         @skip_columns[col_name] = true
       end
       
+      def self.can_parse?(lines)
+        lines[0].include?('*** Header Start ***')
+      end
+      
       private
       # iterate over each line, strip it, look for *** LogFrame Start *** and
       # *** LogFrame End *** -- the content between those goes into a frame array.

data/lib/raw_tab_parser.rb

@@ -0,0 +1,27 @@
+# Part of the Optimus package for managing E-Prime data
+# 
+# Copyright (C) 2008 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
+
+# This almost completely delegates to TabfileParser
+# It differs from EprimetabParser only in that it doesn't skip any lines.
+
+require 'tabfile_parser'
+
+module Eprime
+  class Reader
+    class RawTabParser < TabfileParser
+      def initialize(file, options = {})
+        options = options.merge(:skip_lines => 0)
+        super(file, options)
+      end
+      
+      def self.can_parse?(lines)
+        ary = lines.map { |l| l.strip.split("\t") }
+        ary[0].size > 1 and ary.all? {|e| e.size == ary[0].size}
+      end
+    end
+  end
+end

data/lib/runners/generic_runner.rb

@@ -5,19 +5,9 @@
 # Written by Nathan Vack <njvack@wisc.edu>, at the Waisman Laborotory for Brain
 # Imaging and Behavior, University of Wisconsin - Madison
 
-# A runner to take eprime data files, chew them through a pesudo-templater, 
-# and produce delicious files for importing into other packages. They'll look
-# like:
-#
-# presented     onset     offset
-# stim1         5992      6493
-# stim2         7294      7981
 #
 # This class should handle argument processing, file I/O, and such.
 
-# TODO: Think up a clever way to make this handle arbitrary transformers
-# Probably this is possible by passing the class of the transformer to
-# this runner, and instance_eval()'ing the template file in its presence.
 
 require 'eprime'
 require 'eprime_reader'
@@ -32,9 +22,11 @@ module Eprime
       include ::Eprime::Transformers
       
       attr_accessor :out, :err
-      def initialize(extractor_class, script_name, *args)
+      def initialize(extractor_class, *args)
         @extractor_class = extractor_class
-        @script_name = script_name
+        # caller() returns an array of 'filename:line' -- the last element
+        # should contain the name of the script that started this process
+        @script_name = File.basename(caller.last.split(':').first)
         @out = STDOUT
         @err = STDERR
         @args = args
@@ -51,11 +43,10 @@ module Eprime
       end
       
       def read_data
-        data = Eprime::Data.new
+        data = Eprime::Data.new()
         @options.input_files.each do |infile|
           File.open(infile) do |f|
-            new_data = Eprime::Reader.new(f).eprime_data
-            data.merge!(new_data)
+            data.merge!(Eprime::Reader.new(f).eprime_data)
           end
         end
         @data = data

data/lib/tabfile_parser.rb

@@ -44,9 +44,7 @@ module Eprime
           if col_data.size != expected_size
             raise DamagedFileError.new("In #{@file.path}, line #{current_line} should have #{expected_size} columns but had #{col_data.size}.")
           end
-          col_data.each_index do |i|
-            row[i] = col_data[i]
-          end
+          row.values = col_data
         end
         return data
       end

data/lib/transformers/column_calculator.rb

@@ -32,6 +32,7 @@ module Eprime
         @columns = []
         @columns_intern = []
         @column_indexes = {}
+        @computed = nil
         @rows = []
         COLUMN_TYPES.each do |type|
           instance_variable_set("@#{type}", [])
@@ -42,12 +43,11 @@ module Eprime
     
       # Makes this into a static Eprime::Data object
       def to_eprime_data
-        Eprime::Data.new().merge!(self)
+        computed
       end
     
       def data=(data)
         @data = data
-      
         @data_cols = []
         @data.columns.each do |col_name|
           @data_cols << DataColumn.new(col_name, @data)
@@ -56,26 +56,28 @@ module Eprime
       end
     
       def [](index)
-        compute_data! unless @computed
-        return @rows[index]
+        computed[index]
       end
     
       def column_index(col_id)
-        if col_id.is_a? Fixnum
-          return (col_id >= 0 and col_id < @columns.size) ? col_id : nil
-        end
         return @column_indexes[col_id]
       end
+      
+      alias :find_column_index :column_index
     
       def column(col_id)
         index = column_index(col_id)
         raise IndexError.new("#{col_id} does not exist") if index.nil?
         return @columns_intern[index]
       end
-    
+      
       def size
         @data.size
       end
+      
+      def columns
+        @columns.dup
+      end
     
       def computed_column(name, expression)
         @computed_cols << ComputedColumn.new(name, Expression.new(expression))
@@ -95,18 +97,15 @@ module Eprime
       def sort_expression=(expr)
         # The name 'sorter' is utterly arbitrary and never used
         @sorter = ComputedColumn.new('sorter', Expression.new(expr))
-        @computed = false
+        @computed = nil
       end
     
       def sort_expression
         @sorter.to_s
       end
     
-      def each
-        @data.each_index do |row_index|
-          yield self[row_index]
-        end
-        @rows
+      def each(&block)
+        computed.each(&block)
       end
     
       def self.compute(numeric_expression)
@@ -114,18 +113,23 @@ module Eprime
       end
     
       private
-    
+      
+      def computed
+        @computed || compute_data!
+      end
+      
       def add_column(column)
         # Raise an error if the column already exists
         if @column_indexes[column.name]
           raise ComputationError.new("#{column.name} already exists!")
         end
         # Save the index
+        @column_indexes[@columns_intern.size] = @columns_intern.size
         @column_indexes[column.name] = @columns_intern.size
         @columns_intern << column
         @columns << column.name
       end
-    
+      
       def set_columns!
         @columns = []
         @columns_intern = []
@@ -136,9 +140,9 @@ module Eprime
             add_column(col)
           end
         end
-        @computed = false
+        @computed = nil
       end
-    
+      
       # Creates the infix calculator -- called at class instantiation time
       def self.make_calculator
         @@calculator = ::Eprime::Calculator.new
@@ -150,9 +154,9 @@ module Eprime
       # because copydown and counter columns depend on the values of previous
       # rows.
       def compute_data!
-        @rows = []
-        @data.each_index do |row_index|
-          row = Row.new(self, @data[row_index])
+        @computed = Eprime::Data.new(columns)
+        @data.each_index do |i|
+          row = Row.new(self, @data[i])
           # Loop over each column type -- it's still (slighyly) important that
           # we go over each column type specifically. When counter columns
           # work better, we can rearchitect this a bit.
@@ -173,12 +177,13 @@ module Eprime
           rescue ArgumentError
             # If this fails, it's OK -- we just won't convert.
           end
-          row.sort_value = sv
-          @rows << row
+          new_row = @computed.add_row
+          new_row.sort_value = sv
+          new_row.values = row.values
         end
-        @computed = true
+        @computed
       end
-    
+      
       class Column
         attr_accessor :name
       
@@ -233,6 +238,10 @@ module Eprime
           if path.include?(@name) 
             raise ComputationError.new("#{compute_str} contains a loop with #{@name} -- can't compute")
           end
+          
+          # Allow defining the column computation as a lambda
+          return @expression.expr.call(row) if @expression.expr.is_a? Proc
+            
 
           column_names = @expression.columns
           column_names.each do |col_name|
@@ -285,17 +294,23 @@ module Eprime
       end
     
       class Row
-        attr_reader :computed_data
+        attr_reader :values
         attr_accessor :sort_value
       
         def initialize(parent, rowdata)
           @parent = parent
           @rowdata = rowdata
-          @computed_data = []
-          # Add all the data columns to computed_data
+          @values = []
+          # Add all the data columns to @values
           rowdata.columns.each do |dcol_name|
             index = @parent.column_index(dcol_name)
-            @computed_data[index] = rowdata[dcol_name]
+            rd = rowdata[dcol_name]
+            begin
+              ci = values[index]
+            rescue Exception => e
+              raise e
+            end
+            @values[index] = rowdata[dcol_name]
           end
           @sort_value = 1
         end
@@ -304,7 +319,7 @@ module Eprime
           if @parent.column_index(col_id).nil?
             raise IndexError.new("#{col_id} does not exist")
           end
-          return @computed_data[@parent.column_index(col_id)]
+          return @values[@parent.column_index(col_id)]
         end
       
         def find_column(column_name)
@@ -322,28 +337,31 @@ module Eprime
         
           index = @parent.column_index(col_name)
           col = @parent.column(col_name)
-          @computed_data[index] = col.compute(self)
-          return @computed_data[index]
+          val = col.compute(self)
+          @values[index] = val
+          return val
         end
       
         def <=>(other_row)
           @sort_value <=> other_row.sort_value
         end
-      
       end
     
     
       class Expression
         attr_reader :columns
+        attr_reader :expr
       
         COLUMN_FINDER = /\{([^}]*)\}/ # Finds strings like {foo} and {bar}
         def initialize(expr_string)
           @expr = expr_string
-          @columns = find_columns(expr_string).freeze
+          unless expr_string.is_a? Proc
+            @columns = find_columns(expr_string).freeze 
+          end
         end
       
         def to_s
-          @expr.dup
+          @expr.to_s.dup
         end
       
         private

data/lib/transformers/multipasser.rb

@@ -43,28 +43,20 @@ module Eprime
       def initialize(data = nil)
         @data = data
         @passes = []
-        @computed = false
+        reset!
       end
     
       def columns
-        compute! unless @computed
-        @all_data.columns.dup
+        computed.columns
       end
     
       def data=(data)
         @data = data
-        @computed = false
-      end
-    
-      def each
-        compute! unless @computed
-        @all_data.each do |row|
-          yield row
-        end
+        reset!
       end
     
       def add_pass(*args)
-        @computed = false
+        @computed = nil
         if args[0].instance_of? Pass
           p = args[0]
         else
@@ -73,33 +65,44 @@ module Eprime
         @passes << p and return p
       end
     
+      def each(&block)
+        computed.each(&block)
+      end
+    
       def [](index)
-        compute! unless @computed
-        return @all_data[index]
+        computed[index]
       end
     
       private
-      def compute!
-        @all_data = Eprime::Data.new
+      def computed
+        return @computed if @computed
+        if @passes.empty?
+          @computed = @data
+          return @computed
+        end
+        @computed = Eprime::Data.new
         # Just add a simple pass if we don't have any...
-        add_pass if @passes.empty?
         @passes.each do |pass|
           # We want to duplicate the data, add a sort expression to it, add
           # computed columns, filter it, and then merge it into the complete
           # dataset.
-          cur_data = @data.to_eprime_data 
+          #cur_data = @data.to_eprime_data 
           comp_data = ColumnCalculator.new
-          comp_data.data = cur_data
+          comp_data.data = @data
           comp_data.sort_expression = pass.sort_expression
           pass.computed_columns.each do |col|
             name, expr = *col
             comp_data.computed_column(name, expr)
           end
           filtered = RowFilter.new(comp_data, pass.row_filter)
-          @all_data.merge!(filtered)
+          @computed.merge!(filtered)
         end
-        @all_data = Eprime::Data.new.merge(@all_data.sort)
-        @computed = true
+        @computed.sort!
+        return @computed
+      end
+      
+      def reset!
+        @computed = nil
       end
     end
   end

data/lib/transformers/row_filter.rb

@@ -17,18 +17,32 @@ module Eprime
       def initialize(data, filter)
         @data = data
         @filter = filter
+        @computed = nil
       end
     
       def to_eprime_data
-        Eprime::Data.new().merge!(self)
+        computed
       end
-    
-      def each
-        @data.each do |row|
-          yield row if match?(row)
-        end
+      
+      def method_missing(method, *args, &block)
+        computed.send method, *args, &block
       end
-    
+      
+      private
+      
+      def computed
+        return @computed if @computed
+        @computed = Eprime::Data.new(@data.columns)
+        @data.find_all{ |row|
+          match?(row)
+        }.each { |row|
+          r = @computed.add_row
+          r.values = row.values
+          r.sort_value = row.sort_value
+        }
+        return @computed
+      end
+      
       def match?(row)
         if @filter.is_a? Proc
           return @filter.call(row)

data/lib/version.rb

@@ -2,7 +2,7 @@ module Eprime
   module VERSION
     MAJOR = 0
     MINOR = 6
-    TINY  = 0
+    TINY  = 5
     
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/spec/eprime_data_spec.rb

@@ -45,6 +45,10 @@ shared_examples_for "Eprime::Data with one row" do
     @row[index] = "bitten"
     @row[index].should == "bitten"
   end
+  
+  it "should not lose columns when duplicating" do
+    @data.columns.should == @data.dup.columns
+  end
 
   it "should raise when setting out-of-bound column value" do
     lambda {

data/spec/eprime_reader_spec.rb

@@ -40,7 +40,7 @@ describe Eprime::Reader do
     
     it "should detect log files" do
       @reader.input = (@file)
-      @reader.type.should == :log
+      @reader.type.should == Eprime::Reader::LogfileParser
     end
 
     it "should return the Eprime::Reader::LogfileParser" do
@@ -72,7 +72,7 @@ describe Eprime::Reader do
   
     it "should detect excel csv files" do
       @reader.input = @file
-      @reader.type.should == :excel
+      @reader.type.should == Eprime::Reader::ExcelParser
     end
     
     it "should resutn the Eprime::Reader::ExcelParser" do
@@ -96,7 +96,7 @@ describe Eprime::Reader do
     
     it "should detect eprime csv files" do
       @reader.input = @file
-      @reader.type.should == :eprime
+      @reader.type.should == Eprime::Reader::EprimetabParser
     end
     
     it "should return the Eprime::Reader::EprimetabParser" do
@@ -111,5 +111,17 @@ describe Eprime::Reader do
       data.columns.sort.should == SORTED_COLUMNS
     end
   end
+  
+  describe "with raw tsv files" do
+    before :each do
+      @file = File.open(RAW_TSV_FILE)
+    end
+    
+    
+    it "should detect tsv files" do
+      @reader.input = @file
+      @reader.type.should == Eprime::Reader::RawTabParser
+    end
+  end
 
 end

data/spec/runners/generic_runner_spec.rb

@@ -19,7 +19,7 @@ include EprimeTestHelper
 
 describe Eprime::Runners::GenericRunner do
   before :each do
-    @txr = Eprime::Runners::GenericRunner.new
+    @txr = Eprime::Runners::GenericRunner.new(Eprime::Transformers::BasicTransformer)
   end
   
   it "should start with stdout in @out" do

data/spec/spec_helper.rb

@@ -12,6 +12,7 @@ module EprimeTestHelper
     EXCEL_FILE = File.join(SAMPLE_DIR, 'excel_tsv.txt')
     BAD_EXCEL_FILE = File.join(SAMPLE_DIR, 'bad_excel_tsv.txt')
     EPRIME_FILE = File.join(SAMPLE_DIR, 'eprime_tsv.txt')
+    RAW_TSV_FILE = File.join(SAMPLE_DIR, 'raw_tsv.txt')
     UNKNOWN_FILE = File.join(SAMPLE_DIR, 'unknown_type.txt')
     UNREADABLE_FILE = File.join(SAMPLE_DIR, 'unreadable_file')
     CORRUPT_LOG_FILE = File.join(SAMPLE_DIR, 'corrupt_log_file.txt')
@@ -103,4 +104,10 @@ module EprimeTestHelper
     CONST_EXPRS[sym][1].call.to_s
   end
   
+  def time
+    t1 = Time.now.to_f
+    yield
+    return Time.now.to_f - t1
+  end
+  
 end

data/spec/transformers/column_calculator_spec.rb

@@ -9,6 +9,7 @@ require File.join(File.dirname(__FILE__),'../spec_helper')
 require File.join(File.dirname(__FILE__), '../../lib/eprime')
 
 require 'transformers/column_calculator'
+require 'transformers/row_filter'
 
 include EprimeTestHelper
 
@@ -19,8 +20,12 @@ shared_examples_for "Eprime::Transformers::ColumnCalculator with edata" 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_an_instance_of(Eprime::Transformers::ColumnCalculator::Row)
+    @calc[0].should be_a_kind_of(Eprime::Data::Row)
   end
   
   it "should return data" do
@@ -118,6 +123,17 @@ shared_examples_for "Eprime::Transformers::ColumnCalculator with edata" do
     }.should raise_error(Eprime::Transformers::ColumnCalculator::ComputationError)
   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
+    end
+  end
+  
 end
 
 describe Eprime::Transformers::ColumnCalculator do
@@ -139,31 +155,36 @@ describe Eprime::Transformers::ColumnCalculator do
 
     it "should return data for data columns" do
       @edata[0]['stim_time'].should_not be_nil
-      @calc[0].compute('stim_time').should == @edata[0]['stim_time']
+      @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].compute("always_1").should == "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].compute("test").should == ((3+2)*4).to_s
+      @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].compute("always_1").should == "1"
-      @calc[0].compute("test").should == ((3+2)*4).to_s
+      @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].compute('nonexistent')
+        @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"
@@ -198,6 +219,16 @@ describe Eprime::Transformers::ColumnCalculator do
       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|

data/spec/transformers/multipasser_spec.rb

@@ -9,6 +9,7 @@ require File.join(File.dirname(__FILE__),'../spec_helper')
 require File.join(File.dirname(__FILE__), '../../lib/eprime')
 require 'transformers/multipasser'
 
+include Eprime::Transformers
 include EprimeTestHelper
 
 describe Eprime::Transformers::Multipasser do

data/spec/transformers/row_filter_spec.rb

@@ -29,4 +29,5 @@ describe Eprime::Transformers::RowFilter do
       row['run_start'].should == '2400'
     end
   end
+  
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: optimus-ep
 version: !ruby/object:Gem::Version 
-  version: 0.6.0
+  version: 0.6.5
 platform: ruby
 authors: 
 - Nathan Vack
@@ -9,11 +9,12 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-07-14 00:00:00 -05:00
+date: 2008-09-02 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rparsec
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
@@ -21,6 +22,16 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "1.0"
     version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.7.0
+    version: 
 description: A collection of utilities for working with Eprime data files
 email: 
 - njvack@freshforever.net
@@ -60,6 +71,7 @@ files:
 - lib/eprimetab_parser.rb
 - lib/excel_parser.rb
 - lib/log_file_parser.rb
+- lib/raw_tab_parser.rb
 - lib/runners/generic_runner.rb
 - lib/tabfile_parser.rb
 - lib/tabfile_writer.rb
@@ -119,7 +131,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: optimus-ep
-rubygems_version: 1.0.1
+rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
 summary: A collection of utilities for working with Eprime data files