bio-ngs 0.4.6.alpha.01 → 0.4.6.alpha.02

data/lib/bio/ngs/illumina/fastq.rb

@@ -0,0 +1,176 @@
+module Bio
+  module Ngs
+    module Illumina
+      # module Fastx
+      #   include Fs::Utility
+      # end #Fastx
+
+
+      def filter(file)
+        if File.exists? file
+          filtered_file_basename = File.basename(file)
+          filtered_dir =  File.join(File.dirname,"filtered")
+          Dir.mkdir(filtered_dir) unless Dir.exists?(filtered_dir)
+          FastqGz.gets_compressed(filtered_file_basename) do |compress|
+            FastqGz.gets_filtered(ftest) do |read_header, reader_seq, read_splitter, read_qual|
+             compress.write(read_header + reader_seq + read_splitter + read_qual)
+            end
+          end
+       else
+        raise "Bio::Ngs::Illumina.filter : unkown file #{file}"
+       end 
+      end
+
+      module FastqGz
+        require 'zlib'
+        class << self
+
+        # Return the number of reads processed
+        def gets_uncompressed(file, &block)
+          n_reads = 0
+          Zlib::GzipReader.open(file) do |gz|
+            while  header=gz.gets
+              #seq, splitter, qual = gz.gets, gz.gets, gz.gets
+              n_reads+=1
+              #yield header, seq, splitter, qual
+              yield header, gz.gets, gz.gets, gz.gets
+            end #while
+            gz.close
+          end #GzipReader
+          n_reads
+        end #gets_uncompressed
+
+        
+        def gets_compressed(file, &block)
+          Zlib::GzipWriter.open(file) do |gz|
+           yield gz
+           gz.close
+         end
+       end
+
+        # Return the number of reads processed
+        def gets_filtered(file, &block)
+          n_reads = 0
+          gets_uncompressed(file) do |header, seq, splitter, qual|
+           if header=~/^@.* [^:]*:N:[^:]*:/ 
+            n_reads+=1
+                #pass to the block header, fasta, quality splitter, quality
+                yield header, seq, splitter, qual
+              end
+          end #GzipReader
+          n_reads
+        end #gets_filtered
+      end #FastqGz
+
+  # desc "illumina_filter [DIR(s)]", "Filter the data using Y/N flag in FastQ headers (Illumina). Search for fastq.gz files within directory(ies) passed."
+  # method_option :compression, :type => :string, :default => "pigz"
+  # method_option :cpu, :type => :numeric, :default => 4
+  # def illumina_filter(dir)
+  #   folders = Dir.glob(dir)
+  #   cmd_blocks = []
+  #   folders.each do |folder|
+  #     Parallel.each(Dir.glob(folder+"/*.fastq.gz").sort,:in_processes => options[:cpu].to_i) do |fastq|
+  #       Dir.mkdir(folder+"/filtered") unless Dir.exists? folder+"/filtered"
+  #       fastq = fastq.split("/")[-1]
+  #       system("zcat #{folder+"/"+fastq} | grep -A 3 '^@.* [^:]*:N:[^:]*:' | grep -v '^\-\-'| #{options[:compression]} > #{folder}/filtered/#{fastq}")
+  #     end
+  #   end
+  # end
+  
+  
+  # desc "merge [file(s)]","Merge together fastQ files (accepts wildcards)"
+  # method_option :compressed, :type => :boolean, :default => true
+  # def merge(file)
+  #   files = Dir.glob(file).sort
+  #   cat = (options[:compressed]) ? "zcat" : "cat"
+  #   files.each do |file|
+  #     system("#{cat} #{file} >> merged_reads.fastq")
+  #   end
+  # end
+  
+  # desc "paired_merge [file(s)]","Merge together FastQ files while checking for correct pairing (accepts wildcards)"
+  # method_option :compressed, :type => :boolean, :default => false
+  # def paired_merge(file)
+  #   files = Dir.glob(file).sort.find_all {|f| f=~/_R1_/}
+  #   cat = (options[:compressed] == true) ? "zcat" : "cat"
+  #   files.each do |r1|
+  #     r2 = r1.gsub(/_R1_/,"_R2_")
+  #     if File.exists? r2
+  #       r1_count = count_reads(r1,compressed:options[:compressed])
+  #       r2_count = count_reads(r2,compressed:options[:compressed])
+  #       puts "Read count: #{r1_count} : #{r2_count} , #{file}"
+  #         if r1_count == r2_count
+  #           Parallel.each(["R1","R2"],:in_processes => options[:cpu].to_i) do |read|
+  #             filename = (read == "R1") ? r1 : r2
+  #             system "#{cat} #{filename} >> #{read}_reads.fastq"
+  #           end
+  #         else
+  #           raise RuntimeError "Error: files #{r1} and #{r2} do not have the same number of reads!"
+  #         end
+  #     else
+  #       puts "WARN: file #{r2} does not exist! Reads from #{r1} will be considered as singlets"
+  #       system("#{cat} #{r1} >> singlets_reads.fastq")
+  #     end  
+  #   end
+  # end
+  
+  # desc "uncompress [file(s)]","Uncompress multiple files in parallel (accepts wildcards)"
+  # method_option :cpu, :type => :numeric, :default => 4
+  # def uncompress(file)
+  #   files = Dir.glob(file).sort
+  #   blocks = []
+  #   Parallel.each(files,:in_processes => options[:cpu].to_i) do |file|
+  #     system("gunzip #{file}")
+  #   end
+  # end
+  
+  
+  # desc "trim [fastq(s)]","Calulate quality profile and trim the all the reads using FastX (accepts wildcards)"
+  # method_option :cpu, :type => :numeric, :default => 4
+  # method_option :min_qual, :type => :numeric, :default => 20
+  # def trim(file)
+  #   list = Dir.glob(file).sort
+  #   groups = list / options[:cpu].to_i # get group of files equal to number of CPUs
+  #   cmd_blocks = []
+  #   groups.each do |files|
+  #     Parallel.each(files, :in_processes => options[:cpu].to_i) do |file|
+  #       invoke "quality:fastq_stats", [file], {output:file+".stats"}
+  #       trim_position = options[:read_length]
+  #       lines = File.read(file+".stats").split("\n")
+  #       if lines.size == 0
+    #       raise RuntimeError, "Error in Quality Stats file! Check fastx_quality_stat output"
+   #      end
+   #      read_length = (lines.size) -1
+  #       lines[1..-1].each_with_index do |line,index|
+  #         if line.split("\t")[7].to_i <= options[:min_qual]
+  #           trim_position = index +1
+  #           break
+  #         end 
+  #       end
+  #       if trim_position == options[:read_length]
+  #         puts "WARN: no bases under quality cutoff. No trimming needed on #{file}"
+  #         FileUtils.cp file, file+".ready"
+  #       elsif trim_position < 25 
+  #           puts "WARN: Trimming on #{file} will produce reads that are too short. The file will be discarded, please check quality scores."
+  #       else
+  #         puts "Trimming on position #{trim_position} for #{file}"
+  #         trim = Bio::Ngs::Fastx::Trim.new
+  #         trim.params={trim:read_length-trim_position+1, input:file, output:file+".ready"}
+  #         trim.run
+  #       end
+  #     end
+  #   end
+  # end
+  
+  # private
+  
+  # def count_reads(file,opts = {compressed:false})
+  #   cat = (opts[:compressed] == true) ? "zcat" : "cat"
+  #   total = `#{cat} #{file} | wc -l`.to_i / 4
+  # end
+  
+
+      end #FastqGz
+    end #Illumina
+  end #Ngs
+end #Bio

data/lib/bio/ngs/illumina/illumina.rb

@@ -0,0 +1,64 @@
+#TODO: refactor this code, I don't like it very much
+#TODO: export in JSON format
+require 'bio/ngs/illumina/project'
+require 'bio/ngs/illumina/sample'
+require 'bio/ngs/illumina/fastq'
+
+module Bio
+  module Ngs
+    module Illumina
+
+      class Projects < Meta::Pool
+        def initialize(name, path)
+          super(name)
+          metadata[:path]=path
+        end
+        alias :projects :pool
+      end
+
+      require 'find'
+      class << self
+        def project_directory?(path=".")
+          Dir.chdir(path) do
+            projects = Dir.glob(["Project_*","Undetermined_indices"])
+            return false if projects.empty?
+            into_projects = projects.map do |project|
+              Dir.chdir(project) do |sample|
+                Dir.glob("Sample*").size>0
+              end
+            end.uniq
+
+            if (into_projects.size>1 || (into_projects.first==false))
+              return false
+            end
+          end
+          true
+        end
+
+        def build(path=".")
+
+          projects = Projects.new("Illumina", path)
+
+          Dir.chdir(path) do
+            Dir.glob(["Project_*","Undetermined_indices"]).each do |project_dir|
+              project = Project.new(project_dir.sub(/Project_/,""),project_dir)
+              projects.add(project)
+              Dir.chdir(project_dir) do
+                Dir.glob("Sample*").each do |sample_dir|
+                  sample = Sample.new(sample_dir.sub(/Sample_/,""), sample_dir, project)
+                  project.add(sample)
+                  Dir.chdir(sample_dir) do
+                    Dir.glob(["**/*.fastq", "**/*.fastq.gz"]) do |reads_filename|
+                      sample.add_filename(reads_filename)
+                    end
+                  end
+                end
+              end
+            end
+          end
+          projects
+        end
+      end
+    end #Illumina
+  end #Ngs
+end #Bio

data/lib/bio/ngs/illumina/project.rb

@@ -0,0 +1,81 @@
+#TODO: refactor this code, I don't like it very much
+#TODO: export in JSON format
+require 'meta'
+
+module Bio
+  module Ngs
+    require 'json'
+    module Illumina
+      class Project < Meta::Pool
+        attr_accessor :samples, :sample_sheet, :root_dir
+        def initialize(name, root_dir=".")
+          super(name)
+          @sample_sheet = nil
+          @root_dir = root_dir
+          metadata[:path]=root_dir
+        end
+
+        alias :samples :pool
+
+        def path
+          File.join(@root_dir, (name=~/Undetermined_indices/ ? name : "Project_#{name}"))
+        end
+
+        def samples_path
+          @samples.each_key.map do |sample_name|
+            @samples[sample_name].filenames_paths
+          end.flatten
+        end
+        def to_json(*a)
+          {
+            "json_class"    => self.class.name,
+            "name"          => name,
+            "sample_sheet"  => sample_sheet,
+            "samples"       => samples.each_key.map{|k| samples[k].to_json }
+          }.to_json(*a)
+        end
+      end
+
+      # require 'find'
+      # class << self
+        # def project_directory?(path=".")
+        #   Dir.chdir(path) do
+        #     projects = Dir.glob(["Project_*","Undetermined_indices"])
+        #     return false if projects.empty?
+        #     into_projects = projects.map do |project|
+        #       Dir.chdir(project) do |sample|
+        #         Dir.glob("Sample*").size>0
+        #       end
+        #     end.uniq
+
+        #     if (into_projects.size>1 || (into_projects.first==false))
+        #       return false
+        #     end
+        #   end
+        #   true
+        # end
+
+        # def build(path=".")
+        #   Dir.chdir(path) do
+        #     Dir.glob(["Project_*","Undetermined_indices"]).inject({}) do |projects, project_dir|
+        #       project = Project.new(project_dir.sub(/Project_/,""), path)
+        #       projects[project.name] = project
+        #       Dir.chdir(project_dir) do
+        #         Dir.glob("Sample*").each do |sample_dir|
+        #           sample = Sample.new(sample_dir.sub(/Sample_/,""), project)
+        #           project.samples[sample.name] = sample
+        #           Dir.chdir(sample_dir) do
+        #             Dir.glob(["**/*.fastq", "**/*.fastq.gz"]) do |reads_filename|
+        #               sample.add_filename(reads_filename)
+        #             end
+        #           end
+        #         end
+        #       end
+        #       projects
+        #     end
+        #   end
+        # end
+      # end
+    end #Illumina
+  end #Ngs
+end #Bio

data/lib/bio/ngs/illumina/sample.rb

@@ -0,0 +1,85 @@
+#TODO: refactor this code, I don't like it very much
+#TODO: export in JSON format
+require 'meta'
+require 'securerandom'
+
+module Bio
+  module Ngs
+    module Illumina
+      class MetaReads < Meta::Data
+        def initialize(name, metadata={})
+          super(name, metadata)
+          metadata[:type]=:file
+          metadata[:format]=:fastq
+        end
+      end #File
+
+      class Sample < Meta::Pool
+        #attr_accessor :name #, :filenames
+        def initialize(name, path, parent=nil)
+          super(name)
+          metadata[:path]=path
+          @parent = parent
+        end
+
+        def path
+          File.join @parent.path,"Sample_#{name}"
+        end
+
+        def paired?
+          @filenames.key?(:left) && @filenames.key?(:right)
+        end
+
+        def add_filename(filename)
+          filename_metadata = filename.dup
+          metadata = {:filename=>filename_metadata}
+          #TODO maybe could be usefult to leave this to end used, define what is a filtered/trimmed file. Define a regexp for each category.
+          if filename=~/trimmed|TRIMMED/
+            metadata[:trimmed] = true
+            metadata[:trimmed_aggregated] = true unless filename=~/_\d+\./
+          end
+
+          if filename=~/filtered|FILTERED/
+            metadata[:filtered] = true
+            metadata[:filtered_aggregated] =true unless filename=~/_\d+\./
+          end
+          metadata[:left] = true if filename=~/.*_R1_.*/
+          metadata[:right] = true if filename=~/.*_R2_.*/
+          metadata[:zipped] = true if filename=~/\.gz/
+          metadata[:aggregated] = true unless metadata[:trimmed_aggregated] || metadata[:filtered_aggregated] || filename=~/_\d+\./
+
+          filename.sub!(/_([ACGT]+)_/,'_')
+          metadata[:index] = $1
+          filename.sub!(/_L([0-9]+)_?/,'_')
+          metadata[:lane] = $1
+
+          #filename_cleaned = filename.sub(/_R.*/,'')
+          readsdata_name = File.basename(filename).sub(/TRIMMED/,'').sub(/trimmed/,'').sub(/filtered/,'').sub(/FILTERED/,'').sub(/_R\d+_\d+_?/,'').sub(/_R\d+_/,'').sub(/\..+$/,'') #TODO is not the best thing to do
+
+            if filename=~/R._(\d*).fastq(.gz)?/
+              metadata[:chunks]=$1
+            end
+            self.add MetaReads.new(SecureRandom.uuid, metadata)
+          end
+
+#REMOVE          # def get(tag=filtered)
+          #   @files.get(tag)
+          # end
+
+          def filenames_paths
+            @filenames.keys.map do |filename|
+              filename_path(filename)
+            end.flatten
+          end
+
+          # def to_json(*a)
+          #   {
+          #     "json_class"   => self.class.name,
+          #     "name"         => name,
+          #     "filenames"    => filenames_paths
+          #   }.to_json(*a)
+          # end
+        end #Sample
+      end #Illumina
+    end #Ngs
+  end #Bio

data/lib/bio/ngs/task.rb

@@ -15,7 +15,7 @@ class Thor
 
     def run(instance, args=[])
       public_method?(instance) ? instance.send(name, *args) : instance.class.handle_no_task_error(name)
-      save_history(instance,args) unless instance.class == Bio::Ngs::Runner or instance.class == Thor::Sandbox::History
+     # save_history(instance,args) unless instance.class == Bio::Ngs::Runner or instance.class == Thor::Sandbox::History
     rescue ArgumentError => e
       handle_argument_error?(instance, e, caller) ?
       instance.class.handle_argument_error(self, e) : (raise e)

data/lib/bio/ngs/utils.rb

@@ -1,5 +1,5 @@
 #
-#  
+#
 #
 # Copyright:: Copyright (C) 2011
 #     Francesco Strozzi <francesco.strozzi@gmail.com>
@@ -12,6 +12,8 @@ require 'find'
 module Bio
   module Ngs
     class Utils
+      @@skip_check_binaries=false
+
       class BinaryNotFound < StandardError
         def initialize(opts={})
           @skip_task = opts[:skip_task]
@@ -22,26 +24,35 @@ module Bio
         end
       end
       class << self
-        
+
+        def skip_check_binaries
+          @@skip_check_binaries=true
+        end
+
+        def skip_check_binaries?
+          @@skip_check_binaries
+        end
+
         def binary(name)
-          begin
-            if !(plugin_binaries_found = find_binary_files(name)).empty?
-              return plugin_binaries_found.first
-            elsif (os_binary = Bio::Command.query_command ["which", name]) != ""
-              return os_binary.tr("\n","")
-            else
-              raise BinaryNotFound.new(:skip_task=>true), "No binary found with this name: #{name}"
+          unless skip_check_binaries?
+            begin
+              if !(plugin_binaries_found = find_binary_files(name)).empty?
+                return plugin_binaries_found.first
+              elsif (os_binary = Bio::Command.query_command ["which", name]) != ""
+                return os_binary.tr("\n","")
+              else
+                raise BinaryNotFound.new(:skip_task=>true), "No binary found with this name: #{name}"
+              end
+            rescue BinaryNotFound => e
+              warn e.message
             end
-          rescue BinaryNotFound => e
-            warn e.message
           end
-
         end #binary
 
         def os_type
           require 'rbconfig'
           case RbConfig::CONFIG['host_os']
-          when /darwin/ then return "osx" 
+          when /darwin/ then return "osx"
           when /linux/ then return "linux"
           when /mswin|mingw/ then raise NotImplementedError, "This plugin does not run on Windows"
           end
@@ -76,114 +87,115 @@ module Bio
           mode = (opts[:mode]) ? opts[:mode] : ""
           pbar = nil
           open(opts[:url],"r"+mode,
-          :content_length_proc => lambda {|t|
-            if t && 0 < t
-              pbar = ProgressBar.new('', t)
-              pbar.file_transfer_mode
-            end
+            :content_length_proc => lambda {|t|
+              if t && 0 < t
+                pbar = ProgressBar.new('', t)
+                pbar.file_transfer_mode
+              end
             },
             :progress_proc => lambda {|s|
               pbar.set s if pbar
-              }) do |remote|
-                open(filename,"w"+mode) {|file| file.write remote.read(16384) until remote.eof?}
+            }) do |remote|
+              open(filename,"w"+mode) {|file| file.write remote.read(16384) until remote.eof?}
+            end
+            puts "\nDone"
+          end
+
+          def uncompress_gz_file(file_in)
+            require 'zlib'
+            puts "Uncompressing file #{file_in}"
+            file_out = file_in.gsub(/.gz/,"")
+            Zlib::GzipReader.open(file_in) {|gz|
+              open(file_out,"w") do |file|
+                file.write gz.read
               end
-              puts "\nDone"     
+            }
+            puts "Done\n"
+          end
+
+
+          def download_and_uncompress(url,fileout)
+            self.download_with_progress(:url => url,:mode => "b",:filename => fileout)
+            self.uncompress_gz_file(fileout)
+          end
+
+          def uncompress_command(suffix)
+            case suffix
+            when "tar.bz2" then "tar xvfj"
+            when "tar.gz" then "tar xvfz"
+            when "zip" then "unzip"
+            else
+              raise "Unkonw suffix."
             end
+          end #uncompress_command
 
-            def uncompress_gz_file(file_in)
-              require 'zlib'
-              puts "Uncompressing file #{file_in}"
-              file_out = file_in.gsub(/.gz/,"") 
-              Zlib::GzipReader.open(file_in) {|gz|
-                open(file_out,"w") do |file|
-                  file.write gz.read
-                end
-              }
-              puts "Done\n"          
+          def uncompress_any(tool_name, tool_record)
+            tool_file_name = "#{tool_record["basename"]}.#{tool_record["suffix"]}"
+            tool_dir_name = tool_record["basename"]
+            uncompress = uncompress_command(tool_record["suffix"])
+            STDERR.puts "#{uncompress} #{tool_file_name}"
+            system "#{uncompress} #{tool_file_name}"
+            STDERR.puts "completed."
+            if Dir.exists?(tool_dir_name)
+              tool_dir_name
+            elsif Dir.exists?("#{tool_name}-#{tool_record['version']}")
+              "#{tool_name}-#{tool_record['version']}"
+            else
+              raise "BioNGS can not identify the uncompressed destination folder"
             end
+          end  #uncompress
+
+          def compile_source(tool_name, tool_record, path_external, path_binary)
+            puts "Uncompressing #{tool_name}..."
+            tool_dir_name = uncompress_any(tool_name, tool_record)
+            puts "Compiling #{tool_name}..."
+            cd(tool_dir_name) do
+              #system "#{tool_record["lib"]}='#{path_external}/bin/common/lib'" if tool_record["lib"]
+              #system "#{tool_record["flags"]}='-O2'" if tool_record["flags"]
+              system "PKG_CONFIG_PATH='#{path_external}/bin/common/lib/pkgconfig' ./configure --prefix=#{path_binary} --bindir=#{path_binary}"
+              system "make"
+              system "make install"
+            end #cd
+          end #uncompress_compile
 
+          def just_make(tool_name, tool_record, path_external, path_binary)
+            puts "Uncompressing #{tool_name}..."
+            tool_dir_name = uncompress_any(tool_name, tool_record)
+            puts "Compiling #{tool_name}..."
+            cd(tool_dir_name) do
+              system "make"
+              FileUtils.cp tool_name,path_binary
+            end #cd
+          end
 
-            def download_and_uncompress(url,fileout)
-              self.download_with_progress(:url => url,:mode => "b",:filename => fileout)
-              self.uncompress_gz_file(fileout)
-            end       
+          def install_binary(tool_name, tool_record, path_external, path_binary)
+            require 'fileutils'
+            include FileUtils::Verbose
+            puts "Uncompressing #{tool_name}"
+            uncompressed_tool_dir_name = uncompress_any(tool_name, tool_record)
+            puts "Installing #{tool_name}"
+            path_binary_tool = File.join(path_binary,tool_name)
+            FileUtils.remove_dir(path_binary_tool) if Dir.exists?(path_binary_tool)
+            FileUtils.mkdir(path_binary_tool)
+            FileUtils.cp_r "#{uncompressed_tool_dir_name}/.", path_binary_tool, :preserve=>true
+          end #uncompress install binary
 
-            def uncompress_command(suffix)
-              case suffix
-              when "tar.bz2" then "tar xvfj"
-              when "tar.gz" then "tar xvfz"
-              when "zip" then "unzip"
-              else
-                raise "Unkonw suffix."
-              end
-            end #uncompress_command
-            
-            def uncompress_any(tool_name, tool_record)
-              tool_file_name = "#{tool_record["basename"]}.#{tool_record["suffix"]}"
-              tool_dir_name = tool_record["basename"]
-              uncompress = uncompress_command(tool_record["suffix"])
-              STDERR.puts "#{uncompress} #{tool_file_name}"
-              system "#{uncompress} #{tool_file_name}"
-              STDERR.puts "completed."
-              if Dir.exists?(tool_dir_name)
-                tool_dir_name
-              elsif Dir.exists?("#{tool_name}-#{tool_record['version']}")
-                "#{tool_name}-#{tool_record['version']}"
-              else
-                raise "BioNGS can not identify the uncompressed destination folder"
-              end
-            end  #uncompress
-            
-            def compile_source(tool_name, tool_record, path_external, path_binary)
-              puts "Uncompressing #{tool_name}..."
-              tool_dir_name = uncompress_any(tool_name, tool_record)
-              puts "Compiling #{tool_name}..."
-              cd(tool_dir_name) do
-                #system "#{tool_record["lib"]}='#{path_external}/bin/common/lib'" if tool_record["lib"]
-                #system "#{tool_record["flags"]}='-O2'" if tool_record["flags"]
-                system "PKG_CONFIG_PATH='#{path_external}/bin/common/lib/pkgconfig' ./configure --prefix=#{path_binary} --bindir=#{path_binary}"
-                system "make"
-                system "make install"
-              end #cd
-            end #uncompress_compile
-            
-            def just_make(tool_name, tool_record, path_external, path_binary)
-              puts "Uncompressing #{tool_name}..."
-              tool_dir_name = uncompress_any(tool_name, tool_record)
-              puts "Compiling #{tool_name}..."
-              cd(tool_dir_name) do
-                system "make"
-                FileUtils.cp tool_name,path_binary
-              end #cd
+
+          # search in the current gem's directory for installed binaries which the name binary_name
+          # it's a recursive search in common and os specific directories
+          # return an array: empty if the binary can not be found otherwise full path to the binaries
+          # it is up to the user choose which binary to use, it's suggested to use the first in the array
+          # to have a behavirou similar to the search PATH
+          def find_binary_files(binary_name)
+            path = File.expand_path(File.dirname(__FILE__))
+            Find.find(File.join(path,"ext","bin","common"),File.join(path,"ext","bin",self.os_type)).select do |f|
+              File.file?(f) && File.basename(f) == binary_name
             end
-            
-            def install_binary(tool_name, tool_record, path_external, path_binary)
-              require 'fileutils'
-              include FileUtils::Verbose
-              puts "Uncompressing #{tool_name}"
-              uncompressed_tool_dir_name = uncompress_any(tool_name, tool_record)
-              puts "Installing #{tool_name}"
-              path_binary_tool = File.join(path_binary,tool_name)
-              FileUtils.remove_dir(path_binary_tool) if Dir.exists?(path_binary_tool)
-              FileUtils.mkdir(path_binary_tool) 
-              FileUtils.cp_r "#{uncompressed_tool_dir_name}/.", path_binary_tool, :preserve=>true
-            end #uncompress install binary
-            
-
-            # search in the current gem's directory for installed binaries which the name binary_name
-            # it's a recursive search in common and os specific directories
-            # return an array: empty if the binary can not be found otherwise full path to the binaries
-            # it is up to the user choose which binary to use, it's suggested to use the first in the array
-            # to have a behavirou similar to the search PATH
-            def find_binary_files(binary_name)
-              path = File.expand_path(File.dirname(__FILE__))
-              Find.find(File.join(path,"ext","bin","common"),File.join(path,"ext","bin",self.os_type)).select do |f|
-                File.file?(f) && File.basename(f) == binary_name
-              end
-            end #find_binary_file
-              
-          end #eiginclass
+          end #find_binary_file
+        end #eiginclass
+
+      end # end Utils
+    end # end NGS
+  end # end Bio
 
-        end # end Utils
-      end # end NGS
-    end # end Bio
+  Bio::Ngs::Utils.skip_check_binaries if %w(true yes ok 1).include?(ENV['BIONGS_SKIP_CHECK_BINARIES'])