bio-fastqc 0.2.1 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 47531c30911b727ad8b3bdc50e26ca8a3a6467e1
-  data.tar.gz: 68bfdb57eac8779b634abcce1bed1cd40986a602
+  metadata.gz: 7e21d6a0e0f6ec91c058b8a574e79e6fa9dad431
+  data.tar.gz: 93ed09413b3fdb49564c43e68a49bed3d1937d88
 SHA512:
-  metadata.gz: b5b9b66d01c11669db71c96eb3c7e87c74e7ab45b55605481b6d75b14f5c06b7bb2813dff5d20833068d17bf7246aef663356523b46278621b863675ebc9186e
-  data.tar.gz: e81822150a02e8e7634e0a5942fe0806297c5a86211dc2bb5609d2504b47d64e77c4e7122526069037e6af1166857ba1934444fb51aa4e241690f598e9afc051
+  metadata.gz: 48097e944bd5c7e76a804f7d0623f869dddb17fceb4da878878489f2ad745dab9b0c925cadccce12bee332ff3b3c8db5dea1ce22085acf1be914bddec2f04998
+  data.tar.gz: fc4ac83bb59b47e5bf554884efbdc7e7f179fece8bd94fa70529fe7858727cdf6826ec87ac6081c68d91c3c82f0c908ab46a8798f9b180d9974839aa02daa77c

data/Gemfile

@@ -5,6 +5,8 @@ source "http://rubygems.org"
 
 gem 'rubyzip', '~> 1.1', '>= 1.1.0'
 gem 'thor', "~> 0.19.1"
+gem 'json-ld', '~> 1.99'
+gem 'rdf-turtle', '~> 1.99'
 
 # Add dependencies to develop your gem here.
 # Include everything needed to run rake, tests, features, etc.
@@ -19,5 +21,5 @@ group :development do
   gem 'simplecov', '~> 0.10'
 
   gem 'pry', '~> 0.10'
-  gem 'bio-fastqc'
+  gem 'bio-fastqc', '0.3.0'
 end

data/VERSION

@@ -1 +1 @@
-0.2.1
+0.3.1

data/lib/bio-fastqc.rb

@@ -11,4 +11,6 @@
 require 'bio/fastqc/data'
 require 'bio/fastqc/cli'
 require 'bio/fastqc/parser'
+require 'bio/fastqc/converter'
+require 'bio/fastqc/semantics'
 require 'bio/fastqc'

data/lib/bio/fastqc/cli.rb

@@ -6,13 +6,14 @@ require 'json'
 module Bio
   module FastQC
     class CLI < Thor
-      desc "parse [filename]...", "parse fastqc data in fastqc directory or zipfile, output in json format"
-      def parse(*files)
-        files.each do |file|
-          puts JSON.dump(Parser.new(Data.read(file)).summary)
-        end
-      rescue
-        puts "Wrong input file type: specify fastqc result data, directory or zipfile"
+      desc "parse [--format format] [filename]", "parse fastqc data in fastqc directory or zipfile, output in json, json-ld, or rdf-turtle format."
+      option :format, :default => "json"
+      def parse(file)
+        data = Data.read(file)
+        summary = Parser.new(data).summary
+        puts Converter.new(summary).convert_to(options[:format])
+      # rescue
+      #   puts "Wrong input file type: specify fastqc result data, directory or zipfile"
       end
     end
   end

data/lib/bio/fastqc/converter.rb

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+
+module Bio
+  module FastQC
+    class Converter
+      def initialize(summary_json)
+        @summary_json = summary_json
+      end
+
+      def convert_to(format)
+        case format
+        when "json"
+          to_json
+        when "json-ld"
+          to_jsonld
+        when "turtle"
+          to_turtle
+        end
+      end
+
+      def to_json
+        JSON.dump(@summary_json)
+      end
+
+      def to_jsonld
+        json_ld_object = Semantics.new(@summary_json).json_ld_object
+        JSON.dump(json_ld_object)
+      end
+
+      def to_turtle
+        Semantics.new(@summary_json).turtle
+      end
+    end
+  end
+end

data/lib/bio/fastqc/parser.rb

@@ -220,12 +220,13 @@ module Bio
           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_sequence_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,
+          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,

data/lib/bio/fastqc/semantics.rb

@@ -0,0 +1,715 @@
+# -*- coding: utf-8 -*-
+
+require 'json/ld'
+require 'rdf/turtle'
+
+module Bio
+  module FastQC
+    class Semantics
+      def initialize(summary_json)
+        @summary = summary_json
+      end
+
+      def turtle
+        object = json_ld_object
+        graph = RDF::Graph.new << JSON::LD::API.toRdf(object)
+        graph.dump(:ttl, prefixes: turtle_prefixes)
+      end
+
+      def turtle_prefixes
+        {
+          "uo" => "http://purl.obolibrary.org/obo/",
+          "rdf" => "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
+        }
+      end
+
+      def json_ld_object
+        object = [object_core, static_value_modules].flatten.inject(&:merge)
+        object["hasMatrix"] = matrix_modules
+        object
+      end
+
+      def identifier
+        "http://me.com/data/QNT" + @summary[:filename].split(".").first
+      end
+
+      def object_core
+        {
+          "@context" => jsonld_context,
+          "@id" => identifier,
+        }
+      end
+
+      def static_value_modules
+        [
+          fastqc_version,
+          filename,
+          file_type,
+          encoding,
+          total_sequences,
+          filtered_sequences,
+          sequence_length,
+          percent_gc,
+          total_duplicate_percentage,
+          min_length,
+          max_length,
+          overall_mean_quality_score,
+          overall_median_quality_score,
+          overall_n_content,
+          mean_sequence_length,
+          median_sequence_length,
+        ]
+      end
+
+      def matrix_modules
+        [
+          per_base_sequence_quality,
+          per_tile_sequence_quality,
+          per_sequence_quality_scores,
+          per_base_sequence_content,
+          per_sequence_gc_content,
+          per_base_n_content,
+          sequence_length_distribution,
+          sequence_duplication_levels,
+          overrepresented_sequences,
+          adapter_content,
+          kmer_content,
+        ]
+      end
+
+      def base_stat_class(base)
+        case base
+        when /-/ # when the base position is range like "50-100"
+          "BaseRangeStatistics"
+        else
+          "ExactBaseStatistics"
+        end
+      end
+
+      def fastqc_version
+        {}
+      end
+
+      def filename
+        {
+          "filename" => @summary[:filename],
+        }
+      end
+
+      def file_type
+        {
+          "fileType" => @summary[:file_type],
+        }
+      end
+
+      def encoding
+        {
+          "encoding" => @summary[:encoding],
+        }
+      end
+
+      def total_sequences
+        {
+          "totalSequences" => {
+            "@type" => "SequenceReadContent",
+            "hasUnit" => "uo:CountUnit",
+            "rdf:value" => @summary[:total_sequences],
+          }
+        }
+      end
+
+      def filtered_sequences
+        {
+          "filteredSequences" => {
+            "@type" => "SequenceReadContent",
+            "hasUnit" => "uo:CountUnit",
+            "rdf:value" => @summary[:filtered_sequences],
+          }
+        }
+      end
+
+      def sequence_length
+        {
+          "sequenceLength" => {
+            "@type" => "SequenceReadLength",
+            "hasUnit" => "uo:CountUnit",
+            "rdf:value" => @summary[:sequence_length],
+          }
+        }
+      end
+
+      def percent_gc
+        {
+          "percentGC" => {
+            "@type" => "NucleotideBaseContent",
+            "hasUnit" => "uo:CountUnit",
+            "rdf:value" => @summary[:percent_gc],
+          }
+        }
+      end
+
+      def per_base_sequence_quality
+        {
+          "@type" => "PerBaseSequenceQuality",
+          "hasRow" => per_base_sequence_quality_rows(@summary[:per_base_sequence_quality]),
+        }
+      end
+
+      def per_base_sequence_quality_rows(matrix)
+        matrix.map.with_index do |row, i|
+          base = row[0]
+          mean = row[1]
+          median = row[2]
+          lower_quartile = row[3]
+          upper_quartile = row[4]
+          tenth_percentile = row[5]
+          ninetieth_percentile = row[6]
+
+          {
+            "@type" => [
+              "Row",
+              base_stat_class(base),
+            ],
+            "rowIndex" => i,
+            "basePosition" => base,
+            "meanBaseCallQuality" => {
+              "@type" => "PhredQualityScore",
+              "hasUnit" => "uo:CountUnit",
+              "rdf:value" => mean,
+            },
+            "medianBaseCallQuality" => {
+              "@type" => "PhredQualityScore",
+              "hasUnit" => "uo:CountUnit",
+              "rdf:value" => median,
+            },
+            "baseCallQualityLowerQuartile" => {
+              "@type" => "PhredQualityScore",
+              "hasUnit" => "uo:CountUnit",
+              "rdf:value" => lower_quartile,
+            },
+            "baseCallQualityUpperQuartile" => {
+              "@type" => "PhredQualityScore",
+              "hasUnit" => "uo:CountUnit",
+              "rdf:value" => upper_quartile,
+            },
+            "baseCallQuality10thPercentile" => {
+              "@type" => "PhredQualityScore",
+              "hasUnit" => "uo:CountUnit",
+              "rdf:value" => tenth_percentile,
+            },
+            "baseCallQuality90thPercentile" => {
+              "@type" => "PhredQualityScore",
+              "hasUnit" => "uo:CountUnit",
+              "rdf:value" => ninetieth_percentile,
+            },
+          }
+        end
+      end
+
+      def per_tile_sequence_quality
+        {}
+      end
+
+      def per_sequence_quality_scores
+        {
+          "@type" => "PerSequnceQualityScores",
+          "hasRow" => per_sequence_quality_scores_rows(@summary[:per_sequence_quality_scores]),
+        }
+      end
+
+      def per_sequence_quality_scores_rows(matrix)
+        matrix.map.with_index do |row, i|
+          quality = row[0]
+          count = row[1]
+          {
+            "@type" => "Row",
+            "rowIndex" => i,
+            "baseCallQuality" => {
+              "@type" => "PhredQualityScore",
+              "hasUnit" => "uo:CountUnit",
+              "rdf:value" => quality,
+            },
+            "sequenceReadCount" => {
+              "@type" => "SequenceReadContent",
+              "hasUnit" => "uo:CountUnit",
+              "rdf:value" => count,
+            },
+          }
+        end
+      end
+
+      def per_base_sequence_content
+        {
+          "@type" => "PerBaseSequenceContent",
+          "hasRow" => per_base_sequence_content_rows(@summary[:per_base_sequence_content]),
+        }
+      end
+
+      def per_base_sequence_content_rows(matrix)
+        matrix.map.with_index do |row, i|
+          base = row[0]
+          guanine = row[1]
+          adenine = row[2]
+          thymine = row[3]
+          chytosine = row[4]
+          {
+            "@type" => [
+              "Row",
+              base_stat_class(base),
+            ],
+            "rowIndex" => i,
+            "basePosition" => base,
+            "percentGuanine" => {
+              "@type" => "NucleotideBaseContent",
+              "hasUnit" => "uo:Percentage",
+              "rdf:value" => guanine,
+            },
+            "percentAdenine" => {
+              "@type" => "NucleotideBaseContent",
+              "hasUnit" => "uo:Percentage",
+              "rdf:value" => adenine,
+            },
+            "percentThymine" => {
+              "@type" => "NucleotideBaseContent",
+              "hasUnit" => "uo:Percentage",
+              "rdf:value" => thymine,
+            },
+            "percentCytosine" => {
+              "@type" => "NucleotideBaseContent",
+              "hasUnit" => "uo:Percentage",
+              "rdf:value" => chytosine,
+            },
+          }
+        end
+      end
+
+      def per_sequence_gc_content
+        {
+          "@type" => "PerSequenceGCContent",
+          "hasRow" => per_sequence_gc_content_rows(@summary[:per_sequence_gc_content]),
+        }
+      end
+
+      def per_sequence_gc_content_rows(matrix)
+        matrix.map.with_index do |row, i|
+          gc_content = row[0]
+          count = row[1]
+          {
+            "@type" => "Row",
+            "rowIndex" => i,
+            "percentGC" => {
+              "@type" => "NucleotideBaseContent",
+              "hasunit" => "uo:Percent",
+              "rdf:value" => gc_content,
+            },
+            "sequenceReadCount" => {
+              "@type" => "SequenceReadContent",
+              "hasUnit" => "uo:CountUnit",
+              "rdf:value" => count,
+            },
+          }
+        end
+      end
+
+      def per_base_n_content
+        {
+          "@type" => "PerBaseNContent",
+          "hasRow" => per_base_n_content_rows(@summary[:per_base_n_content]),
+        }
+      end
+
+      def per_base_n_content_rows(matrix)
+        matrix.map.with_index do |row, i|
+          base = row[0]
+          n_count = row[1]
+          {
+            "@type" => [
+              "Row",
+              base_stat_class(base),
+            ],
+            "rowIndex" => i,
+            "basePosition" => base,
+            "nCount" => {
+              "@type" => "NContent",
+              "hasUnit" => "uo:Percentage",
+              "rdf:value" => n_count,
+            },
+          }
+        end
+      end
+
+      def sequence_length_distribution
+        {
+          "@type" => "SequenceLengthDistribution",
+          "hasRow" => sequence_length_distribution_rows(@summary[:sequence_length_distribution]),
+        }
+      end
+
+      def sequence_length_distribution_rows(matrix)
+        matrix.map.with_index do |row, i|
+          length = row[0]
+          count = row[1]
+          {
+            "@type" => "Row",
+            "rowIndex" => i,
+
+            "sequenceReadLength" => {
+              "@type" => "SequenceReadLength",
+              "hasUnit" => "uo:CountUnit",
+              "rdf:value" => length,
+            },
+            "sequenceReadCount" => {
+              "@type" => "SequenceReadContent",
+              "hasUnit" => "uo:CountUnit",
+              "rdf:value" => count,
+            },
+          }
+        end
+      end
+
+      def total_duplicate_percentage
+        {}
+      end
+
+      def sequence_duplication_levels
+        {
+          "@type" => "SequenceDuplicationLevels",
+          "hasRow" => sequence_duplication_levels_rows(@summary[:sequence_duplication_levels]),
+        }
+      end
+
+      def sequence_duplication_levels_rows(matrix)
+        matrix.map.with_index do |row, i|
+          duplication_level = row[0]
+          relative_count = row[1]
+          {
+            "@type" => "Row",
+            "rowIndex" => i,
+
+            "sequenceDuplicationLevel" => {
+              "@type" => "SequenceDuplicationLevel",
+              "hasUnit" => "uo:CountUnit",
+              "rdf:value" => duplication_level,
+            },
+            "sequenceReadRelativeCount" => {
+              "@type" => "SequenceReadContent",
+              "hasUnit" => "uo:CountUnit",
+              "rdf:value" => relative_count,
+            },
+          }
+        end
+      end
+
+      def overrepresented_sequences
+        {
+          "@type" => "OverrepresentedSequences",
+          "hasRow" => overrepresented_sequences_rows(@summary[:overrepresented_sequences]),
+        }
+      end
+
+      def overrepresented_sequences_rows(matrix)
+        matrix.map.with_index do |row, i|
+          sequence = row[0]
+          count = row[1]
+          percentage = row[2]
+          possible_source = row[3]
+          {
+            "@type" => "Row",
+            "rowIndex" => i,
+            "overrepresentedSequence" => sequence,
+            "sequenceReadCount" => {
+              "@type" => "SequenceReadContent",
+              "hasUnit" => "uo:CountUnit",
+              "rdf:value" => count,
+            },
+            "sequenceReadPercentage" => {
+              "@type" => "SequenceReadContent",
+              "hasUnit" => "uo:Percentage",
+              "rdf:value" => percentage,
+            },
+            "possibleSourceOfSequence" => possible_source,
+          }
+        end
+      end
+
+      def adapter_content
+        {}
+      end
+
+      def kmer_content
+        {
+          "@type" => "KmerContent",
+          "hasRow" => kmer_content_rows(@summary[:kmer_content]),
+        }
+      end
+
+      def kmer_content_rows(matrix)
+        matrix.map.with_index do |row, i|
+          sequence = row[0]
+          count = row[1]
+          ratio_overall = row[2]
+          ratio_max = row[3]
+          ratio_max_position = row[4]
+          {
+            "@type" => "Row",
+            "rowIndex" => i,
+            "kmerSequence" => sequence,
+            "sequenceReadCount" => {
+              "@type" => "SequenceReadContent",
+              "hasUnit" => "uo:CountUnit",
+              "rdf:value" => count,
+            },
+            "observedPerExpectedOverall" => {
+              "@type" => "SequenceReadContent",
+              "hasUnit" => "uo:Ratio",
+              "rdf:value" => ratio_overall,
+            },
+            "observedPerExpectedMax" => {
+              "@type" => "SequenceReadContent",
+              "hasUnit" => "uo:Ratio",
+              "rdf:value" => ratio_max,
+            },
+            "observedPerExpectedMaxPosition" => ratio_max_position,
+          }
+        end
+      end
+
+      def min_length
+        {
+          "minSequenceLength" => {
+            "@type" => "SequenceReadLength",
+            "hasUnit" => "uo:CountUnit",
+            "rdf:value" => @summary[:min_length],
+          }
+        }
+      end
+
+      def max_length
+        {
+          "maxSequenceLength" => {
+            "@type" => "SequenceReadLength",
+            "hasUnit" => "uo:CountUnit",
+            "rdf:value" => @summary[:max_length],
+          }
+        }
+      end
+
+      def mean_sequence_length
+        {
+          "meanSequenceLength" => {
+            "@type" => "SequenceReadLength",
+            "hasUnit" => "uo:CountUnit",
+            "rdf:value" => @summary[:mean_sequence_length],
+          }
+        }
+      end
+
+      def median_sequence_length
+        {
+            "medianSequenceLength" => {
+            "@type" => "SequenceReadLength",
+            "hasUnit" => "uo:CountUnit",
+            "rdf:value" => @summary[:median_sequence_length],
+          }
+        }
+      end
+
+      def overall_mean_quality_score
+        {
+          "overallMeanBaseCallQuality" => {
+            "@type" => "PhredQualityScore",
+            "hasUnit" => "uo:CountUnit",
+            "rdf:value" => @summary[:overall_mean_quality_score],
+          }
+        }
+      end
+
+      def overall_median_quality_score
+        {
+          "overallMedianBaseCallQuality" => {
+            "@type" => "PhredQualityScore",
+            "hasUnit" => "uo:CountUnit",
+            "rdf:value" => @summary[:overall_median_quality_score],
+          }
+        }
+      end
+
+      def overall_n_content
+        {
+          "overallNContent" => {
+            "@type" => "NContent",
+            "hasUnit" => "uo:Percentage",
+            "rdf:value" => @summary[:overall_n_content],
+          }
+        }
+      end
+
+      #
+      # Generate JSON-LD context object
+      #
+
+      def jsonld_context
+        # definition of imported terms in @context
+        object = imported_keywords
+
+        # definition of local ontology terms
+        domain = "http://me.com/sos#"
+
+        # definition of class in @context
+        sos_class.each do |term|
+          object[term] = {}
+          object[term]["@id"] = domain + term
+          object[term]["@type"] = "@id"
+        end
+
+        # definition of object properties in @context
+        sos_object_properties.each do |term|
+          object[term] = {}
+          object[term]["@id"] = domain + term
+          object[term]["@type"] = "@id"
+        end
+
+        sos_data_properties_string.each do |term|
+          object[term] = {}
+          object[term]["@id"] = domain + term
+          object[term]["@type"] = "http://www.w3.org/2001/XMLSchema#string"
+        end
+
+        sos_data_properties_integer.each do |term|
+          object[term] = {}
+          object[term]["@id"] = domain + term
+          object[term]["@type"] = "http://www.w3.org/2001/XMLSchema#integer"
+        end
+
+        sos_data_properties_float.each do |term|
+          object[term] = {}
+          object[term]["@id"] = domain + term
+          object[term]["@type"] = "http://www.w3.org/2001/XMLSchema#float"
+        end
+
+        object
+      end
+
+      def imported_keywords
+        {
+          "uo" => "http://purl.obolibrary.org/obo/",
+          "rdf" => "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
+        }
+      end
+
+      #
+      # definition of classes
+      #
+
+      def sos_class
+        [
+          sos_class_general,
+          sos_class_fastqc_modules,
+          sos_class_for_values,
+        ].flatten
+      end
+
+      def sos_class_general
+        [
+          "SequenceStatisticsReport",
+          "SequenceStatisticsMatrix",
+          "Row",
+          "ExactBaseStatistics",
+          "BaseRangeStatistics",
+        ]
+      end
+
+      def sos_class_fastqc_modules
+        [
+          "PerBaseSequenceQuality",
+          "PerTileSequenceQuality",
+          "PerSequnceQualityScores",
+          "PerBaseSequenceContent",
+          "PerSequenceGCContent",
+          "PerBaseNContent",
+          "SequenceLengthDistribution",
+          "SequenceDuplicationLevels",
+          "OverrepresentedSequences",
+          "KmerContent",
+        ]
+      end
+
+      def sos_class_for_values
+        [
+          "PhredQualityScore",
+          "NucleotideBaseContent",
+          "SequenceReadContent",
+          "SequenceReadLength",
+          "SequenceDuplicationLevel",
+        ]
+      end
+
+      #
+      # definition of predicates
+      #
+
+      def sos_object_properties
+        [
+          "hasMatrix",
+          "totalSequences",
+          "filteredSequences",
+          "sequenceLength",
+          "percentGC",
+          "hasRow",
+          "basePosition",
+          "kmerSequence",
+          "meanBaseCallQuality",
+          "medianBaseCallQuality",
+          "nCount",
+          "observedPerExpectedMax",
+          "observedPerExpectedMaxPosition",
+          "observedPerExpectedOverall",
+          "percentAdenine",
+          "percentCytosine",
+          "percentGC",
+          "percentGuanine",
+          "percentThymine",
+          "sequenceDuplicationLevel",
+          "sequenceReadCount",
+          "sequenceReadLength",
+          "sequenceReadPercentage",
+          "sequenceReadRelativeCount",
+          "hasUnit",
+          "overallMeanBaseCallQuality",
+          "overallMedianBaseCallQuality",
+          "overallNContent",
+        ]
+      end
+
+      def sos_data_properties_string
+        [
+          "filename",
+          "fileType",
+          "encoding",
+          "possibleSourceOfSequence",
+          "overrepresentedSequence",
+        ]
+      end
+
+      def sos_data_properties_integer
+        [
+          "rowIndex",
+        ]
+      end
+
+      def sos_data_properties_float
+        [
+          "baseCallQuality",
+          "baseCallQuality10thPercentile",
+          "baseCallQuality90thPercentile",
+          "baseCallQualityLowerQuartile",
+          "baseCallQualityUpperQuartile",
+          "minSequenceLength",
+          "maxSequenceLength",
+          "meanSequenceLength",
+          "medianSequenceLength",
+        ]
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bio-fastqc
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.1
 platform: ruby
 authors:
 - Tazro Inutano Ohta
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-11 00:00:00.000000000 Z
+date: 2016-03-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip
@@ -44,6 +44,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.19.1
+- !ruby/object:Gem::Dependency
+  name: json-ld
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.99'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.99'
+- !ruby/object:Gem::Dependency
+  name: rdf-turtle
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.99'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.99'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -160,16 +188,16 @@ dependencies:
   name: bio-fastqc
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.3.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.3.0
 description: ruby parser for FastQC, a quality control software for high-throughput
   sequencing data.
 email: inutano@gmail.com
@@ -194,8 +222,10 @@ files:
 - lib/bio-fastqc.rb
 - lib/bio/fastqc.rb
 - lib/bio/fastqc/cli.rb
+- lib/bio/fastqc/converter.rb
 - lib/bio/fastqc/data.rb
 - lib/bio/fastqc/parser.rb
+- lib/bio/fastqc/semantics.rb
 - spec/bio-fastqc_spec.rb
 - spec/example_fastqc.zip
 - spec/spec_helper.rb