bio-fastqc 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eadb40fda6d28b9a545f14241ba2faec3b3a6125
-  data.tar.gz: 22920fae6a3f69315e7ef1d497816b00efb2518f
+  metadata.gz: 47531c30911b727ad8b3bdc50e26ca8a3a6467e1
+  data.tar.gz: 68bfdb57eac8779b634abcce1bed1cd40986a602
 SHA512:
-  metadata.gz: 37fb1d7b6e7124ff9c3678ca01402d9cb68422b5630bb55fd15df4e57c3697acac118e53e5d7b4a753487be693fcfd53c67e62f9d5442a2a0b350ddf1719a670
-  data.tar.gz: 71ecd9ac350ef2aecdd8048de2f76faeb5371b0c468f781eb71f934ae5a2cd1bbecb8a4a66db8a24c0d1a022bcc74aa06291c5795f651ba6b179b0dc6fda8d7c
+  metadata.gz: b5b9b66d01c11669db71c96eb3c7e87c74e7ab45b55605481b6d75b14f5c06b7bb2813dff5d20833068d17bf7246aef663356523b46278621b863675ebc9186e
+  data.tar.gz: e81822150a02e8e7634e0a5942fe0806297c5a86211dc2bb5609d2504b47d64e77c4e7122526069037e6af1166857ba1934444fb51aa4e241690f598e9afc051

data/.travis.yml

@@ -1,13 +1,6 @@
 language: ruby
 rvm:
-  - 1.9.2
-  - 1.9.3
-  - jruby-19mode # JRuby in 1.9 mode
-
-# - rbx-19mode
-#  - 1.8.7
-#  - jruby-18mode # JRuby in 1.8 mode
-#  - rbx-18mode
+  - 2.2.1
 
 # uncomment this line if your project needs to run something other than `rake`:
 # script: bundle exec rspec spec

data/Gemfile

@@ -9,7 +9,7 @@ gem 'thor', "~> 0.19.1"
 # Add dependencies to develop your gem here.
 # Include everything needed to run rake, tests, features, etc.
 group :development do
-  gem 'bundler', '~> 1.10'
+  gem 'bundler', '>= 1.8.0'
   gem 'rake', '~> 10.0'
   gem 'rspec', '~> 3.3'
   gem 'jeweler', '~> 2.0'

data/README.md

@@ -2,7 +2,11 @@
 
 [![Build Status](https://secure.travis-ci.org/inutano/bioruby-fastqc.png)](http://travis-ci.org/inutano/bioruby-fastqc)
 
-A ruby parser for [FastQC](http://www.bioinformatics.babraham.ac.uk/projects/fastqc/) data.
+A ruby parser for [FastQC](http://www.bioinformatics.babraham.ac.uk/projects/fastqc/) data. 
+
+## Reqruirements
+
+Ruby 2.0 or later
 
 ## Installation
 

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.2.1

data/lib/bio/fastqc/data.rb

@@ -4,33 +4,33 @@ require 'zip'
 
 module Bio
   module FastQC
-	  class Data
-			class << self
-				def read(file)
-					read_zipfile(file)
-				rescue Zip::Error
-					read_flatfile(file)
+    class Data
+  		class << self
+  			def read(file)
+  				read_zipfile(file)
+  			rescue Zip::Error
+  				read_flatfile(file)
         rescue Errno::EISDIR
           read_dir(file)
-				end
+  			end
 
-				def read_zipfile(file)
-					Zip::File.open(file) do |zipfile|
-						zipfile.glob('*/fastqc_data.txt').first.get_input_stream.read
-					end
-				end
+  			def read_zipfile(file)
+  				Zip::File.open(file) do |zipfile|
+  					zipfile.glob('*/fastqc_data.txt').first.get_input_stream.read
+  				end
+  			end
 
-				def read_flatfile(file)
-					open(file).read
-				end
+  			def read_flatfile(file)
+  				open(file).read
+  			end
 
-				def read_dir(file)
-					open(File.join(file, "fastqc_data.txt")).read
-				rescue Errno::ENOENT
-					puts "FastQC data file fastqc_data.txt not found"
-					exit
-				end
+  			def read_dir(file)
+  				open(File.join(file, "fastqc_data.txt")).read
+  			rescue Errno::ENOENT
+  				puts "FastQC data file fastqc_data.txt not found"
+  				exit
+  			end
   		end
-		end
-	end
+  	end
+  end
 end

data/lib/bio/fastqc/parser.rb

@@ -2,94 +2,98 @@
 
 module Bio
   module FastQC
-	  class Parser
-	    def initialize(fastqc_data_txt)
-	      @data = fastqc_data_txt
-	      @object = parse(@data)
-	      @base = self.basic_statistics
-	    end
-
-	    def parse(data)
-	      modules = data.split(">>END_MODULE\n")
-	      modules.map do |node|
-	        lines = node.split("\n")
-	        rm_header = lines.map do |line|
-	          if line !~ /^\#/ || line =~ /^#Total Duplicate Percentage/
-	            line.split("\t")
-	          end
-	        end
-	        rm_header.compact
-	      end
-	    end
-
-	    def basic_statistics
-	      Hash[*@object.select{|a| a.first.first == ">>Basic Statistics" }.flatten]
-	    end
-
-	    def filename
-	      @base["Filename"]
-	    end
-
-	    def file_type
-	      @base["File type"]
-	    end
-
-	    def encoding
-	      @base["Encoding"]
-	    end
-
-	    def total_sequences
-	      @base["Total Sequences"].to_i
-	    end
-
-	    def filtered_sequences
-	      @base["Filtered Sequences"].to_i
-	    end
-
-	    def sequence_length
-	      @base["Sequence length"]
-	    end
-
-	    def min_length
-	      l = @base["Sequence length"]
-	      if l =~ /\d-\d/
-	        l.sub(/-\d+$/,"").to_i
-	      else
-	        l.to_i
-	      end
-	    end
-
-	    def max_length
-	      l = @base["Sequence length"]
-	      if l =~ /\d-\d/
-	        l.sub(/^\d+-/,"").to_i
-	      else
-	        l.to_i
-	      end
-	    end
-
-	    def percent_gc
-	      @base["%GC"].to_i
-	    end
-
-	    def per_base_sequence_quality
-	      node = @object.select{|a| a.first.first == ">>Per base sequence quality" }
-	      node.first.select{|n| n.first != ">>Per base sequence quality" }
-	    end
-
-	    ## Custom module: overall mean base call quality indicator
-	    def overall_mean_quality_score
-	      per_base = self.per_base_sequence_quality
-	      v = per_base.map{|c| (10**(c[1].to_f/-10)).to_f }
-	      -10 * Math.log10(v.reduce(:+) / v.size)
-	    end
+    class Parser
+      def initialize(fastqc_data_txt)
+        @data = fastqc_data_txt
+        @object = parse(@data)
+        @base = self.basic_statistics
+      end
+
+      def parse(data)
+        modules = data.split(">>END_MODULE\n")
+        modules.map do |node|
+          lines = node.split("\n")
+          rm_header = lines.map do |line|
+            if line !~ /^\#/ || line =~ /^#Total Duplicate Percentage/
+              line.split("\t")
+            end
+          end
+          rm_header.compact
+        end
+      end
+
+      def fastqc_version
+        @data.split("\n").first.split("\t").last
+      end
+
+      def basic_statistics
+        Hash[*@object.select{|a| a.first.first == ">>Basic Statistics" }.flatten]
+      end
+
+      def filename
+        @base["Filename"]
+      end
+
+      def file_type
+        @base["File type"]
+      end
+
+      def encoding
+        @base["Encoding"]
+      end
+
+      def total_sequences
+        @base["Total Sequences"].to_i
+      end
+
+      def filtered_sequences
+        @base["Filtered Sequences"].to_i
+      end
+
+      def sequence_length
+        @base["Sequence length"]
+      end
+
+      def min_length
+        l = @base["Sequence length"]
+        if l =~ /\d-\d/
+          l.sub(/-\d+$/,"").to_i
+        else
+          l.to_i
+        end
+      end
+
+      def max_length
+        l = @base["Sequence length"]
+        if l =~ /\d-\d/
+          l.sub(/^\d+-/,"").to_i
+        else
+          l.to_i
+        end
+      end
+
+      def percent_gc
+        @base["%GC"].to_i
+      end
+
+      def per_base_sequence_quality
+        node = @object.select{|a| a.first.first == ">>Per base sequence quality" }
+        node.first.select{|n| n.first != ">>Per base sequence quality" }
+      end
+
+      ## Custom module: overall mean base call quality indicator
+      def overall_mean_quality_score
+        per_base = self.per_base_sequence_quality
+        v = per_base.map{|c| (10**(c[1].to_f/-10)).to_f }
+        -10 * Math.log10(v.reduce(:+) / v.size)
+      end
 
       ## Custom module: overall median base call quality indicator
-	    def overall_median_quality_score
-	      per_base = self.per_base_sequence_quality
+      def overall_median_quality_score
+        per_base = self.per_base_sequence_quality
         v = per_base.map{|c| (10**(c[2].to_f/-10)).to_f }
-	      -10 * Math.log10(v.reduce(:+) / v.size)
-	    end
+        -10 * Math.log10(v.reduce(:+) / v.size)
+      end
 
       def per_tile_sequence_quality
         node = @object.select{|a| a.first.first == ">>Per tile sequence quality" }
@@ -98,135 +102,142 @@ module Bio
         []
       end
 
-	    def per_sequence_quality_scores
-	      node = @object.select{|a| a.first.first == ">>Per sequence quality scores" }
-	      node.first.select{|n| n.first != ">>Per sequence quality scores" }
-	    end
-
-	    def per_base_sequence_content
-	      node = @object.select{|a| a.first.first == ">>Per base sequence content" }
-	      node.first.select{|n| n.first != ">>Per base sequence content" }
-	    end
-
-	    def per_sequence_gc_content
-	      node = @object.select{|a| a.first.first == ">>Per sequence GC content" }
-	      node.first.select{|n| n.first != ">>Per sequence GC content" }
-	    end
-
-	    def per_sequence_gc_content
-	      node = @object.select{|a| a.first.first == ">>Per sequence GC content" }
-	      node.first.select{|n| n.first != ">>Per sequence GC content" }
-	    end
-
-	    def per_base_n_content
-	      node = @object.select{|a| a.first.first == ">>Per base N content" }
-	      node.first.select{|n| n.first != ">>Per base N content" }
-	    end
-
-	    ## Custom module: overall N content
-	    def overall_n_content
-	      per_base = self.per_base_n_content
-	      v = per_base.map{|c| c[1].to_f }
-	      v.reduce(:+) / v.size
-	    end
-
-	    def sequence_length_distribution
-	      node = @object.select{|a| a.first.first == ">>Sequence Length Distribution" }
-	      node.first.select{|n| n.first != ">>Sequence Length Distribution" }
-	    end
-
-	    ## Custom module: mean sequence length calculated from distribution
-	    def mean_sequence_length
-	      distribution = self.sequence_length_distribution
-	      sum = distribution.map do |length_count|
-	        length = length_count[0]
-	        count = length_count[1].to_f
-	        if length =~ /\d-\d/
-	          f = length.sub(/-\d+$/,"").to_i
-	          b = length.sub(/^\d+-/,"").to_i
-	          mean = (f + b) / 2
-	          mean * count
-	        else
-	          length.to_i * count
-	        end
-	      end
-	      sum.reduce(:+) / self.total_sequences
-	    end
-
-	    ## Custom module: median sequence length calculated from distribution
-	    def median_sequence_length
-	      distribution = self.sequence_length_distribution
-	      array = distribution.map do |length_count|
-	        length = length_count[0]
-	        count = length_count[1].to_i
-	        if length =~ /\d-\d/
-	          f = length.sub(/-\d+$/,"").to_i
-	          b = length.sub(/^\d+-/,"").to_i
-	          mean = (f + b) / 2
-	          [mean] * count
-	        else
-	          [length.to_i] * count
-	        end
-	      end
-	      sorted = array.flatten.sort
-	      quot = sorted.size / 2
-	      if !sorted.size.even?
-	        sorted[quot]
-	      else
-	        f = sorted[quot]
-	        b = sorted[quot - 1]
-	        (f + b) / 2
-	      end
-	    end
-
-	    def sequence_duplication_levels
-	      node = @object.select{|a| a.first.first == ">>Sequence Duplication Levels" }
-	      node.first.select{|n| n.first != ">>Sequence Duplication Levels" && n.first != "\#Total Duplicate Percentage" }
-	    end
-
-	    def total_duplicate_percentage
-	      node = @object.select{|a| a.first.first == ">>Sequence Duplication Levels" }
-	      node.first.select{|n| n.first == "\#Total Duplicate Percentage" }.flatten[1].to_f
-	    end
-
-	    def overrepresented_sequences
-	      node = @object.select{|a| a.first.first == ">>Overrepresented sequences" }
-	      node.first.select{|n| n.first != ">>Overrepresented sequences" }
-	    end
-
-	    def kmer_content
-	      node = @object.select{|a| a.first.first == ">>Kmer Content" }
-	      node.first.select{|n| n.first != ">>Kmer Content" }
-	    end
-
-	    def summary
-	      {
+      def per_sequence_quality_scores
+        node = @object.select{|a| a.first.first == ">>Per sequence quality scores" }
+        node.first.select{|n| n.first != ">>Per sequence quality scores" }
+      end
+
+      def per_base_sequence_content
+        node = @object.select{|a| a.first.first == ">>Per base sequence content" }
+        node.first.select{|n| n.first != ">>Per base sequence content" }
+      end
+
+      def per_sequence_gc_content
+        node = @object.select{|a| a.first.first == ">>Per sequence GC content" }
+        node.first.select{|n| n.first != ">>Per sequence GC content" }
+      end
+
+      def per_sequence_gc_content
+        node = @object.select{|a| a.first.first == ">>Per sequence GC content" }
+        node.first.select{|n| n.first != ">>Per sequence GC content" }
+      end
+
+      def per_base_n_content
+        node = @object.select{|a| a.first.first == ">>Per base N content" }
+        node.first.select{|n| n.first != ">>Per base N content" }
+      end
+
+      ## Custom module: overall N content
+      def overall_n_content
+        per_base = self.per_base_n_content
+        v = per_base.map{|c| c[1].to_f }
+        v.reduce(:+) / v.size
+      end
+
+      def sequence_length_distribution
+        node = @object.select{|a| a.first.first == ">>Sequence Length Distribution" }
+        node.first.select{|n| n.first != ">>Sequence Length Distribution" }
+      end
+
+      ## Custom module: mean sequence length calculated from distribution
+      def mean_sequence_length
+        distribution = self.sequence_length_distribution
+        sum = distribution.map do |length_count|
+          length = length_count[0]
+          count = length_count[1].to_f
+          if length =~ /\d-\d/
+            f = length.sub(/-\d+$/,"").to_i
+            b = length.sub(/^\d+-/,"").to_i
+            mean = (f + b) / 2
+            mean * count
+          else
+            length.to_i * count
+          end
+        end
+        sum.reduce(:+) / self.total_sequences
+      end
+
+      ## Custom module: median sequence length calculated from distribution
+      def median_sequence_length
+        distribution = self.sequence_length_distribution
+        array = distribution.map do |length_count|
+          length = length_count[0]
+          count = length_count[1].to_i
+          if length =~ /\d-\d/
+            f = length.sub(/-\d+$/,"").to_i
+            b = length.sub(/^\d+-/,"").to_i
+            mean = (f + b) / 2
+            [mean.to_f] * count
+          else
+            [length.to_f] * count
+          end
+        end
+        sorted = array.flatten.sort
+        quot = sorted.size / 2
+        if !sorted.size.even?
+          sorted[quot]
+        else
+          f = sorted[quot]
+          b = sorted[quot - 1]
+          (f + b) / 2
+        end
+      end
+
+      def sequence_duplication_levels
+        node = @object.select{|a| a.first.first == ">>Sequence Duplication Levels" }
+        node.first.select{|n| n.first != ">>Sequence Duplication Levels" && n.first != "\#Total Duplicate Percentage" }
+      end
+
+      def total_duplicate_percentage
+        node = @object.select{|a| a.first.first == ">>Sequence Duplication Levels" }
+        node.first.select{|n| n.first == "\#Total Duplicate Percentage" }.flatten[1].to_f
+      end
+
+      def overrepresented_sequences
+        node = @object.select{|a| a.first.first == ">>Overrepresented sequences" }
+        node.first.select{|n| n.first != ">>Overrepresented sequences" }
+      end
+
+      def adapter_content
+        node = @object.select{|a| a.first.first == ">>Adapter Content" }
+        node.first.select{|n| n.first != ">>Adapter Content" }
+      end
+
+      def kmer_content
+        node = @object.select{|a| a.first.first == ">>Kmer Content" }
+        node.first.select{|n| n.first != ">>Kmer Content" }
+      end
+
+      def summary
+        {
+          fastqc_version: self.fastqc_version,
           filename: self.filename,
-	        file_type: self.file_type,
-	        encoding: self.encoding,
-	        total_sequences: self.total_sequences,
-	        filtered_sequences: self.filtered_sequences,
-	        sequence_length: self.sequence_length,
-	        percent_gc: self.percent_gc,
-	        per_base_sequence_quality: self.per_base_sequence_quality,
+          file_type: self.file_type,
+          encoding: self.encoding,
+          total_sequences: self.total_sequences,
+          filtered_sequences: self.filtered_sequences,
+          sequence_length: self.sequence_length,
+          percent_gc: self.percent_gc,
+          per_base_sequence_quality: self.per_base_sequence_quality,
           per_tile_sequence_quality: self.per_tile_sequence_quality,
-	        per_sequnce_quality_scores: self.per_sequence_quality_scores,
-	        per_base_sequence_content: self.per_base_sequence_content,
-	        per_sequence_gc_content: self.per_sequence_gc_content,
-	        per_base_n_content: self.per_base_n_content,
-	        sequence_length_distribution: self.sequence_length_distribution,
-	        total_duplicate_percentage: self.total_duplicate_percentage,	        sequence_duplication_levels: self.sequence_duplication_levels,
-	        overrepresented_sequences: self.overrepresented_sequences,
-	        kmer_content: self.kmer_content,
-	        min_length: self.min_length,
-	        max_length: self.max_length,
-	        overall_mean_quality_score: self.overall_mean_quality_score,
-	        overall_median_quality_score: self.overall_median_quality_score,
-	        overall_n_content: self.overall_n_content,
-	        mean_sequence_length: self.mean_sequence_length,
-	        median_sequence_length: self.median_sequence_length,
+          per_sequnce_quality_scores: self.per_sequence_quality_scores,
+          per_base_sequence_content: self.per_base_sequence_content,
+          per_sequence_gc_content: self.per_sequence_gc_content,
+          per_base_n_content: self.per_base_n_content,
+          sequence_length_distribution: self.sequence_length_distribution,
+          total_duplicate_percentage: self.total_duplicate_percentage,	        sequence_duplication_levels: self.sequence_duplication_levels,
+          overrepresented_sequences: self.overrepresented_sequences,
+          adapter_content: self.adapter_content,
+          kmer_content: self.kmer_content,
+          min_length: self.min_length,
+          max_length: self.max_length,
+          overall_mean_quality_score: self.overall_mean_quality_score,
+          overall_median_quality_score: self.overall_median_quality_score,
+          overall_n_content: self.overall_n_content,
+          mean_sequence_length: self.mean_sequence_length,
+          median_sequence_length: self.median_sequence_length,
         }
-	    end
-	  end
-	end
+      end
+    end
+  end
 end

data/spec/bio-fastqc_spec.rb

@@ -3,17 +3,296 @@ require 'spec_helper'
 describe Bio::FastQC do
   context "with an example data" do
     before do
-      zipfile = File.join(__dir__, "example_fastqc.zip")
-      @data = Bio::FastQC::Data.read(zipfile)
+      @zipfile = File.join(__dir__, "example_fastqc.zip")
     end
-    
-    it 'extracts data from zip file' do
-      expect(@data).not_to be_empty
+
+    describe Bio::FastQC::Data do
+      before do
+        @data = Bio::FastQC::Data.read(@zipfile)
+      end
+
+      describe '#read' do
+        it 'returns parsed data from zipfile' do
+          expect(@data).not_to be_empty
+        end
+      end
     end
-    
-    it 'parses a fastqc data and returns json' do
-      p = Bio::FastQC::Parser.new(@data)
-      expect(p.summary).not_to be_empty
+
+    describe Bio::FastQC::Parser do
+      before do
+        @data = Bio::FastQC::Data.read(@zipfile)
+        @parser = Bio::FastQC::Parser.new(@data)
+      end
+
+      describe '#fastqc_version' do
+        it 'returns fastqc version as String and not empty' do
+          expect(@parser.fastqc_version).to be_instance_of(String)
+          expect(@parser.fastqc_version).not_to be_empty
+        end
+      end
+
+      describe '#filename' do
+        it 'returns filename as String and not empty' do
+          expect(@parser.filename).to be_instance_of(String)
+          expect(@parser.filename).not_to be_empty
+        end
+      end
+
+      describe '#file_type' do
+        it 'returns file type as String and not empty' do
+          expect(@parser.file_type).to be_instance_of(String)
+          expect(@parser.file_type).not_to be_empty
+        end
+      end
+
+      describe '#encoding' do
+        it 'returns encoding type as String and not empty' do
+          expect(@parser.encoding).to be_instance_of(String)
+          expect(@parser.encoding).not_to be_empty
+        end
+      end
+
+      describe '#total_sequences' do
+        it 'returns total number of sequences as Fixnum' do
+          expect(@parser.total_sequences).to be_instance_of(Fixnum)
+        end
+      end
+
+      describe '#filtered_sequences' do
+        it 'returns number of filtered sequence as Fixnum and not empty' do
+          expect(@parser.filtered_sequences).to be_instance_of(Fixnum)
+        end
+      end
+
+      describe '#sequence_length' do
+        it 'returns length of sequence as String and not empty' do
+          expect(@parser.sequence_length).to be_instance_of(String)
+          expect(@parser.sequence_length).not_to be_empty
+        end
+      end
+
+      describe '#percent_gc' do
+        it 'returns percentage of GC content as Fixnum and not empty' do
+          expect(@parser.percent_gc).to be_instance_of(Fixnum)
+        end
+      end
+
+      describe '#per_base_sequence_quality' do
+        before do
+          @value = @parser.per_base_sequence_quality
+        end
+
+        it 'returns data frame as Array' do
+          expect(@value).to be_instance_of(Array)
+        end
+
+        it 'returns an array with depth 2' do
+          expect(@value.depth).to eq(2)
+        end
+
+        it 'returns an array of an array with 7 elements' do
+          sizes = @value.map{|a| a.size }.uniq
+          expect(sizes).to eq([7])
+        end
+      end
+
+      describe '#per_tile_sequence_quality' do
+        it 'returns data frame as Array' do
+          expect(@parser.per_tile_sequence_quality).to be_instance_of(Array)
+        end
+
+        it 'returns array with depth 2' do
+          expect(@parser.per_tile_sequence_quality.depth).to eq(2)
+        end
+
+        it 'returns an array of an array with 3 elements' do
+          sizes = @parser.per_tile_sequence_quality.map{|a| a.size }.uniq
+          expect(sizes).to eq([3])
+        end
+      end
+
+      describe '#per_sequence_quality_scores' do
+        it 'returns data frame as Array' do
+          expect(@parser.per_sequence_quality_scores).to be_instance_of(Array)
+        end
+
+        it 'returns array with depth 2' do
+          expect(@parser.per_sequence_quality_scores.depth).to eq(2)
+        end
+
+        it 'returns an array of an array with 2 elements' do
+          sizes = @parser.per_sequence_quality_scores.map{|a| a.size }.uniq
+          expect(sizes).to eq([2])
+        end
+      end
+
+      describe '#per_base_sequence_content' do
+        it 'returns data frame as Array' do
+          expect(@parser.per_base_sequence_content).to be_instance_of(Array)
+        end
+
+        it 'returns array with depth 2' do
+          expect(@parser.per_base_sequence_content.depth).to eq(2)
+        end
+
+        it 'returns an array of an array with 5 elements' do
+          sizes = @parser.per_base_sequence_content.map{|a| a.size }.uniq
+          expect(sizes).to eq([5])
+        end
+      end
+
+      describe '#per_sequence_gc_content' do
+        it 'returns data frame as Array' do
+          expect(@parser.per_sequence_gc_content).to be_instance_of(Array)
+        end
+
+        it 'returns array with depth 2' do
+          expect(@parser.per_sequence_gc_content.depth).to eq(2)
+        end
+
+        it 'returns an array of an array with 2 elements' do
+          sizes = @parser.per_sequence_gc_content.map{|a| a.size }.uniq
+          expect(sizes).to eq([2])
+        end
+      end
+
+      describe '#per_base_n_content' do
+        it 'returns data frame as Array' do
+          expect(@parser.per_base_n_content).to be_instance_of(Array)
+        end
+
+        it 'returns array with depth 2' do
+          expect(@parser.per_base_n_content.depth).to eq(2)
+        end
+
+        it 'returns an array of an array with 2 elements' do
+          sizes = @parser.per_base_n_content.map{|a| a.size }.uniq
+          expect(sizes).to eq([2])
+        end
+      end
+
+      describe '#sequence_length_distribution' do
+        it 'returns data frame as Array' do
+          expect(@parser.sequence_length_distribution).to be_instance_of(Array)
+        end
+
+        it 'returns array with depth 2' do
+          expect(@parser.sequence_length_distribution.depth).to eq(2)
+        end
+
+        it 'returns an array of an array with 2 elements' do
+          sizes = @parser.sequence_length_distribution.map{|a| a.size }.uniq
+          expect(sizes).to eq([2])
+        end
+      end
+
+      describe '#total_duplicate_percentage' do
+        it 'returns duplicate percentage as Float and not empty' do
+          expect(@parser.total_duplicate_percentage).to be_instance_of(Float)
+        end
+      end
+
+      describe '#sequence_duplication_levels' do
+        it 'returns data frame as Array' do
+          expect(@parser.sequence_duplication_levels).to be_instance_of(Array)
+        end
+
+        it 'returns array with depth 2' do
+          expect(@parser.sequence_duplication_levels.depth).to eq(2)
+        end
+
+        it 'returns an array of an array with 3 elements' do
+          sizes = @parser.sequence_duplication_levels.map{|a| a.size }.uniq
+          expect(sizes).to eq([3])
+        end
+      end
+
+      describe '#overrepresented_sequences' do
+        it 'returns data frame as Array' do
+          expect(@parser.overrepresented_sequences).to be_instance_of(Array)
+        end
+
+        it 'returns array with depth 2' do
+          expect(@parser.overrepresented_sequences.depth).to eq(2)
+        end
+
+        it 'returns an array of an array with 4 elements' do
+          sizes = @parser.overrepresented_sequences.map{|a| a.size }.uniq
+          expect(sizes).to eq([4])
+        end
+      end
+
+      describe '#adapter_content' do
+        it 'returns data frame as Array' do
+          expect(@parser.adapter_content).to be_instance_of(Array)
+        end
+
+        it 'returns array with depth 2' do
+          expect(@parser.adapter_content.depth).to eq(2)
+        end
+
+        it 'returns an array of an array with 5 elements' do
+          sizes = @parser.adapter_content.map{|a| a.size }.uniq
+          expect(sizes).to eq([5])
+        end
+      end
+
+      describe '#kmer_content' do
+        it 'returns data frame as Array' do
+          expect(@parser.kmer_content).to be_instance_of(Array)
+        end
+
+        it 'returns array with depth 2' do
+          expect(@parser.kmer_content.depth).to eq(2)
+        end
+
+        it 'returns an array of an array with 5 elements' do
+          sizes = @parser.kmer_content.map{|a| a.size }.uniq
+          expect(sizes).to eq([5])
+        end
+      end
+
+      describe '#min_length' do
+        it 'returns minimum read length as Fixnum and not empty' do
+          expect(@parser.min_length).to be_instance_of(Fixnum)
+        end
+      end
+
+      describe '#max_length' do
+        it 'returns maximum read length as Fixnum and not empty' do
+          expect(@parser.max_length).to be_instance_of(Fixnum)
+        end
+      end
+
+      describe '#overall_mean_quality_score' do
+        it 'returns overall mean quality score as Float and not empty' do
+          expect(@parser.overall_mean_quality_score).to be_instance_of(Float)
+        end
+      end
+
+      describe '#overall_median_quality_score' do
+        it 'returns overall median quality score as Float and not empty' do
+          expect(@parser.overall_median_quality_score).to be_instance_of(Float)
+        end
+      end
+
+      describe '#overall_n_content' do
+        it 'returns overall N content as Float and not empty' do
+          expect(@parser.overall_n_content).to be_instance_of(Float)
+        end
+      end
+
+      describe '#mean_sequence_length' do
+        it 'returns mean sequence length from read length distribution as Float and not empty' do
+          expect(@parser.mean_sequence_length).to be_instance_of(Float)
+        end
+      end
+
+      describe '#median_sequence_length' do
+        it 'returns median sequence length from read length distribution as Float and not empty' do
+          expect(@parser.median_sequence_length).to be_instance_of(Float)
+        end
+      end
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,2 +1,14 @@
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 require 'bio-fastqc'
+
+class Array
+	def depth
+		map {|element| element.depth + 1 }.max
+	end
+end
+
+class Object
+  def depth
+    0
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bio-fastqc
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Tazro Inutano Ohta
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-06 00:00:00.000000000 Z
+date: 2015-11-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip
@@ -48,16 +48,16 @@ dependencies:
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.10'
+        version: 1.8.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.10'
+        version: 1.8.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement