needleman_wunsch_aligner 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 525f3aee90fc6e9de7a8de268cfcd7300836b5e7
+  data.tar.gz: 561e1b71b51e6c45cbaf0e6da72bbe9341a9adbb
+SHA512:
+  metadata.gz: b87838a2c2bf5460090d68ea23494aa2a714556b51f558ea17a9ad708612181f0a71ae96b56025a6e1ed5af96512ed25fce8a694f1cb3476876fad85c8d82f88
+  data.tar.gz: 2579acb036d6b4fba976fc3705a1cbc129ef9fc68a30458b699d37ac2909f0607b8a6e65ecde3aab4217816dc556d44e56b342b0b3e54551ac545f4993f1b43c

data/.gitignore

@@ -0,0 +1,24 @@
+*.gem
+*.rbc
+.bundle
+.config
+.ruby-gemset
+.ruby-version
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in needleman_wunsch_aligner.gemspec
+gemspec

data/LICENSE.txt

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

data/README.md

@@ -0,0 +1,96 @@
+# NeedlemanWunschAligner
+
+This gem finds the optimal alignment of two sequences of any kind of Ruby Objects. You can implement sophisticated scoring functions, using any of the Objects’ attributes.
+
+The [Needleman-Wunsch algorithm](https://en.wikipedia.org/wiki/Needleman%E2%80%93Wunsch_algorithm) is typically used in bioinformatics to align protein or nucleotide sequences, however it works really well for any kind of sequence. I have used this gem to align paragraphs and sentences of pairs of bilingual texts.
+
+Given two sequences
+
+    seq1 = 'GCATGCU'
+    seq2 = 'GATTACA'
+
+The algorithm will find the optimal alignment based on a scoring function you specify:
+
+    GCATG-CU
+    =+==!-=!
+    G-ATTACA
+
+Meaning of the symbols:
+
+    = Match
+    ! Mismatch
+    + Insert
+    - Deletion
+
+Insert and Deletion are usually grouped together as `IndDel`.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'needleman_wunsch_aligner'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install needleman_wunsch_aligner
+
+## Usage
+
+Instantiate a new aligner with the two sequences and compute the optimal alignment:
+
+    require 'needleman_wunsch_aligner'
+
+    aligner = NeedlemanWunschAligner.new([1,2,3], [2,3,4])
+    aligner.get_optimal_alignment
+    # => [[1, 2, 3, nil], [nil, 2, 3, 4]]
+
+Inspect the alignment:
+
+    aligner.print_alignment
+
+    # =>   1 | nil
+           2 | 2
+           3 | 3
+         nil | 4
+
+Inspect the score table:
+
+    aligner.print_as_table(:score)
+    # =>            2   3   4
+                0  -1  -2  -3
+            1  -1  -2  -3  -4
+            2  -2   0  -1  -2
+            3  -3  -1   1   0
+
+Inspect the traceback table:
+
+    aligner.print_as_table(:traceback)
+    # =>            2   3   4
+                x   ←   ←   ←
+            1   ↑   ↑   ↑   ↑
+            2   ↑   ⬉   ←   ←
+            3   ↑   ↑   ⬉   ←
+
+## Customization
+
+The gem comes with a very basic scoring function. You can implement much more
+sophisticated ones by subclassing the `NeedlemanWunschAligner` class and overriding the following instance methods:
+
+* `compute_score`
+* `default_gap_penalty`
+* `gap_indicator`
+
+Please see `NeedlemanWunschAligner::ExampleParagraphAndSentenceAligner` for an
+example.
+
+## Contributing
+
+1. Fork it ( https://github.com/jhund/needleman_wunsch_aligner/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,14 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+Rake::TestTask.new do |test|
+  test.libs << 'spec'
+  test.pattern = 'spec/**/*_spec.rb'
+  test.verbose = true
+end

data/lib/needleman_wunsch_aligner/example_paragraph_and_sentence_aligner.rb

@@ -0,0 +1,49 @@
+class NeedlemanWunschAligner
+  class ExampleParagraphAndSentenceAligner < NeedlemanWunschAligner
+
+    # Get score for alignment pair of paragraphs and sentences. Aligner prioritizes
+    # alignment of paragraphs over that of sentences.
+    #
+    #         p/1   p/2   p/nil s/a   s/b   s/nil
+    #  p/1    25    -25   -25   -250  -250  -250
+    #  p/2          25    -25   -250  -250  -250
+    #  p/nil              25    -250  -250  -250
+    #  s/a                      10    -10   -10
+    #  s/b                            10    -10
+    #  s/nil                                10
+    #
+    # param left_el [Hash]
+    # param top_el [Hash]
+    # return [Integer]
+    def compute_score(left_el, top_el)
+      score = 0
+      if left_el[:type] == top_el[:type]
+        # Match on type (paragraph vs. sentence)
+        case left_el[:type]
+        when :paragraph
+          score += left_el[:id] == top_el[:id] ? 25 : -25
+        when :sentence
+          score += left_el[:id] == top_el[:id] ? 10 : -10
+        else
+          raise "Handle this: #{ [left_el, top_el].inspect }"
+        end
+      elsif [left_el, top_el].any? { |e| :paragraph == e[:type] }
+        # Difference in type, one is :paragraph. This is more significant
+        # than sentences.
+        score += -250
+      else
+        raise "Handle this: #{ [left_el, top_el].inspect }"
+      end
+      score
+    end
+
+    def default_gap_penalty
+      -10
+    end
+
+    def gap_indicator
+      { type: :gap }
+    end
+
+  end
+end

data/lib/needleman_wunsch_aligner/version.rb

@@ -0,0 +1,3 @@
+class NeedlemanWunschAligner
+  VERSION = "1.0.0"
+end

data/lib/needleman_wunsch_aligner.rb

@@ -0,0 +1,173 @@
+require "needleman_wunsch_aligner/version"
+
+# Finds the optimal alignment of two sequences using the Needleman-Wunsch algorithm.
+# This basic implementation works with any Ruby object and just looks at object
+# identity for the scoring algorithm.
+#
+# See ExampleParagraphAndSentenceAligner for an example of a more sophisticated
+# scoring algorithm.
+class NeedlemanWunschAligner
+
+  # @param left_seq [Array<Object>] sequence drawn at left of matrix
+  # @param top_seq [Array<Object>] sequence drawn at top of matrix
+  def initialize(left_seq, top_seq)
+    @left_seq = left_seq
+    @top_seq = top_seq
+  end
+
+  # Returns two arrays that represent the optimal alignment.
+  def get_optimal_alignment
+    construct_score_matrix_and_traceback_matrix
+    compute_optimal_alignment
+  end
+
+  # This is a basic implementation of the scoring algorithm. See
+  # ExampleParagraphAndSentenceAligner for a more complex scoring function.
+  # @param left_el [Object]
+  # @param top_el [Object]
+  # @return [Numeric]
+  def compute_score(left_el, top_el)
+    left_el == top_el ? 1 : -3
+  end
+
+  # Returns the default penalty for a gap.
+  # @return [Numeric]
+  def default_gap_penalty
+    -1
+  end
+
+  # Returns a sequence element to indicate a gap. Needs to be compatible with
+  # other sequence elements and your scoring function.
+  # @return [Object]
+  def gap_indicator
+    nil
+  end
+
+  # Prints the optimal alignment.
+  # @param col_width [Integer, optional] max width of each col in chars
+  def print_alignment(col_width = 20)
+    aligned_left_seq, aligned_top_seq = get_optimal_alignment
+    puts
+    aligned_left_seq.each_with_index do |ls_el, idx|
+      rs_el = aligned_top_seq[idx]
+      puts [
+        ls_el.inspect[0..col_width].rjust(col_width),
+        rs_el.inspect[0..col_width].ljust(col_width),
+      ].join(' | ')
+    end
+  end
+
+  # Prints either the score or the traceback matrix as table.
+  # @param which_matrix [Symbol] one of :traceback or :score
+  # @param col_width [Integer, optional], defaults to 3
+  def print_as_table(which_matrix, col_width = 3)
+    get_optimal_alignment  if @score_matrix.nil?
+    the_matrix = case which_matrix
+    when :traceback
+      @traceback_matrix
+    when :score
+      @score_matrix
+    else
+      raise "Handle this: #{ which_matrix.inspect }"
+    end
+
+    puts
+    puts 'left_seq = ' + @left_seq.join
+    puts 'top_seq = ' + @top_seq.join
+    puts
+    print ' ' * 2 * col_width
+
+    # Print header row
+    @top_seq.each_index { |e| print(@top_seq[e].to_s.rjust(col_width)) }
+
+    puts ''
+    traverse_score_matrix do |row, col|
+      if 0 == col and 0 == row
+        # first column in first row
+        print ' '.rjust(col_width)
+      elsif 0 == col
+        # first col in subsequent rows
+        print @left_seq[row - 1].to_s.rjust(col_width)
+      end
+      print the_matrix[row][col].to_s.rjust(col_width)
+      puts '' if col == the_matrix[row].length - 1
+    end
+  end
+
+protected
+
+  def construct_score_matrix_and_traceback_matrix
+    initialize_score_matrix_and_traceback_matrix
+    traverse_score_matrix do |row, col|
+      if 0 == row && 0 == col # top left cell
+        @score_matrix[0][0] = 0
+        @traceback_matrix[0][0] = 'x'
+      elsif 0 == row # first row
+        @score_matrix[0][col] = col * default_gap_penalty
+        @traceback_matrix[0][col] = '←'
+      elsif 0 == col # first col
+        @score_matrix[row][0] = row * default_gap_penalty
+        @traceback_matrix[row][0] = '↑'
+      else # other cells
+        # compute scores
+        from_top = @score_matrix[row-1][col] + default_gap_penalty
+        from_left = @score_matrix[row][col-1] + default_gap_penalty
+        # @left_seq and @top_seq are off by 1 because we added cells for gaps in the matrix
+        from_top_left = @score_matrix[row-1][col-1] + compute_score(@left_seq[row-1], @top_seq[col-1])
+
+        # find max score and direction
+        max, direction = [from_top_left, '⬉']
+        max, direction = [from_top, '↑']  if from_top > max
+        max, direction = [from_left, '←']  if from_left > max
+
+        @score_matrix[row][col] = max
+        @traceback_matrix[row][col] = direction
+      end
+    end
+  end
+
+  def compute_optimal_alignment
+    row = @score_matrix.length-1
+    col = @score_matrix[0].length-1
+    left = Array.new
+    top = Array.new
+    while row > 0 or col > 0
+      if @traceback_matrix[row][col] == '⬉'
+        left.push(@left_seq[row-1])
+        top.push(@top_seq[col-1])
+        row -= 1
+        col -= 1
+      elsif @traceback_matrix[row][col] == '←'
+        left.push(gap_indicator)
+        top.push @top_seq[col-1]
+        col -= 1
+      elsif @traceback_matrix[row][col] == '↑'
+        left.push @left_seq[row-1]
+        top.push(gap_indicator)
+        row -= 1
+      else
+        puts "something strange happened" # this shouldn't happen
+      end
+    end
+    [left.reverse, top.reverse]
+  end
+
+  def traverse_score_matrix
+    @score_matrix.each_index do |row|
+      @score_matrix[row].each_index do |col|
+        yield(row, col)
+      end
+    end
+  end
+
+  def initialize_score_matrix_and_traceback_matrix
+    @score_matrix = Array.new(@left_seq.length + 1)
+    @traceback_matrix = Array.new(@left_seq.length + 1)
+
+    @score_matrix.each_index do |row|
+      @score_matrix[row] = Array.new(@top_seq.length + 1)
+      @traceback_matrix[row] = Array.new(@top_seq.length + 1)
+    end
+  end
+
+end

data/needleman_wunsch_aligner.gemspec

@@ -0,0 +1,22 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'needleman_wunsch_aligner/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "needleman_wunsch_aligner"
+  spec.version       = NeedlemanWunschAligner::VERSION
+  spec.authors       = ["Jo Hund"]
+  spec.email         = ["jhund@clearcove.ca"]
+  spec.summary       = %q{Find the optimal alignment of two sequences of Ruby Objects.}
+  spec.homepage      = "https://github.com/jhund/needleman_wunsch_aligner"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+end

data/spec/needleman_wunsch_aligner/example_paragraph_and_sentence_aligner_spec.rb

@@ -0,0 +1,162 @@
+require 'spec_helper'
+require 'needleman_wunsch_aligner'
+require 'needleman_wunsch_aligner/example_paragraph_and_sentence_aligner'
+require 'pp'
+
+class NeedlemanWunschAligner
+
+  # Container for test data
+  class TestData
+
+    def self.sequence_a
+      [
+        { type: :paragraph, id: 1 },
+        { type: :sentence, id: nil },
+        { type: :sentence, id: nil },
+        { type: :sentence, id: nil },
+        { type: :paragraph, id: 2 },
+        { type: :sentence, id: nil },
+        { type: :sentence, id: nil },
+        { type: :paragraph, id: 3 },
+        { type: :sentence, id: nil },
+        { type: :sentence, id: nil },
+        { type: :sentence, id: nil },
+        { type: :sentence, id: nil },
+      ]
+    end
+
+    def self.sequence_b
+      [
+        { type: :paragraph, id: nil },
+        { type: :sentence, id: nil },
+        { type: :paragraph, id: 1 },
+        { type: :sentence, id: nil },
+        { type: :sentence, id: nil },
+        { type: :paragraph, id: 2 },
+        { type: :sentence, id: nil },
+        { type: :sentence, id: nil },
+        { type: :sentence, id: nil },
+        { type: :sentence, id: nil },
+        { type: :paragraph, id: 3 },
+        { type: :sentence, id: nil },
+        { type: :sentence, id: nil },
+        { type: :sentence, id: nil },
+      ]
+    end
+
+    def self.optimal_alignment
+      [
+        [
+          { type: :gap },
+          { type: :gap },
+          { type: :paragraph, id: 1 },
+          { type: :sentence, id: nil },
+          { type: :sentence, id: nil },
+          { type: :sentence, id: nil },
+          { type: :paragraph, id: 2 },
+          { type: :gap },
+          { type: :gap },
+          { type: :sentence, id: nil },
+          { type: :sentence, id: nil },
+          { type: :paragraph, id: 3 },
+          { type: :sentence, id: nil },
+          { type: :sentence, id: nil },
+          { type: :sentence, id: nil },
+          { type: :sentence, id: nil },
+        ],
+        [
+          { type: :paragraph, id: nil },
+          { type: :sentence, id: nil },
+          { type: :paragraph, id: 1 },
+          { type: :gap },
+          { type: :sentence, id: nil },
+          { type: :sentence, id: nil },
+          { type: :paragraph, id: 2 },
+          { type: :sentence, id: nil },
+          { type: :sentence, id: nil },
+          { type: :sentence, id: nil },
+          { type: :sentence, id: nil },
+          { type: :paragraph, id: 3 },
+          { type: :gap },
+          { type: :sentence, id: nil },
+          { type: :sentence, id: nil },
+          { type: :sentence, id: nil },
+        ]
+      ]
+    end
+
+  end
+
+  describe ExampleParagraphAndSentenceAligner do
+
+    let(:sequence_a){ TestData.sequence_a }
+    let(:sequence_b){ TestData.sequence_b }
+    let(:optimal_alignment){ TestData.optimal_alignment }
+    let(:aligner){ ExampleParagraphAndSentenceAligner.new(sequence_a, sequence_b) }
+
+    describe "#get_optimal_alignment" do
+
+      it "returns the optimal_alignment" do
+        r = aligner.get_optimal_alignment
+        r.must_equal(optimal_alignment)
+      end
+
+    end
+
+    describe "#compute_score" do
+
+      # Test matrix:
+      #         p/1   p/2   p/nil s/a   s/b   s/nil
+      #  p/1    25    -25   -25   -250  -250  -250
+      #  p/2          25    -25   -250  -250  -250
+      #  p/nil              25    -250  -250  -250
+      #  s/a                      10    -10   -10
+      #  s/b                            10    -10
+      #  s/nil                                10
+
+      [
+        [{ type: :paragraph, id: 1 }, { type: :paragraph, id: 1 }, 25],
+        [{ type: :paragraph, id: 1 }, { type: :paragraph, id: 2 }, -25],
+        [{ type: :paragraph, id: 1 }, { type: :paragraph, id: nil }, -25],
+        [{ type: :paragraph, id: 1 }, { type: :sentence, id: :a }, -250],
+        [{ type: :paragraph, id: 1 }, { type: :sentence, id: :b }, -250],
+        [{ type: :paragraph, id: 1 }, { type: :sentence, id: nil }, -250],
+
+        [{ type: :paragraph, id: 2 }, { type: :paragraph, id: 2 }, 25],
+        [{ type: :paragraph, id: 2 }, { type: :paragraph, id: nil }, -25],
+        [{ type: :paragraph, id: 2 }, { type: :sentence, id: :a }, -250],
+        [{ type: :paragraph, id: 2 }, { type: :sentence, id: :b }, -250],
+        [{ type: :paragraph, id: 2 }, { type: :sentence, id: nil }, -250],
+
+        [{ type: :paragraph, id: nil }, { type: :paragraph, id: nil }, 25],
+        [{ type: :paragraph, id: nil }, { type: :sentence, id: :a }, -250],
+        [{ type: :paragraph, id: nil }, { type: :sentence, id: :b }, -250],
+        [{ type: :paragraph, id: nil }, { type: :sentence, id: nil }, -250],
+
+        [{ type: :sentence, id: :a }, { type: :sentence, id: :a }, 10],
+        [{ type: :sentence, id: :a }, { type: :sentence, id: :b }, -10],
+        [{ type: :sentence, id: :a }, { type: :sentence, id: nil }, -10],
+
+        [{ type: :sentence, id: :b }, { type: :sentence, id: :b }, 10],
+        [{ type: :sentence, id: :b }, { type: :sentence, id: nil }, -10],
+
+        [{ type: :sentence, id: nil }, { type: :sentence, id: nil }, 10],
+      ].each do |(left_el, right_el, xpect)|
+
+        it "handles #{ left_el.inspect }:#{ right_el.inspect }" do
+          aligner.send(:compute_score, left_el, right_el).must_equal(xpect)
+        end
+
+      end
+    end
+
+    describe "#default_gap_penalty" do
+
+      it 'returns the expected value' do
+        aligner.send(:default_gap_penalty).must_equal(-10)
+      end
+
+    end
+
+  end
+end

data/spec/needleman_wunsch_aligner_spec.rb

@@ -0,0 +1,93 @@
+# must raise exceptions on overridable methods
+require 'spec_helper'
+require 'needleman_wunsch_aligner'
+
+describe NeedlemanWunschAligner do
+
+  let(:aligner){ NeedlemanWunschAligner.new([], []) }
+
+  describe "#get_optimal_alignment" do
+
+    [
+      [
+        [1,2,3],
+        [1,2,3],
+        [
+          [1,2,3],
+          [1,2,3]
+        ]
+      ],
+      [
+        [1,2,3],
+        [2,3,4],
+        [
+          [  1,2,3,nil],
+          [nil,2,3,4]
+        ]
+      ],
+      [
+        [2],
+        [1,2,3],
+        [
+          [nil,2,nil],
+          [1  ,2,3]
+        ]
+      ],
+      [
+        [1,1,1,1],
+        [2,2,2,2],
+        [
+          [nil,nil,nil,nil,1  ,1  ,1  ,1],
+          [2  ,2  ,2  ,2  ,nil,nil,nil,nil]
+        ]
+      ],
+      [
+        [1,1,1,1],
+        [2,2,2,1],
+        [
+          [nil,nil,nil,1  ,1  ,1  ,1],
+          [2  ,2  ,2  ,nil,nil,nil,1]
+        ]
+      ],
+    ].each do |(seq_a, seq_b, optimal_alignment)|
+
+      it "returns the optimal_alignment" do
+        a = NeedlemanWunschAligner.new(seq_a, seq_b)
+        a.get_optimal_alignment.must_equal(optimal_alignment)
+      end
+
+    end
+
+  end
+
+  describe "#compute_score" do
+
+    [
+      [1, 1, 1],
+      [1, 2, -3],
+    ].each do |(left_el, right_el, xpect)|
+
+      it "handles #{ left_el.inspect }:#{ right_el.inspect }" do
+        aligner.send(:compute_score, left_el, right_el).must_equal(xpect)
+      end
+
+    end
+  end
+
+  describe "#default_gap_penalty" do
+
+    it 'returns the expected value' do
+      aligner.send(:default_gap_penalty).must_equal(-1)
+    end
+
+  end
+
+  describe "#gap_indicator" do
+
+    it 'returns the expected value' do
+      aligner.send(:gap_indicator).must_equal(nil)
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+ENV["RAILS_ENV"] = "test"
+require 'bundler/setup'
+require 'minitest/autorun'
+require 'needleman_wunsch_aligner'
+
+#MiniTest::Unit.autorun

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: needleman_wunsch_aligner
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jo Hund
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- jhund@clearcove.ca
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/needleman_wunsch_aligner.rb
+- lib/needleman_wunsch_aligner/example_paragraph_and_sentence_aligner.rb
+- lib/needleman_wunsch_aligner/version.rb
+- needleman_wunsch_aligner.gemspec
+- spec/needleman_wunsch_aligner/example_paragraph_and_sentence_aligner_spec.rb
+- spec/needleman_wunsch_aligner_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/jhund/needleman_wunsch_aligner
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Find the optimal alignment of two sequences of Ruby Objects.
+test_files:
+- spec/needleman_wunsch_aligner/example_paragraph_and_sentence_aligner_spec.rb
+- spec/needleman_wunsch_aligner_spec.rb
+- spec/spec_helper.rb