bahuvrihi-hansen_lab 0.0.1

data/MIT-LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2008, YOUR_NAME_HERE
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this
+software and associated documentation files (the "Software"), to deal in the Software
+without restriction, including without limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
+to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/lib/hansen_lab/tasks/align_columns.rb

@@ -0,0 +1,105 @@
+require 'tap/tasks/table_task'
+ 
+module HansenLab
+  module Tasks
+  
+    # startdoc::manifest align table data across multiple files
+    # Aligns the table data across multiple files.  Takes a list of tab-delimited 
+    # input files.
+    #
+    class AlignColumns < Tap::Tasks::TableTask
+    
+      config :sort_column, 0, &c.yaml(String, Integer)      # specifies the sort column, index or name
+      config :default_value, "", &c.string                  # a default string value for empty cells  
+      
+      def format_row(data)
+        data.join(col_sep * 2) + row_sep
+      end
+      
+      def process(target, *filepaths)
+    
+        # load the table data
+        tables = filepaths.collect do |filepath|
+          log_basename :align, filepath
+          parse_table(File.read(filepath))
+        end
+        
+        # hash rows by the sorting keys
+        sorting_keys = []
+        key_hashes = tables.collect do |table|
+          
+          keys = case sort_column
+          when Integer then table.column(sort_column)
+          when String then table.column_by_header(sort_column)
+          end
+          
+          hash = {}
+          keys.each_with_index do |key, i|
+            (hash[key] ||= []) << i
+          end
+          sorting_keys.concat(keys)
+          
+          hash
+        end
+        
+        # sort, omitting empty keys
+        sorting_keys = sorting_keys.uniq.sort.delete_if do |key|
+          key.strip.empty?
+        end
+        
+        # normalize the number of rows for each key, cross table
+        sorting_keys.each do |key|
+          max = key_hashes.inject(0) do |max, hash|
+            row_index = (hash[key] ||= [])
+            row_index.length > max ? row_index.length : max
+          end
+          
+          key_hashes.each do |hash|
+            row_index = hash[key]
+            row_index.concat Array.new(max - row_index.length, nil)
+          end
+        end
+        
+        # prepare the target file and dump the results
+        prepare(target) 
+        File.open(target, "wb") do |file|
+          # print file header
+          header = []
+          filepaths.each_with_index do |filepath, i|
+            table = tables[i]
+            unless table.n_columns == 0
+              array = table.blank_row
+              array[0] = "# #{File.basename(filepath)}"
+              header << array.join(col_sep)
+            end
+          end
+          file.print format_row(header)
+          
+          # print header if applicable
+          if header_row
+            row = tables.collect {|table| table.headers.join(col_sep)}
+            file.print format_row(row)
+          end
+          
+          sorting_keys.each do |key|
+            key_rows = []
+            tables.each_with_index do |table, index|
+              row_index = key_hashes[index][key]
+              rows = row_index.collect do |i| 
+                (i == nil ? table.blank_row : table.data[i]).join(col_sep)
+              end
+              
+              key_rows << rows
+            end
+    
+            key_rows.transpose.collect do |row|
+              file.print format_row(row)
+            end
+          end
+        end
+        
+        target
+      end
+    end
+  end
+end

data/lib/hansen_lab/tasks/align_mod.rb

@@ -0,0 +1,97 @@
+require 'tap/tasks/table_task'
+ 
+module HansenLab
+  module Tasks
+  
+    # :startdoc::manifest align mascot peptide ids at a modification
+    # Aligns Mascot peptide identifications along a modification boundary.
+    #
+    # For example:
+    #   [input.txt]
+    #   AAAQAAA 0.0004000.0 first
+    #   QBBBBBQ 0.4000004.0 second 
+    #
+    # Becomes:
+    #   [input.align]
+    #   |AAA|Q|AAA|first|
+    #   |.|Q|BBBBBQ|second (1)|
+    #   |QBBBBB|Q|.|second (2)|
+    #
+    # Extra fields can be present in the input file, they will be carried forward
+    # to the result file.  If a sequence has multiple modifications, each will be
+    # listed in the result, as above.
+    #
+    # Note that while the results don't seem terribly well aligned here, they can
+    # be turned into a table by using RedCloth (for example by posting the result
+    # as a message to Basecamp), or you can modify the output with the configs.
+    #
+    class AlignMod < Tap::Tasks::TableTask
+      
+      config :mod_numbers, [1], :arg_name => '[1, 2, 3]', &c.array   # the alignment modification number
+      
+      config :output_empty_cell, "", &c.string      # the content for empty output cells
+      config :output_line_format, "%s", &c.string   # the format string for the output lines
+      config :output_col_sep, "\t", &c.string       # the output column delimiter
+      config :default_value, "", &c.string                  # a default string value for empty cells  
+      
+      def format_row(data)
+        output_line_format % data.join(output_col_sep)
+      end
+      
+      def process(target, source)
+    
+        table = parse_table( File.read(source) )
+        
+        prepare(target) 
+        File.open(target, "wb") do |file|
+          
+          # handle the header row.  Note that the headers need to be
+          # moved around a little to conform to the output format.
+          if header_row
+            file.puts format_row(["", "", ""] + table.headers[2..-1])
+          end
+          
+          sequence_locations = {}
+          table.data.each do |line|
+            seq, locator, *identifiers = line
+
+            # checks
+            unless locator =~ /^\d\.(\d+)\.\d$/ && seq.length == $1.length
+              raise "could not split line correctly: #{line}"
+            end
+            
+            locator = $1
+            locations = sequence_locations[seq] ||= []
+            split_locations = [] 
+            0.upto(locator.length-1) do |index|
+              if mod_numbers.include?(locator[index, 1].to_i)
+                unless locations.include?(index)
+                  split_locations << index
+                  locations << index
+                end
+              end
+            end
+            
+            split_locations.each_with_index do |location, index|
+              data = [
+                seq[0...location],
+                seq[location, 1],
+                seq[location+1..-1],
+              ] 
+              data += identifiers if index == 0
+              
+              # modify the lead identifier to note duplicates
+              data[3] = "#{identifiers[0]} (#{index + 1})" if split_locations.length > 1
+              data.collect! {|str| str.empty? ? output_empty_cell : str }
+              
+              file.puts format_row(data)
+            end
+            
+          end
+        end
+        
+        target
+      end
+    end
+  end
+end

data/lib/hansen_lab/tasks/flag_row.rb

@@ -0,0 +1,69 @@
+require 'tap/tasks/table_task'
+ 
+module HansenLab
+  module Tasks
+  
+    # :startdoc::manifest flag rows in a table
+    # Flags rows in a table that have a column matching a specified 
+    # regexp pattern.  You can specify the column to check by name 
+    # (in which case the first row is assumed to be headers) or by 
+    # number (starting with column 0).  Patterns are matched without
+    # regard to case.
+    #
+    # Examples:
+    #   # match the 'accession' column with entries like 'mouse'
+    #   % tap run -- flag_row FILE --column accession --pattern mouse
+    #
+    #   # match the first (ie index == 0) column with entries
+    #   # like 'a mouse' or 'a human'
+    #   % tap run -- flag_row FILE --column 0 --pattern "a mouse|a human"
+    #
+    class FlagRow < Tap::Tasks::TableTask
+    
+      config :check_column, 0, &c.yaml(String, Integer)    # the column to check
+      config :pattern, /./, &c.regexp                      # the matching pattern
+      config :flag, 1                                      # the flag value
+      config :no_flag, 0                                   # the not-flagged value
+      
+      def flag_rows(table)
+        column_index = case check_column
+        when String then table.headers.index(check_column)
+        when Integer then check_column
+        else nil
+        end
+
+        if column_index == nil  || table.n_columns <= column_index
+          raise "could not identify column: #{check_column}"
+        end
+        
+        # iterate over the rows and add a flag signaling
+        # a match to the pattern
+        table.data.collect! do |row|
+          row << (row[column_index] =~ pattern ? flag : no_flag)
+        end
+        
+        table
+      end
+      
+      # process defines what the task does; use the
+      # same number of inputs to enque the task
+      # as specified here
+      def process(target, source)
+        
+        log_basename :process, source
+        
+        # load the data and split into rows
+        table = parse_table(File.read(source))
+        flag_rows(table)
+
+        # prepare the target file and dump the results
+        prepare(target) 
+        File.open(target, "wb") do |file|
+          file << table.join(row_sep, col_sep, header_row)
+        end
+        
+        target
+      end
+    end
+  end
+end

data/tap.yml

@@ -0,0 +1 @@
+gems: [data_explorer, xcalibur]

data/test/tap_test_suite.rb

@@ -0,0 +1,5 @@
+$:.unshift File.join(File.dirname(__FILE__), '../lib')
+
+# runs all subsets (see Tap::Test::SubsetMethods)
+ENV["ALL"] = true 
+Dir.glob("./**/*_test.rb").each {|test| require test}

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+name: bahuvrihi-hansen_lab
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Simon Chiang
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-07-08 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: tap
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.10.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: sample_tasks
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.10.0
+    version: 
+description: 
+email: simon.a.chiang@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- MIT-LICENSE
+files: 
+- lib/hansen_lab/tasks/align_columns.rb
+- lib/hansen_lab/tasks/align_mod.rb
+- lib/hansen_lab/tasks/flag_row.rb
+- tap.yml
+- README
+- MIT-LICENSE
+has_rdoc: true
+homepage: http://github.com/bahuvrihi/hansen_lab/wikis
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Code developed for use in the Hansen Lab
+test_files: 
+- test/tap_test_suite.rb