ngs_server 0.1

data/ext/bamtools/src/utils/bamtools_utilities.cpp

@@ -0,0 +1,333 @@
+// ***************************************************************************
+// bamtools_utilities.cpp (c) 2010 Derek Barnett, Erik Garrison
+// Marth Lab, Department of Biology, Boston College
+// ---------------------------------------------------------------------------
+// Last modified: 9 June 2011
+// ---------------------------------------------------------------------------
+// Provides general utilities used by BamTools sub-tools.
+// ***************************************************************************
+
+#include <api/BamMultiReader.h>
+#include <api/BamReader.h>
+#include <utils/bamtools_utilities.h>
+using namespace BamTools;
+
+#include <algorithm>
+#include <cstdlib>
+#include <cstring>
+#include <fstream>
+#include <iostream>
+#include <sstream>
+using namespace std;
+
+namespace BamTools {
+  
+const char REVCOMP_LOOKUP[] = {'T',  0,  'G', 'H',
+                                0,   0,  'C', 'D',
+                                0,   0,   0,   0,
+                               'K', 'N',  0,   0,
+                                0,  'Y', 'W', 'A',
+                               'A', 'B', 'S', 'X',
+                               'R',  0 };
+  
+} // namespace BamTools 
+  
+// returns true if 'source' contains 'pattern'
+bool Utilities::Contains(const string& source, const string& pattern) {
+    return ( source.find(pattern) != string::npos );
+}
+
+// returns true if 'source' contains 'c'
+bool Utilities::Contains(const std::string &source, const char c) {
+    return ( source.find(c) != string::npos );
+}
+
+// returns true if 'source' ends with 'pattern'
+bool Utilities::EndsWith(const string& source, const string& pattern) {
+    return ( source.find(pattern) == (source.length() - pattern.length()) );
+}
+
+// returns true if 'source' ends with 'c'
+bool Utilities::EndsWith(const std::string& source, const char c) {
+    return ( source.find(c) == (source.length() - 1) );
+}
+
+// check if a file exists
+bool Utilities::FileExists(const string& filename) {
+    ifstream f(filename.c_str(), ifstream::in);
+    return !f.fail();
+}
+
+// Parses a region string, does validation (valid ID's, positions), stores in Region struct
+// Returns success (true/false)
+bool Utilities::ParseRegionString(const string& regionString,
+                                  const BamReader& reader,
+                                  BamRegion& region)
+{
+    // -------------------------------
+    // parse region string
+  
+    // check first for empty string
+    if ( regionString.empty() ) 
+        return false;   
+    
+    // non-empty string, look for a colom
+    size_t foundFirstColon = regionString.find(':');
+    
+    // store chrom strings, and numeric positions
+    string startChrom;
+    string stopChrom;
+    int startPos;
+    int stopPos;
+    
+    // no colon found
+    // going to use entire contents of requested chromosome 
+    // just store entire region string as startChrom name
+    // use BamReader methods to check if its valid for current BAM file
+    if ( foundFirstColon == string::npos ) {
+        startChrom = regionString;
+        startPos   = 0;
+        stopChrom  = regionString;
+        stopPos    = -1;
+    }
+    
+    // colon found, so we at least have some sort of startPos requested
+    else {
+      
+        // store start chrom from beginning to first colon
+        startChrom = regionString.substr(0,foundFirstColon);
+        
+        // look for ".." after the colon
+        size_t foundRangeDots = regionString.find("..", foundFirstColon+1);
+        
+        // no dots found
+        // so we have a startPos but no range
+        // store contents before colon as startChrom, after as startPos
+        if ( foundRangeDots == string::npos ) {
+            startPos   = atoi( regionString.substr(foundFirstColon+1).c_str() ); 
+            stopChrom  = startChrom;
+            stopPos    = -1;
+        } 
+        
+        // ".." found, so we have some sort of range selected
+        else {
+          
+            // store startPos between first colon and range dots ".."
+            startPos = atoi( regionString.substr(foundFirstColon+1, foundRangeDots-foundFirstColon-1).c_str() );
+          
+            // look for second colon
+            size_t foundSecondColon = regionString.find(':', foundRangeDots+1);
+            
+            // no second colon found
+            // so we have a "standard" chrom:start..stop input format (on single chrom)
+            if ( foundSecondColon == string::npos ) {
+                stopChrom  = startChrom;
+                stopPos    = atoi( regionString.substr(foundRangeDots+2).c_str() );
+            }
+            
+            // second colon found
+            // so we have a range requested across 2 chrom's
+            else {
+                stopChrom  = regionString.substr(foundRangeDots+2, foundSecondColon-(foundRangeDots+2));
+                stopPos    = atoi( regionString.substr(foundSecondColon+1).c_str() );
+            }
+        }
+    }
+
+    // -------------------------------
+    // validate reference IDs & genomic positions
+    
+    const RefVector references = reader.GetReferenceData();
+    
+    // if startRefID not found, return false
+    int startRefID = reader.GetReferenceID(startChrom);
+    if ( startRefID == (int)references.size() ) return false;  
+    
+    // if startPos is larger than reference, return false
+    const RefData& startReference = references.at(startRefID);
+    if ( startPos > startReference.RefLength ) return false;
+    
+    // if stopRefID not found, return false
+    int stopRefID = reader.GetReferenceID(stopChrom);
+    if ( stopRefID == (int)references.size() ) return false;
+    
+    // if stopPosition larger than reference, return false
+    const RefData& stopReference = references.at(stopRefID);
+    if ( stopPos > stopReference.RefLength ) return false;
+    
+    // if no stopPosition specified, set to reference end
+    if ( stopPos == -1 ) stopPos = stopReference.RefLength;  
+    
+    // -------------------------------
+    // set up Region struct & return
+    
+    region.LeftRefID = startRefID;
+    region.LeftPosition = startPos;
+    region.RightRefID = stopRefID;;
+    region.RightPosition = stopPos;
+    return true;
+}
+
+// Same as ParseRegionString() above, but accepts a BamMultiReader
+bool Utilities::ParseRegionString(const string& regionString,
+                                  const BamMultiReader& reader,
+                                  BamRegion& region)
+{
+    // -------------------------------
+    // parse region string
+  
+    // check first for empty string
+    if ( regionString.empty() ) 
+        return false;   
+    
+    // non-empty string, look for a colom
+    size_t foundFirstColon = regionString.find(':');
+    
+    // store chrom strings, and numeric positions
+    string startChrom;
+    string stopChrom;
+    int startPos;
+    int stopPos;
+    
+    // no colon found
+    // going to use entire contents of requested chromosome 
+    // just store entire region string as startChrom name
+    // use BamReader methods to check if its valid for current BAM file
+    if ( foundFirstColon == string::npos ) {
+        startChrom = regionString;
+        startPos   = 0;
+        stopChrom  = regionString;
+        stopPos    = -1;
+    }
+    
+    // colon found, so we at least have some sort of startPos requested
+    else {
+      
+        // store start chrom from beginning to first colon
+        startChrom = regionString.substr(0,foundFirstColon);
+        
+        // look for ".." after the colon
+        size_t foundRangeDots = regionString.find("..", foundFirstColon+1);
+        
+        // no dots found
+        // so we have a startPos but no range
+        // store contents before colon as startChrom, after as startPos
+        if ( foundRangeDots == string::npos ) {
+            startPos   = atoi( regionString.substr(foundFirstColon+1).c_str() ); 
+            stopChrom  = startChrom;
+            stopPos    = -1;
+        } 
+        
+        // ".." found, so we have some sort of range selected
+        else {
+          
+            // store startPos between first colon and range dots ".."
+            startPos = atoi( regionString.substr(foundFirstColon+1, foundRangeDots-foundFirstColon-1).c_str() );
+          
+            // look for second colon
+            size_t foundSecondColon = regionString.find(':', foundRangeDots+1);
+            
+            // no second colon found
+            // so we have a "standard" chrom:start..stop input format (on single chrom)
+            if ( foundSecondColon == string::npos ) {
+                stopChrom  = startChrom;
+                stopPos    = atoi( regionString.substr(foundRangeDots+2).c_str() );
+            }
+            
+            // second colon found
+            // so we have a range requested across 2 chrom's
+            else {
+                stopChrom  = regionString.substr(foundRangeDots+2, foundSecondColon-(foundRangeDots+2));
+                stopPos    = atoi( regionString.substr(foundSecondColon+1).c_str() );
+            }
+        }
+    }
+
+    // -------------------------------
+    // validate reference IDs & genomic positions
+    
+    const RefVector references = reader.GetReferenceData();
+    
+    // if startRefID not found, return false
+    int startRefID = reader.GetReferenceID(startChrom);
+    if ( startRefID == (int)references.size() ) return false;  
+    
+    // if startPos is larger than reference, return false
+    const RefData& startReference = references.at(startRefID);
+    if ( startPos > startReference.RefLength ) return false;
+    
+    // if stopRefID not found, return false
+    int stopRefID = reader.GetReferenceID(stopChrom);
+    if ( stopRefID == (int)references.size() ) return false;
+    
+    // if stopPosition larger than reference, return false
+    const RefData& stopReference = references.at(stopRefID);
+    if ( stopPos > stopReference.RefLength ) return false;
+    
+    // if no stopPosition specified, set to reference end
+    if ( stopPos == -1 ) stopPos = stopReference.RefLength;  
+    
+    // -------------------------------
+    // set up Region struct & return
+    
+    region.LeftRefID = startRefID;
+    region.LeftPosition = startPos;
+    region.RightRefID = stopRefID;;
+    region.RightPosition = stopPos;
+    return true;
+}
+
+void Utilities::Reverse(string& sequence) {
+    reverse(sequence.begin(), sequence.end());
+}
+
+void Utilities::ReverseComplement(string& sequence) {
+    
+    // do complement, in-place
+    size_t seqLength = sequence.length();
+    for ( size_t i = 0; i < seqLength; ++i )
+        sequence.replace(i, 1, 1, REVCOMP_LOOKUP[(int)sequence.at(i) - 65]);
+    
+    // reverse it
+    Reverse(sequence);
+}
+
+vector<string> Utilities::Split(const string& source, const char delim) {
+
+    stringstream ss(source);
+    string field;
+    vector<string> fields;
+
+    while ( getline(ss, field, delim) )
+        fields.push_back(field);
+    return fields;
+}
+
+vector<string> Utilities::Split(const string& source, const string& delims) {
+
+    vector<string> fields;
+
+    char* tok;
+    char* cchars = new char[source.size()+1];
+    char* cstr = &cchars[0];
+    strcpy(cstr, source.c_str());
+    tok = strtok(cstr, delims.c_str());
+    while (tok != NULL) {
+        fields.push_back(tok);
+        tok = strtok(NULL, delims.c_str());
+    }
+
+    delete[] cchars;
+
+    return fields;
+}
+
+// returns true if 'source' starts with 'pattern'
+bool Utilities::StartsWith(const string& source, const string& pattern) {
+    return ( source.find(pattern) == 0 );
+}
+
+// returns true if 'source' starts with 'c'
+bool Utilities::StartsWith(const std::string &source, const char c) {
+    return ( source.find(c) == 0 );
+}

data/ext/bamtools/src/utils/bamtools_utilities.h

@@ -0,0 +1,67 @@
+// ***************************************************************************
+// bamtools_utilities.h (c) 2010 Derek Barnett, Erik Garrison
+// Marth Lab, Department of Biology, Boston College
+// ---------------------------------------------------------------------------
+// Last modified: 9 June 2011
+// ---------------------------------------------------------------------------
+// Provides general utilities used by BamTools sub-tools.
+// ***************************************************************************
+
+#ifndef BAMTOOLS_UTILITIES_H
+#define BAMTOOLS_UTILITIES_H
+
+#include <api/BamAux.h>
+#include <utils/utils_global.h>
+#include <cassert>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#define BAMTOOLS_ASSERT_UNREACHABLE assert( false )
+#define BAMTOOLS_ASSERT_MESSAGE( condition, message ) if (!( condition )) throw std::runtime_error( message );
+
+namespace BamTools {
+
+class BamReader;
+class BamMultiReader;
+
+class UTILS_EXPORT Utilities {
+  
+    public: 
+        // returns true if 'source' contains 'pattern' or 'c'
+        static bool Contains(const std::string& source, const std::string& pattern);
+        static bool Contains(const std::string& source, const char c);
+
+        // returns true if 'source' ends with 'pattern' or 'c'
+        static bool EndsWith(const std::string& source, const std::string& pattern);
+        static bool EndsWith(const std::string& source, const char c);
+
+        // check if a file exists
+        static bool FileExists(const std::string& fname);
+        
+        // Parses a region string, uses reader to do validation (valid ID's, positions), stores in Region struct
+        // Returns success (true/false)
+        static bool ParseRegionString(const std::string& regionString,
+                                      const BamReader& reader,
+                                      BamRegion& region);
+        // Same as above, but accepts a BamMultiReader
+        static bool ParseRegionString(const std::string& regionString,
+                                      const BamMultiReader& reader,
+                                      BamRegion& region);
+
+        // sequence utilities
+        static void Reverse(std::string& sequence);
+        static void ReverseComplement(std::string& sequence);
+
+        // split string on delimiter character (or string of allowed delimiters)
+        static std::vector<std::string> Split(const std::string& source, const char delim);
+        static std::vector<std::string> Split(const std::string& source, const std::string& delims);
+
+        // returns true if 'source' starts with 'pattern' or 'c'
+        static bool StartsWith(const std::string& source, const std::string& pattern);
+        static bool StartsWith(const std::string &source, const char c);
+};
+
+} // namespace BamTools
+  
+#endif // BAMTOOLS_UTILITIES_H

data/ext/bamtools/src/utils/bamtools_variant.h

@@ -0,0 +1,128 @@
+// ***************************************************************************
+// bamtools_variant.h (c) 2010 Derek Barnett, Erik Garrison
+// Marth Lab, Department of Biology, Boston College
+// ---------------------------------------------------------------------------
+// Last modified: 19 November 2010
+// ---------------------------------------------------------------------------
+// Provides a template-based variant type
+// ---------------------------------------------------------------------------
+// Modified from:
+// variant_t - An Improved Variant Type Based on Member Templates
+// (c) 2000 Fernando Cacciola
+// Dr. Dobb's (http://www.ddj.com/cpp/184401293)
+//
+// * Modified to be in BamTools namespace, otherwise code is same. (DB)
+// ***************************************************************************
+
+#ifndef BAMTOOLS_VARIANT_H
+#define BAMTOOLS_VARIANT_H
+
+#include <utils/utils_global.h>
+#include <stdexcept>
+#include <string>
+#include <typeinfo>
+
+namespace BamTools {
+
+class UTILS_EXPORT Variant {
+  
+    public:
+        Variant(void) : data(NULL) { }
+        
+        Variant(const Variant& other) { 
+            if ( other.data != NULL ) 
+                other.data->AddRef();
+            data = other.data;
+        }
+
+        ~Variant(void) { 
+            if ( data != NULL ) 
+                data->Release();
+        }
+
+        // NOTE: This code takes care of self-assignment.
+        // DO NOT CHANGE THE ORDER of the statements.
+        Variant& operator= (const Variant& rhs) {
+            if ( rhs.data != NULL ) 
+                rhs.data->AddRef();
+            if ( data != NULL ) 
+                data->Release();
+            data = rhs.data;
+            return *this;
+        }
+
+        // This member template constructor allows you to
+        // instance a variant_t object with a value of any type.
+        template<typename T>
+        Variant(T v) 
+            : data(new Impl<T>(v)) 
+        { 
+            data->AddRef(); 
+        }
+
+        // This generic conversion operator let you retrieve
+        // the value held. To avoid template specialization conflicts,
+        // it returns an instance of type T, which will be a COPY
+        // of the value contained.
+        template<typename T> 
+        operator T() const { 
+            return CastFromBase<T>(data)->data;
+        }
+
+        // This forms returns a REFERENCE and not a COPY, which
+        // will be significant in some cases.
+        template<typename T> 
+        const T& get(void) const { 
+            return CastFromBase<T>(data)->data; 
+        }
+
+        template<typename T> 
+        bool is_type(void) const { 
+            return typeid(*data)==typeid(Impl<T>); 
+        }
+
+        template<typename T> 
+        bool is_type(T v) const { 
+            return typeid(*data)==typeid(v); 
+        }
+
+    private:
+        struct ImplBase {
+                
+            ImplBase() : refs(0) { }
+            virtual ~ImplBase(void) { }
+                
+            void AddRef(void) { ++refs; }
+            void Release(void) { 
+                --refs;
+                if ( refs == 0 ) delete this;
+            }
+                
+            size_t refs;
+        };
+
+        template<typename T>
+        struct Impl : ImplBase {
+            Impl(T v) : data(v) { }
+            ~Impl(void) { }
+            T data;
+        };
+
+        // The following method is static because it doesn't
+        // operate on variant_t instances.
+        template<typename T> 
+        static Impl<T>* CastFromBase(ImplBase* v) {
+            // This upcast will fail if T is other than the T used
+            // with the constructor of variant_t.
+            Impl<T>* p = dynamic_cast< Impl<T>* > (v);
+            if ( p == NULL ) 
+                throw std::invalid_argument( typeid(T).name() + std::string(" is not a valid type") );
+            return p;
+        }
+
+        ImplBase* data;
+};
+
+} // namespace BamTools
+
+#endif // BAMTOOLS_VARIANT_H

data/ext/bamtools/src/utils/cmake_install.cmake

@@ -0,0 +1,29 @@
+# Install script for directory: /Users/chase/Desktop/tmp_workspace/ngs_server/ext/bamtools/src/utils
+
+# Set the install prefix
+IF(NOT DEFINED CMAKE_INSTALL_PREFIX)
+  SET(CMAKE_INSTALL_PREFIX "/usr/local")
+ENDIF(NOT DEFINED CMAKE_INSTALL_PREFIX)
+STRING(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
+
+# Set the install configuration name.
+IF(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME)
+  IF(BUILD_TYPE)
+    STRING(REGEX REPLACE "^[^A-Za-z0-9_]+" ""
+           CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}")
+  ELSE(BUILD_TYPE)
+    SET(CMAKE_INSTALL_CONFIG_NAME "Release")
+  ENDIF(BUILD_TYPE)
+  MESSAGE(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"")
+ENDIF(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME)
+
+# Set the component getting installed.
+IF(NOT CMAKE_INSTALL_COMPONENT)
+  IF(COMPONENT)
+    MESSAGE(STATUS "Install component: \"${COMPONENT}\"")
+    SET(CMAKE_INSTALL_COMPONENT "${COMPONENT}")
+  ELSE(COMPONENT)
+    SET(CMAKE_INSTALL_COMPONENT)
+  ENDIF(COMPONENT)
+ENDIF(NOT CMAKE_INSTALL_COMPONENT)
+

data/ext/bamtools/src/utils/utils_global.h

@@ -0,0 +1,21 @@
+// ***************************************************************************
+// utils_global.h (c) 2010 Derek Barnett
+// Marth Lab, Department of Biology, Boston College
+// ---------------------------------------------------------------------------
+// Last modified: 19 November 2010 (DB)
+// ---------------------------------------------------------------------------
+// Provides macros for exporting & importing BamTools-utils library symbols
+// ***************************************************************************
+
+#ifndef UTILS_GLOBAL_H
+#define UTILS_GLOBAL_H
+
+#include "shared/bamtools_global.h"
+
+#ifdef BAMTOOLS_UTILS_LIBRARY
+#  define UTILS_EXPORT BAMTOOLS_LIBRARY_EXPORT
+#else
+#  define UTILS_EXPORT BAMTOOLS_LIBRARY_IMPORT
+#endif
+
+#endif // UTILS_GLOBAL_H

data/lib/ngs_server/version.rb

@@ -0,0 +1,3 @@
+module NgsServer
+  VERSION = "0.1"
+end

data/lib/ngs_server.rb

@@ -0,0 +1,3 @@
+module NgsServer
+  # Your code goes here...
+end

data/ngs_server.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "ngs_server/version"
+
+Gem::Specification.new do |s|
+  s.name        = "ngs_server"
+  s.version     = NgsServer::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Chase Miller"]
+  s.email       = ["chmille4@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{"Ultra Lightweight NGS Data Server"}
+  s.description = %q{"Converts BAM/VCF files into JSON for consumption by web apps"}
+
+  s.rubyforge_project = "ngs_server"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+#  s.executables   = "bin/ngs_"
+  s.extensions    = ["ext/bamtools/extconf.rb"]
+  s.require_paths = ["lib"]
+end