optimus-ep 0.5

data/lib/log_file_parser.rb

@@ -0,0 +1,208 @@
+# 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
+
+module Eprime
+  class Reader
+    
+    # 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.
+
+      FRAME_START = '*** LogFrame Start ***'
+      FRAME_END = '*** LogFrame End ***'
+      HEADER_START = '*** Header Start ***'
+      HEADER_END = '*** Header End ***'
+      LEVEL_KEY = 'Level'
+      LEVEL_NAME_KEY = 'LevelName'
+      
+      attr_reader :frames
+      attr_reader :levels
+      attr_reader :top_level
+      attr_reader :skip_columns
+      
+      # Valid things for the options hash:
+      #   :columns => an array of strings, predefining the expected columns 
+      #               (and their order)
+      #   :force => true, if you want to ignore things such as column added
+      #               warnings and if the file is incomplete
+      
+      def initialize(file, options = {})
+        @columns = options[:columns]
+        @force = options[:force]
+        @file = file
+        @levels = [''] # The 0 index should be blank.
+        @top_level = 0 # This is the level of the frame that'll generate output rows
+        @skip_columns = {} # A hash of columns we *don't* want to add -- just define the strings
+      end
+      
+      def make_frames!
+        read_levels(@file)
+        @frames = frameify(@file)
+        set_parents!
+        set_counters!
+      end
+      
+      def to_eprime
+        begin
+          if @frames.nil? or @frames.empty?
+            make_frames!
+          end
+        rescue Exception => e
+          unless @force
+            raise e
+          end
+        end
+        if @columns
+          data = Eprime::Data.new(@columns)
+        else
+          data = Eprime::Data.new
+        end
+        self.top_frames.each do |frame|
+          row = data.add_row
+          frame.columns.each do |column, value|
+            begin
+              # Do a check for columns to skip -- this will happen in the case
+              # where you have Procedure[Session] and Procedure[Task] -- we
+              # shouldn't have Procedure, in that case.
+              unless @skip_columns[column]
+                row[column] = value
+              end
+            rescue Exception => e
+              unless @force
+                raise e
+              end
+            end
+          end
+        end
+        return data
+      end
+      
+      def top_frames
+        return frames.find_all { |frame| frame.level == @top_level }
+      end
+      
+      # Define this as a column we *should not* include in out output.
+      def skip_column(col_name)
+        @skip_columns[col_name] = true
+      end
+      
+      private
+      # iterate over each line, strip it, look for *** LogFrame Start *** and
+      # *** LogFrame End *** -- the content between those goes into a frame array.
+      # If we start a frame but don't end it, raise a DamagedFileError
+      def frameify(file)
+        in_frame = false
+        frames = []
+        frame = Frame.new(self)
+        level = 0
+        file.each_line do |line|
+          # TODO? Refactor this out into its own private function
+          l_s = line.strip
+          key, val = l_s.split(/: */, 2) # There isn't always a space, and values can contain colons
+          
+          if !in_frame
+            if key == LEVEL_KEY
+              frame.level = val.to_i
+              @top_level = frame.level if frame.level > @top_level
+            elsif key == FRAME_START
+              in_frame = true
+            end
+          else
+            if key == FRAME_END
+              in_frame = false
+              frames << frame
+              frame = Frame.new(self)
+            else
+              # Add the data to our frame
+              # One more special thing: Experiment gets renamed ExperimentName. WTF?
+              key = "ExperimentName" if key == "Experiment"
+              frame[key] = val
+            end
+          end
+        end
+        raise DamagedFileError.new("Last frame never closed in #{file.path}") if in_frame
+        return frames
+      end
+      
+      # Reads through the header and resets the file to its starting position
+      def read_levels(file)
+        in_header = false
+        file.each_line do |line|
+          l_s = line.strip
+          key, val = l_s.split(': ')
+          if !in_header
+            if key == HEADER_START
+              in_header = true
+            end
+          else
+            if key == HEADER_END
+              file.rewind
+              return # Get out of this function!
+            else
+              if key == LEVEL_NAME_KEY
+                @levels << val
+              end
+            end
+          end
+        end
+      end
+      
+      def set_counters!
+        counts = [0] * (@levels.length+1)
+        @frames.each do |frame|
+          counts[frame.level] += 1
+          key = @levels[frame.level]
+          frame[key] = counts[frame.level]
+          counts.fill(0, (frame.level+1)..@levels.length)
+        end
+      end
+      
+      def set_parents!
+        parents = []
+        @frames.reverse_each do |frame|
+          parents[frame.level] = frame
+          frame.parent = parents[frame.level-1] # This will be nil for empty slots.
+        end
+      end
+      
+      class Frame
+        attr_accessor :level
+        attr_accessor :parent
+        def initialize(parser)
+          @level = nil
+          @parent = nil
+          @data = Hash.new
+          @parser = parser
+        end
+        
+        def columns
+          my_data = @data.dup
+          return my_data if @parent.nil?
+          parent_data = @parent.columns
+          parent_data.each do |key, val|
+            if my_data.has_key?(key)
+              @parser.skip_column(key)
+              # Append a string like "[Session]" or "[Block]" to the key name
+              my_data["#{key}[#{@parser.levels[@level]}]"] = my_data[key]
+              my_data["#{key}[#{@parser.levels[@parent.level]}]"] = val
+            else
+              my_data[key] = parent_data[key]
+            end
+          end
+          return my_data
+        end
+        
+        def method_missing(meth, *args)
+          @data.send meth, *args
+        end
+      end
+    end # Class LogfileParser
+  end # Class Reader
+end # Module Eprime

data/lib/row_filter.rb

@@ -0,0 +1,40 @@
+# 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
+
+module Eprime
+  
+  # Implements a row-wise filter for eprime data.
+  # Right now it requires a proc; I'll do something better with a little
+  # DSL later.
+  class RowFilter
+    include Enumerable
+    
+    def initialize(data, filter)
+      @data = data
+      @filter = filter
+    end
+    
+    def each
+      @data.each do |row|
+        yield row if match?(row)
+      end
+    end
+    
+    def match?(row)
+      if @filter.is_a? Proc
+        return @filter.call(row)
+      elsif @filter.is_a? Array
+        # @filter will be of the form [col_name, comparator, [value]]
+        # only 'equals' is supported for comparators
+        if @filter[1].downcase != 'equals'
+          raise ArgumentError.new('Only equals is supported in filtering')
+        end
+        return row[@filter[0]].to_s == @filter[2].to_s
+      end
+    end
+  end
+end

data/lib/tabfile_parser.rb

@@ -0,0 +1,55 @@
+# 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
+
+
+module Eprime
+  class Reader
+    
+    # This class is for reading tab-delimited Eprime files. (Or, really, any tab-delimited file).
+    # The main option of interest is the :skip_lines option, which specifies how many lines
+    # to skip before finding column names. For example:
+    #
+    # TabfileParser.new(stream, :skip_lines => 1)
+    #
+    # is what you'd use for skipping the filename line in a standard eprime Excel file.
+    #
+    # Note: you'll generally be using subclasses of this, and not manually specifying skip_lines.
+    
+    class TabfileParser
+      def initialize(file, options = {})
+        @file = file
+        @skip_lines = options[:skip_lines] || 0
+        @columns = options[:columns]
+      end
+      
+      def to_eprime
+        lines = @file.readlines
+        @skip_lines.times do
+          lines.shift
+        end
+        
+        file_columns = lines.shift.split("\t").map {|elt| elt.strip }
+        expected_size = file_columns.size
+        columns = file_columns
+        data = Eprime::Data.new(columns)
+        current_line = @skip_lines+1
+        lines.each do |line|
+          current_line += 1
+          row = data.add_row
+          col_data = line.split("\t").map {|e| e.strip }
+          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
+        end
+        return data
+      end
+    end
+  end 
+end

data/lib/tabfile_writer.rb

@@ -0,0 +1,44 @@
+# 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
+
+# Just use the standard Ruby CSV processing library; it'll make our lives
+# way easier (by handling in-band tabs, etc)
+require 'csv'
+
+module Eprime
+  
+  # Writes an Eprime::Data object as a tab-delmited file -- hopefully exactly
+  # like E-DataAid.
+  class TabfileWriter
+    
+    # Create a writer, but don't actually write the output.
+    # Valid things in the options hash:
+    # :write_top_line => true, if you want to include the filename
+    #   (if it's a file output stream) as the first line output
+    def initialize(eprime_data, outstream, options = {})
+      @eprime = eprime_data
+      @outstream = outstream
+      @write_top_line = options[:write_top_line]
+      @columns = options[:columns] || @eprime.columns
+    end
+    
+    # Write to the output stream.
+    def write
+      CSV::Writer.generate(@outstream, "\t") do |tsv|
+        if @write_top_line
+          name = @outstream.respond_to?(:path) ? File.expand_path(@outstream.path.to_s) : ''
+          tsv << [name]
+        end
+        tsv << @columns
+        @eprime.each do |row|
+          vals = @columns.map { |col_name| row[col_name] }
+          tsv << vals
+        end
+      end
+    end
+  end
+end

data/lib/writers/stimtimes_writer.rb

@@ -0,0 +1,97 @@
+# 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 class is a bit ugly around the edges -- I'm not quite sure how to
+# architect it, yet.
+
+require 'eprime'
+require 'column_calculator'
+require 'row_filter'
+
+module Eprime
+  class StimtimesWriter
+    @@computed_columns = []
+    @@counter_columns = []
+    @@copydown_columns = []
+    @@runs = 0
+    @@run_column = ''
+    @@output_files = []
+    
+    def initialize(argv)
+      # Look through our necessary class variables and do some odd stuff
+      edata = Eprime::Data.new
+      argv.each do |filename|
+        File.open(filename, 'r') do |f|
+          reader = Eprime::Reader.new(f)
+          edata.merge!(reader.eprime_data)
+        end
+        
+        @calc = Eprime::ColumnCalculator.new
+        @calc.data = edata
+        @@computed_columns.each do |coldata|
+          @calc.computed_column *coldata
+        end
+        
+        @@counter_columns.each do |coldata|
+          @calc.counter_column *coldata
+        end
+        
+        @@copydown_columns.each do |coldata|
+          @calc.copydown_column *coldata
+        end
+        
+
+        @@output_files.each do |output|
+          filename, filter, output_column = output
+          self.output_file(filename, filter, output_column)
+        end
+      end
+    end
+
+    def output_file(filename, filter, output_column)
+      File.open(filename, 'w') do |file|
+        filtered = Eprime::RowFilter.new(@calc, filter)
+        
+        1.upto(@@runs) do |run|            
+          run_rows = filtered.find_all {|row| row[@@run_column].to_s == run.to_s}.to_a
+          vals = run_rows.map { |r| r[output_column] }
+          if vals.size == 0
+            file.puts "**"
+          else
+            file.puts((vals << "*").join(' '))
+          end
+        end
+      end
+    end
+    
+    class << self
+      def computed_column(*args)
+        @@computed_columns << args
+      end
+      
+      def counter_column(*args)
+        @@counter_columns << args
+      end
+      
+      def copydown_column(*args)
+        @@copydown_columns << args
+      end
+      
+      def runs(runs)
+        @@runs = runs
+      end
+      
+      def run_column(col_name)
+        @@run_column = col_name
+      end
+      
+      def output_file(*args)
+        @@output_files << args
+      end
+    end
+  end
+end

data/spec/calculator_spec.rb

@@ -0,0 +1,56 @@
+# 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
+
+require File.join(File.dirname(__FILE__),'spec_helper')
+require File.join(File.dirname(__FILE__), '../lib/eprime')
+require 'calculator'
+
+include EprimeTestHelper
+
+describe Eprime::Calculator do
+  before :all do
+    @calc = Eprime::Calculator.new
+  end
+  
+  it "should compute constants" do
+    @calc.compute(es(:const)).should == ev(:const)
+  end
+  
+  it "should add" do
+    @calc.compute(es(:add)).should == ev(:add)
+  end
+  
+  it "should multiply" do
+    @calc.compute(es(:mul)).should == ev(:mul)
+  end
+  
+  it "should handle negation" do
+    @calc.compute(es(:add_neg)).should == ev(:add_neg)
+  end
+  
+  it "should handle grouping" do
+    @calc.compute(es(:add_mul_group)).should == ev(:add_mul_group)
+  end
+  
+  it "should handle fdiv" do
+    @calc.compute(es(:fdiv)).should == ev(:fdiv)
+  end
+  
+  it "should handle fmul" do
+    @calc.compute(es(:fmul)).should == ev(:fmul)
+  end
+  
+  it "should handle mod" do
+    @calc.compute(es(:mod)).should == ev(:mod)
+  end
+  
+  it "should fail with infix garbage" do
+    lambda {
+      @calc.compute("1 broken 2")
+    }.should raise_error(RParsec::ParserException)
+  end
+end