bio-table 0.0.1

data/features/bio-table-csv-reader-feature.rb

@@ -0,0 +1,28 @@
+# require 'bio-table'
+
+Given /^a comma separated table$/ do |string|
+  @lines = string.split(/\n/)
+end
+
+When /^I read the multi\-line string$/ do
+end
+
+Then /^I should correctly parse the comma\-separated headers into "(.*?)","(.*?)","(.*?)"$/ do |arg1, arg2, arg3|
+  @t = BioTable::Table.new
+  @t.read_lines(@lines, :in_format => :csv)
+  @t.header[0].should == arg1
+  @t.header[1].should == arg2
+  @t.header[2].should == arg3
+end
+
+And /^I should correctly parse the first line into$/ do |string|
+  line1 = @t[0]
+  s = eval(string);
+  line1.fields.should == s
+end
+
+And /^it should have the rowname "(.*?)"$/ do |arg1|
+  @t.rownames[0].should == "105853"
+end
+
+

data/features/bio-table-csv-reader.feature

@@ -0,0 +1,22 @@
+Feature: Read CSV table
+
+  bio-table should read multiple table formats. 
+
+  Scenario: Read a comma separated table
+    Given a comma separated table
+        """
+        #Gene,AJ,B6,Axb1,Axb2,Axb4,Axb12,AXB13,Axb15,Axb19,Axb23,Axb24,Bxa1,Bxa2,Bxa4,Bxa7,Bxa8,Bxa12,Bxa11,Bxa13,Bxa15,Bxa16,Axb5,Axb6,Axb8,Axb1,Bxa24,Bxa25,Bxa26,gene_symbol,gene_desc
+        105853,0.06,0,0,0,0,0,0.11,0,0,0,,,0,0,0,0,0,0,0,0,0,0,0,0,,0,,,Mal2,"MAL2 proteolipid protein"
+        105855,236.88,213.95,213.15,253.49,198,231.56,200.96,255.2,214.04,231.46,,,233.23,241.26,237.53,171.87,237.13,162.3,252.13,284.85,188.76,253.43,220.15,305.52,,217.42,,,Nckap1l,"NCK associated protein 1 like,NCK associated protein 1 like,"
+        105859,0,0.14,0,0,0.07,0.04,0,0,0,0,,,0.02,0,0,0,0,0,0.06,0,0,0,0.02,0,,0,,,Csdc2,"RNA-binding protein pippin"
+        105866,0,0,0,0,0,0,0,0,0,0,,,0,0,0,0,0,0,0,0,0,0,0,0,,0,,,Krt72,"keratin 72"
+        """
+    When I read the multi-line string
+    Then I should correctly parse the comma-separated headers into "#Gene","AJ","B6"
+    And I should correctly parse the first line into 
+      """
+      ["0.06", "0", "0", "0", "0", "0", "0.11", "0", "0", "0", nil, nil, "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", nil, "0", nil, nil, "Mal2", "MAL2 proteolipid protein"]
+      """
+    And it should have the rowname "105853"
+
+

data/features/support/env.rb

@@ -0,0 +1,13 @@
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
+require 'bio-table'
+
+require 'rspec/expectations'

data/lib/bio-table.rb

@@ -0,0 +1,23 @@
+# Please require your code below, respecting the naming conventions in the
+# bioruby directory tree.
+#
+# For example, say you have a plugin named bio-plugin, the only uncommented
+# line in this file would be 
+#
+#   require 'bio/bio-plugin/plugin'
+#
+# In this file only require other files. Avoid other source code.
+
+require 'bio-logger'
+require 'bio-table/columns.rb'
+require 'bio-table/validator.rb'
+require 'bio-table/filter.rb'
+require 'bio-table/parser.rb'
+require 'bio-table/formatter.rb'
+require 'bio-table/tablerow.rb'
+require 'bio-table/table.rb'
+require 'bio-table/tablereader.rb'
+require 'bio-table/tablewriter.rb'
+require 'bio-table/diff.rb'
+require 'bio-table/overlap.rb'
+

data/lib/bio-table/columns.rb

@@ -0,0 +1,11 @@
+module BioTable
+
+  module Columns
+
+    # Returns a list of selected columns, [0] if none set
+    def self.to_list list
+      return [0] if list == nil or list == ""
+      list.map { |item| item.to_i }
+    end
+  end
+end

data/lib/bio-table/diff.rb

@@ -0,0 +1,30 @@
+# Diff module
+#
+
+module BioTable
+
+  module Diff
+
+    def self.diff_tables t1, t2, options 
+      logger = Bio::Log::LoggerPlus['bio-table']
+      columns = Columns::to_list(options[:diff])
+      t = Table.new(t1.header)
+      l1 = t1.map { |row| columns.map { |i| row.all_fields[i] } }
+      l2 = t2.map { |row| columns.map { |i| row.all_fields[i] } }
+      logger.warn "Not all selected keys are unique!" if l1.uniq.size != l1.size or l2.uniq.size != l2.size
+      diff = l2 - l1
+      # create index for table 2
+      idx2 = {}
+      t2.each do | row |
+        key = columns.map { |i| row.all_fields[i] }
+        idx2[key] = row
+      end
+      diff.each do |values|
+        t.push(t2.row_by_columns(columns.zip(values),idx2))
+      end
+      t
+    end
+
+  end
+
+end

data/lib/bio-table/filter.rb

@@ -0,0 +1,57 @@
+module BioTable
+
+  module Filter
+
+    # Create an index to the column headers, so header A,B,C,D with columns
+    # C,A returns [2,0]. It can be the column index is already indexed, return
+    # it in that case.
+    #
+    def Filter::create_column_index columns, header
+      return nil if not columns 
+      numbers = columns.dup.delete_if { |v| not valid_int?(v) }
+      if numbers.size == columns.size
+        return columns.map { |v| v.to_i }
+      end
+
+      index = []
+      columns.each do | name |
+        pos = header.index(name)
+        raise "Column name #{name} not found!" if pos == nil
+        index << pos 
+      end
+      return index
+    end
+
+    def Filter::apply_column_filter fields, index
+      if index
+        index.map { |idx| fields[idx] }
+      else
+        fields
+      end
+    end
+
+    def Filter::valid_int?(s)
+      s.to_i.to_s == s
+    end
+
+    def Filter::valid_number?(s)
+      s.to_s.match(/\A[+-]?\d+?(\.\d+)?\Z/) == nil ? false : true
+    end
+
+    def Filter::numeric code, fields
+      return true if code == nil
+      if fields
+        values = fields.map { |field| (valid_number?(field) ? field.to_f : nil ) } # FIXME: not so lazy
+        begin
+          eval(code)
+        rescue
+          $stderr.print "Failed to evaluate ",fields," with ",code,"\n"
+          raise 
+        end
+      else
+        false
+      end
+    end
+  end
+
+end

data/lib/bio-table/formatter.rb

@@ -0,0 +1,28 @@
+module BioTable
+
+  class TabFormatter
+    def write list
+      print list.map{|field| (field==nil ? "NA" : field)}.join("\t"),"\n"
+    end
+
+  end
+
+  class CsvFormatter
+
+    def write list
+      csv_string = CSV.generate do |csv|
+        csv << list
+      end
+      print csv_string
+    end
+  end
+
+  module FormatFactory
+    def self.create format
+      # @logger.info("Formatting to #{format}")
+      return CsvFormatter.new if format == :csv
+      return TabFormatter.new
+    end
+  end
+end
+

data/lib/bio-table/overlap.rb

@@ -0,0 +1 @@
+# Overlap module

data/lib/bio-table/parser.rb

@@ -0,0 +1,22 @@
+require 'csv'
+
+module BioTable
+
+  module LineParser
+
+    # Converts a string into an array of string fields
+    def LineParser::parse(line, in_format)
+      if in_format == :csv
+        CSV.parse(line)[0]
+      else
+        line.strip.split("\t").map { |field| 
+          fld = field.strip
+          fld = nil if fld == "NA"
+          fld
+        }
+      end
+    end
+    
+  end
+
+end

data/lib/bio-table/table.rb

@@ -0,0 +1,121 @@
+module BioTable
+
+  class Table
+
+    include Enumerable
+
+    attr_reader :header, :rows, :rownames
+
+    def initialize header=nil
+      @header = header if header
+      @logger = Bio::Log::LoggerPlus['bio-table']
+      @rows = []
+      @rownames = []
+    end
+
+    # Read lines (list of string) and add them to the table, setting row names 
+    # and row fields. The first row is assumed to be the header and ignored if the
+    # header has been set.
+
+    def read_lines lines, options = {}
+      num_filter  = options[:num_filter]
+      @logger.debug "Filtering on #{num_filter}" if num_filter 
+      use_columns = options[:columns]
+      @logger.debug "Filtering on columns #{use_columns}" if use_columns 
+      include_rownamess = options[:with_rownamess]
+      @logger.debug "Include row names" if include_rownamess
+      first_column = (include_rownamess ? 0 : 1)
+
+      # parse the header
+      header = LineParser::parse(lines[0], options[:in_format])
+      Validator::valid_header?(header, @header)
+      @header = header if not @header
+
+      column_index = Filter::create_column_index(use_columns,header)
+      @header = Filter::apply_column_filter(header,column_index)
+
+      (lines[1..-1]).each do | line |
+        fields = LineParser::parse(line, options[:in_format])
+        fields = Filter::apply_column_filter(fields,column_index) 
+        rownames = fields[0]
+        data_fields = fields[first_column..-1]
+        next if not Validator::valid_row?(data_fields,@header,@rows)
+        next if not Filter::numeric(num_filter,data_fields)
+        @rownames << rownames if not include_rownamess # otherwise doubles rownamess
+        @rows << data_fields
+      end
+    end
+
+    def read_file filename, options = {}
+      lines = []
+      if not options[:in_format] and filename =~ /\.csv$/
+        @logger.debug "Autodetected CSV file"
+        options[:in_format] = :csv
+      end
+      @logger.debug(options)
+      # Read the file lines into an Array, not lazy FIXME 
+      File.open(filename).each_line do | line |
+        lines.push line
+      end
+      read_lines(lines, options)
+    end
+
+    def write options = {}
+      format = options[:format]
+      format = :tab if not format
+      formatter = FormatFactory::create(format)
+      formatter.write(@header) if options[:write_header]
+      each do | tablerow |
+        # p tablerow
+        formatter.write(tablerow.all_fields) if tablerow.valid?
+      end
+    end
+
+    def push rownames,fields = nil
+      if fields == nil and rownames.kind_of?(TableRow)
+        @rownames << rownames.rowname
+        @rows << rownames.fields
+      else
+        @rownames << rownames
+        @rows << fields
+      end
+    end
+
+    def [] row
+      if row
+        TableRow.new(@rownames[row],@rows[row])
+      else
+        nil
+      end
+    end
+
+    def row_by_name name
+      self[rownames.index(name)]
+    end
+
+    def row_by_columns zip,idx=nil
+      index = zip.first[0]
+      value = zip.first[1]
+      if idx 
+        row = idx[zip.transpose[1]]
+        return row if row.match_all_fields?(zip)
+      else
+        each do | row | 
+          fields = row.all_fields
+          if fields[index] == value
+            return row if row.match_all_fields?(zip)
+          end
+        end
+      end
+      nil
+    end
+
+    def each 
+      @rows.each_with_index do | row,i |
+        yield TableRow.new(@rownames[i], row)
+      end
+    end
+
+  end
+
+end

data/lib/bio-table/tablereader.rb

@@ -0,0 +1,13 @@
+module BioTable
+
+  module TableReader
+    def TableReader::read_file filename, options = {}
+      logger = Bio::Log::LoggerPlus['bio-table']
+      logger.info("Parsing #{filename}")
+      t = Table.new
+      t.read_file(filename, options)
+      t
+    end
+  end
+
+end

data/lib/bio-table/tablerow.rb

@@ -0,0 +1,29 @@
+module BioTable
+
+  class TableRow
+    attr_reader :rowname, :fields
+    def initialize rowname, fields
+      @rowname = rowname
+      @fields = fields
+    end
+
+    def all_fields
+      ([@rowname] << @fields).flatten
+    end
+
+    def valid?
+      fields != nil and fields.size > 0
+    end
+  
+    def match_all_fields? zip
+      row_fields = all_fields
+      zip.each do | a |
+        index = a[0]
+        value = a[1]
+        return false if row_fields[index] != value
+      end
+      true
+    end
+  end
+
+end

data/lib/bio-table/tablewriter.rb

@@ -0,0 +1,6 @@
+module BioTable
+
+  module TableWriter
+  end
+
+end

data/lib/bio-table/validator.rb

@@ -0,0 +1,26 @@
+module BioTable
+
+  module Validator
+    def Validator::valid_header? header, old_header
+      if old_header
+        if header - old_header != []
+          p old_header
+          p header
+          raise "Headers do not compare!"
+        end
+      end
+      true
+    end
+
+    def Validator::valid_row? fields, header, rows
+      return false if fields == nil or fields.size == 0
+      if rows.size>0 and (fields.size != rows.last.size)
+        p rows.last
+        p fields
+        throw "Number of fields diverge in line #{rows.size + 1} (size #{fields.size}, expected #{rows.last.size})"
+      end
+      true
+    end
+  end
+
+end