phonetics 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c1ad0894f34019de351475721cfba624c2873944993e82db0e72ee7dd6aef374
+  data.tar.gz: 4590f9791a8409e9ef380949cc675c75507864050e72f616d4b3ac99f4dc4439
+SHA512:
+  metadata.gz: 60af744c78500372afb02dd22fdc1066cc7d2e83ab218eed798ff7d96f101cbc112eb0b19c6a694ec83d79e891c5ea41e0d8cda26ad5aab209aa87aed3ba9f2e
+  data.tar.gz: 971566027a0b60cfad064f7c54c871a94830dae6c3210c77c306b31dbe0410c2687415c87686caecf9dd065812b3027b7bc6c48b69ec7fee3b01c56bfeff2644

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.5.1
+before_install: gem install bundler -v 1.16.2

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at github@jackcanty.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in phonetics.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,35 @@
+PATH
+  remote: .
+  specs:
+    phonetics (1.0.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.3)
+    rake (12.3.2)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.16)
+  phonetics!
+  rake
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   1.16.2

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Jack Danger
+
+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,14 @@
+# Phonetics
+
+
+
+
+## Contributing
+
+Patches welcome, forks celebrated.
+
+Everyone interacting in the Phonetics project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/JackDanger/phonetics/blob/master/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the wide-open terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/lib/phonetic_levenshtein.rb

@@ -0,0 +1,103 @@
+require_relative './phonetics'
+
+# Using the Damerau version of the Levenshtein algorithm, with phonetic feature
+# count used instead of a binary edit distance calculation
+#
+# This implementation is almost entirely taken from the damerau-levenshtein gem
+# (https://github.com/GlobalNamesArchitecture/damerau-levenshtein/tree/master/ext/damerau_levenshtein).
+# The implementation is modified based on "Using Phonologically Weighted
+# Levenshtein Distances for the Prediction of Microscopic Intelligibility" by
+# Lionel Fontan, Isabelle Ferrané, Jérôme Farinas, Julien Pinquier, Xavier
+# Aumont, 2016
+# https://hal.archives-ouvertes.fr/hal-01474904/document
+class PhoneticLevenshtein
+  def initialize(ipa_str1, ipa_str2)
+    @str1 = ipa_str1
+    @str2 = ipa_str2
+    @len1 = ipa_str1.size
+    @len2 = ipa_str2.size
+    prepare_matrix
+    set_edit_distances(ipa_str1, ipa_str2)
+  end
+
+  def distance
+    walk.last[:distance]
+  end
+
+  def self.distance(str1, str2)
+    new(str1, str2).distance
+  end
+
+  private
+
+  def walk
+    res = []
+    cell = [@len2, @len1]
+    while cell != [0, 0]
+      cell, char = char_data(cell)
+      res.unshift char
+    end
+    res
+  end
+
+  def set_edit_distances(str1, str2)
+    (1..@len2).each do |i|
+      (1..@len1).each do |j|
+        no_change(i, j) && next if str2[i - 1] == str1[j - 1]
+        @matrix[i][j] = [del(i, j) + 1.0, ins(i, j) + 1.0, subst(i, j)].min
+      end
+    end
+  end
+
+  def char_data(cell)
+    char = { distance: @matrix[cell[0]][cell[1]] }
+    val = find_previous(cell)
+    previous_value = val[0][0]
+    char[:type] = previous_value == char[:distance] ? :same : val[1]
+    cell = val.pop
+    [cell, char]
+  end
+
+  def find_previous(cell)
+    candidates = [[[ins(*cell), 1], :ins, [cell[0], cell[1] - 1]],
+                  [[del(*cell), 2], :del, [cell[0] - 1, cell[1]]],
+                  [[subst(*cell), 0], :subst, [cell[0] - 1, cell[1] - 1]]]
+    select_cell(candidates)
+  end
+
+  def select_cell(candidates)
+    candidates.select { |e| e[-1][0] >= 0 && e[-1][1] >= 0 }.
+      sort_by(&:first).first
+  end
+
+  # TODO: Score the edit distance lower if sonorant sounds are found in sequence.
+  def del(i, j)
+    @matrix[i - 1][j]
+  end
+
+  def ins(i, j)
+    @matrix[i][j - 1]
+  end
+
+  # This is where we implement the modifications to Damerau-Levenshtein according to
+  # https://hal.archives-ouvertes.fr/hal-01474904/document
+  def subst(i, j)
+    map = Phonetics.distance_map[@str1[j]]
+    score = map[@str2[i]] if map
+    score ||= 1.0
+    @matrix[i - 1][j - 1] + score
+  end
+
+  def no_change(i, j)
+    @matrix[i][j] = @matrix[i - 1][j - 1]
+  end
+
+  def prepare_matrix
+    @matrix = []
+    @matrix << (0..@len1).to_a
+    @len2.times do |i|
+      ary = [i + 1] + (1..@len1).map { nil }
+      @matrix << ary
+    end
+  end
+end

data/lib/phonetics/version.rb

@@ -0,0 +1,3 @@
+module Phonetics
+  VERSION = File.read(File.join(File.dirname(__FILE__), '../../VERSION')).chomp
+end

data/lib/phonetics.rb

@@ -0,0 +1,246 @@
+require 'delegate'
+
+module Phonetics
+  extend self
+
+  # This subclass of the stdlib's String allows us to iterate over each phoneme
+  # in a string without monkeypatching
+  #
+  # Usage:
+  #   Phonetics::String.new("wətɛvɝ").each_phoneme.to_a
+  #   => ["w", "ə", "t", "ɛ", "v", "ɝ"]
+  class String < SimpleDelegator
+
+    # Group all phonemes by how many characters they have. Use this to walk
+    # through a string finding phonemes (looking for longest ones first)
+    def self.phonemes_by_length
+      @phonemes_by_length ||= Phonetics.phonemes.each_with_object(
+        # This relies on the impicit stable key ordering of Hash objects in Ruby
+        # 2+ to keep the keys in descending order.
+        4 => Set.new, 3 => Set.new, 2 => Set.new, 1 => Set.new
+      ) do |str, acc|
+        acc[str.chars.size] << str
+      end
+    end
+
+    def each_phoneme
+      idx = 0
+      Enumerator.new do |y|
+        while idx < chars.length
+          found = false
+          self.class.phonemes_by_length.each do |size, phonemes|
+            if idx + size <= chars.length
+              candidate = chars[idx..idx+size-1].join
+              if phonemes.include?(candidate)
+                y.yield candidate
+                idx += size
+                found = true
+                break
+              else
+              end
+            end
+          end
+          idx += 1 unless found
+        end
+      end
+    end
+  end
+
+  module Vowels
+    extend self
+
+    FormantFrequencies = {
+      # https://en.wikipedia.org/wiki/Formant#Phonetics
+      'i' => { F1: 240, F2: 2400, rounded: false },
+      'y' => { F1: 235, F2: 2100, rounded: false },
+      'ɪ' => { F1: 300, F2: 2100, rounded: false }, # Guessing From other vowels
+      'e' => { F1: 390, F2: 2300, rounded: false },
+      'ø' => { F1: 370, F2: 1900, rounded: true },
+      'ɛ' => { F1: 610, F2: 1900, rounded: false },
+      'œ' => { F1: 585, F2: 1710, rounded: true },
+      'a' => { F1: 850, F2: 1610, rounded: false },
+      'ɶ' => { F1: 820, F2: 1530, rounded: true },
+      'ɑ' => { F1: 750, F2: 940,  rounded: false },
+      'ɒ' => { F1: 700, F2: 760,  rounded: true },
+
+      'ʌ' => { F1: 600, F2: 1170, rounded: false },
+      # copying 'ʌ' for other mid-vowel formants
+      'ə' => { F1: 600, F2: 1170, rounded: false },
+      'ɝ' => { F1: 600, F2: 1170, rounded: false, rhotic: true },
+
+      'ɔ' => { F1: 500, F2: 700,  rounded: true },
+      'ɤ' => { F1: 460, F2: 1310, rounded: false },
+      'o' => { F1: 360, F2: 640,  rounded: true },
+      'ɯ' => { F1: 300, F2: 1390, rounded: false },
+      'æ' => { F1: 800, F2: 1900, rounded: false }, # Guessing From other vowels
+      'u' => { F1: 350, F2: 650,  rounded: true }, # Guessing From other vowels
+      'ʊ' => { F1: 350, F2: 650,  rounded: true },
+      # Frequencies from http://videoweb.nie.edu.sg/phonetic/vowels/measurements.html
+    }
+
+    def phonemes
+      @phonemes ||= FormantFrequencies.keys
+    end
+
+    # Given two vowels, calculate the (pythagorean) distance between them using
+    # their F1 and F2 frequencies as x/y coordinates.
+    # The return value is scaled to a value between 0 and 1
+    # TODO: account for rhoticity (F3)
+    def distance(phoneme1, phoneme2)
+      formants1 = FormantFrequencies.fetch(phoneme1)
+      formants2 = FormantFrequencies.fetch(phoneme2)
+
+      @minmax_f1 ||= FormantFrequencies.values.minmax {|a, b| a[:F1] <=> b[:F1] }.map {|h| h[:F1] }
+      @minmax_f2 ||= FormantFrequencies.values.minmax {|a, b| a[:F2] <=> b[:F2] }.map {|h| h[:F2] }
+
+      # Get an x and y value for each input phoneme scaled between 0.0 and 1.0
+      # We'll use the scaled f1 as the 'x' and the scaled f2 as the 'y'
+      scaled_phoneme1_f1 = (formants1[:F1] - @minmax_f1[0]) / @minmax_f1[1].to_f
+      scaled_phoneme1_f2 = (formants1[:F2] - @minmax_f2[0]) / @minmax_f2[1].to_f
+      scaled_phoneme2_f1 = (formants2[:F1] - @minmax_f1[0]) / @minmax_f1[1].to_f
+      scaled_phoneme2_f2 = (formants2[:F2] - @minmax_f2[0]) / @minmax_f2[1].to_f
+
+      f1_distance = (scaled_phoneme1_f1 - scaled_phoneme2_f1).abs
+      f2_distance = (scaled_phoneme1_f2 - scaled_phoneme2_f2).abs
+
+      # When we have four values we can use the pythagorean theorem on them
+      # (order doesn't matter)
+      Math.sqrt((f1_distance ** 2) + (f2_distance ** 2))
+    end
+  end
+
+  module Consonants
+    extend self
+
+    # Plosives and fricatives are less similar than trills and flaps, or
+    # sibilant fricatives and non-sibilant fricatives
+    # TODO: this is unfinished and possibly a bad idea
+    MannerDistances = {
+      'Nasal'                  => %w[continuant],
+      'Stop'                   => %w[],
+      'Sibilant fricative'     => %w[continuant fricative],
+      'Non-sibilant fricative' => %w[continuant non_sibilant fricative],
+      'Approximant'            => %w[],
+      'Tap/Flap'               => %w[],
+      'Trill'                  => %w[],
+      'Lateral fricative'      => %w[continuant fricative],
+      'Lateral approximant'    => %w[],
+      'Lateral tap/flap'       => %w[],
+    }.freeze
+
+    # This chart (columns 2 through the end, anyway) is a direct port of
+    # https://en.wikipedia.org/wiki/International_Phonetic_Alphabet#Letters
+    # We # store the consonant table in this format to make updating it easier.
+    ChartData = %Q{          | Labio-velar | Bi-labial | Labio-dental | Linguo-labial | Dental | Alveolar | Post-alveolar | Retro-flex | Palatal | Velar | Uvular | Pharyngeal | Glottal
+      Nasal                  |             | m̥  m      |    ɱ         |    n̼          |        | n̥  n     |               | ɳ̊  ɳ       | ɲ̊  ɲ    | ŋ̊  ŋ  |    ɴ   |            |        
+      Stop                   |             | p  b      | p̪  b̪         | t̼  d̼          |        | t  d     |               | ʈ  ɖ       | c  ɟ    | k  g  | q  ɢ   | ʡ          | ʔ      
+      Sibilant fricative     |             |           |              |               |        | s  z     | ʃ  ʒ          | ʂ  ʐ       | ɕ  ʑ    |       |        |            |        
+      Non-sibilant fricative |             | ɸ  β      | f  v         | θ̼  ð̼          | θ  ð   | θ̠  ð̠     | ɹ̠̊˔ ɹ̠˔         |    ɻ˔      | ç  ʝ    | x  ɣ  | χ  ʁ   | ħ  ʕ       | h  ɦ   
+      Approximant            |   w         |           | ʋ̥  ʋ         |               |        | ɹ̥  ɹ     |               | ɻ̊  ɻ       | j̊  j    | ɰ̊  ɰ  |        |            |    ʔ̞   
+      Tap/flap               |             |    ⱱ̟      |    ⱱ         |    ɾ̼          |        | ɾ̥  ɾ     |               | ɽ̊  ɽ       |         |       |    ɢ̆   |    ʡ̆       |        
+      Trill                  |             | ʙ̥  ʙ      |              |               |        | r̥  r     |               |            |         |       | ʀ̥  ʀ   | ʜ  ʢ       |        
+      Lateral fricative      |             |           |              |               |        | ɬ  ɮ     |               | ɭ̊˔ ɭ˔      | ʎ̝̊  ʎ̝    | ʟ̝̊  ʟ̝  |        |            |        
+      Lateral approximant    |             |           |              |               |        | l̥  l     |               | ɭ̊  ɭ       | ʎ̥  ʎ    | ʟ̥  ʟ  |    ʟ̠   |            |        
+      Lateral tap/flap       |             |           |              |               |        |    ɺ     |               |    ɭ̆       |    ʎ̆    |    ʟ̆  |        |            |         
+    }
+
+    # Parse the ChartData into a lookup table where we can retrieve attributes
+    # for each phoneme
+    def features
+      @features ||= begin 
+        header, *manners = ChartData.lines
+
+        _, *positions = header.chomp.split(' | ')
+        positions.map(&:strip!)
+
+        # Remove any trailing blank lines
+        manners.pop while manners.last.to_s.strip.empty?
+
+        position_indexes = Hash[*positions.each_with_index.to_a.flatten]
+
+        @position_count = positions.size
+
+        manners.each_with_object({}) do |row, phonemes|
+          manner, *columns = row.chomp.split(' | ')
+          manner.strip!
+          positions.zip(columns).each do |position, phoneme_text|
+            data = {
+              position: position,
+              position_index: position_indexes[position],
+              manner: manner,
+            }
+            # If there is a character in the first byte then this articulation
+            # has a voiceless phoneme. The symbol may use additional characters
+            # as part of the phoneme symbol.
+            unless phoneme_text[0] == ' '
+              # Take the first non-blank character string
+              symbol = phoneme_text.chars.take_while { |char| char != ' ' }.join
+              phoneme_text = phoneme_text[symbol.chars.size..-1]
+
+              phonemes[symbol] = data.merge(voiced: false)
+            end
+            # If there's a character anywhere left in the string then this
+            # articulation has a voiced phoneme
+            unless phoneme_text.strip.empty?
+              symbol = phoneme_text.strip
+              phonemes[symbol] = data.merge(voiced: true)
+            end
+          end
+        end
+      end
+    end
+
+    def phonemes
+      @phonemes ||= features.keys
+    end
+
+    # Given two consonants, calculate their difference by summing the
+    # following:
+    #   * 0.1 if they are not voiced the same
+    #   * 0.3 if they are different manners
+    #   * Up to 0.6 if they are the maximum position difference
+    def distance(phoneme1, phoneme2)
+      features1 = features[phoneme1]
+      features2 = features[phoneme2]
+
+      penalty = 0
+      penalty += 0.1 if features1[:voiced] != features2[:voiced]
+
+      penalty += 0.3 if features1[:manner] != features2[:manner]
+
+      # Use up to the remaining 0.6 for penalizing differences in manner
+      penalty += 0.6 * ((features1[:position_index] - features2[:position_index]).abs / @position_count.to_f)
+      penalty
+    end
+  end
+
+  def phonemes
+    Consonants.phonemes + Vowels.phonemes
+  end
+
+  Symbols = Consonants.phonemes.reduce({}) {|acc, p| acc.update p => :consonant }.merge(
+    Vowels.phonemes.reduce({}) { |acc, p| acc.update p => :vowel }
+  )
+
+  def distance(phoneme1, phoneme2)
+    types = [Symbols.fetch(phoneme1), Symbols.fetch(phoneme2)].sort
+    if types == [:consonant, :vowel]
+      1.0
+    elsif types == [:vowel, :vowel]
+      Vowels.distance(phoneme1, phoneme2)
+    elsif types == [:consonant, :consonant]
+      Consonants.distance(phoneme1, phoneme2)
+    end
+  end
+
+  def distance_map
+    @distance_map ||= (
+      Vowels.phonemes + Consonants.phonemes
+    ).permutation(2).each_with_object(Hash.new { |h, k| h[k] = {} } ) do |pair, scores|
+      p1, p2 = *pair
+      score = distance(p1, p2)
+      scores[p1][p2] = score
+      scores[p2][p1] = score
+    end
+  end
+end

data/phonetics.gemspec

@@ -0,0 +1,22 @@
+Gem::Specification.new do |spec|
+  spec.name          = "phonetics"
+  spec.version       = File.read(File.join(File.dirname(__FILE__), './VERSION'))
+  spec.authors       = ["Jack Danger"]
+  spec.email         = ["github@jackcanty.com"]
+
+  spec.summary       = %q{tools for linguistic code using the International Phonetic Alphabet}
+  spec.description   = %q{tools for linguistic code using the International Phonetic Alphabet}
+  spec.homepage      = "https://github.com/JackDanger/phonetics"
+  spec.license       = "MIT"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: phonetics
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jack Danger
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-04-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: tools for linguistic code using the International Phonetic Alphabet
+email:
+- github@jackcanty.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- lib/phonetic_levenshtein.rb
+- lib/phonetics.rb
+- lib/phonetics/version.rb
+- phonetics.gemspec
+homepage: https://github.com/JackDanger/phonetics
+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.7.6
+signing_key: 
+specification_version: 4
+summary: tools for linguistic code using the International Phonetic Alphabet
+test_files: []