phonology 0.0.1

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2010 Norman Clarke
+
+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,5 @@
+# Phonology
+
+Some phonology utilities for Ruby. In progress, so no documentation yet.
+
+To see some of the things you can do, take a peek at the tests.

data/lib/phonology/features.rb

@@ -0,0 +1,182 @@
+module Phonology
+
+  # Raised for any attempt to access an invalid feature.
+  class FeatureError < StandardError; end
+
+  # Distinctive features.
+  module Features
+
+    # Pulmonic consonants
+    PULMONIC = [:nasal, :plosive, :fricative, :approximant, :trill, :flap,
+      :lateral, :bilabial, :labiodental, :dental, :alveolar, :postalveolar,
+      :retroflex, :palatal, :velar, :uvular, :pharyngeal, :epiglottal, :glottal]
+
+    # Non-pulmonic consonants
+    NON_PULMONIC = [:click, :implosive, :ejective]
+
+    # Vocalic features
+    VOCALIC = [:close, :near_close, :close_mid, :mid, :open_mid, :near_open, :open,
+      :front, :near_front, :central, :near_back, :back, :rounded]
+
+    # Consontal features
+    CONSONANTAL = (PULMONIC + NON_PULMONIC).to_set
+
+    # All features classes
+    ALL = ([:voiced] + PULMONIC + NON_PULMONIC + VOCALIC).to_set
+
+    # Manner of articulation features
+    MANNER = [:nasal, :plosive, :fricative, :approximant, :trill, :flap, :lateral] + NON_PULMONIC
+
+    # Place of articulation features
+    PLACE = CONSONANTAL.to_a - MANNER
+
+    # Vowel height
+    HEIGHT = [:close, :near_close, :close_mid, :mid, :open_mid, :near_open, :open]
+
+    # Vowel backness
+    BACKNESS = (VOCALIC.to_set - HEIGHT - [:rounded])
+
+    # Feature classes
+    CLASSES = {
+      :labial       => [:bilabial, :labiodental].to_set,
+      :coronal      => [:dental, :alveolar, :postalveolar, :retroflex].to_set,
+      :dorsal       => [:palatal, :velar, :uvular].to_set,
+      :radical      => [:pharyngeal, :epiglottal].to_set,
+      :vocalic      => VOCALIC + [:rounded],
+      :non_pulmonic => NON_PULMONIC,
+      :pulmonic     => PULMONIC,
+      :consonantal  => CONSONANTAL
+    }
+
+    # Sets of distinctive features mapped to an IPA symbol
+    SETS = {
+      [:voiced, :bilabial, :nasal].to_set                     => [0x006d],
+      [:voiced, :labiodental, :nasal].to_set                  => [0x0271],
+      [:voiced, :alveolar, :nasal].to_set                     => [0x006e],
+      [:voiced, :retroflex, :nasal].to_set                    => [0x0273],
+      [:voiced, :palatal, :nasal].to_set                      => [0x0272],
+      [:voiced, :velar, :nasal].to_set                        => [0x014b],
+      [:voiced, :uvular, :nasal].to_set                       => [0x0274],
+      [:bilabial, :plosive].to_set                            => [0x0070],
+      [:voiced, :bilabial, :plosive].to_set                   => [0x0062],
+      [:labiodental, :plosive].to_set                         => [0x0070, 0x032a],
+      [:voiced, :labiodental, :plosive].to_set                => [0x0062, 0x032a],
+      [:alveolar, :plosive].to_set                            => [0x0074],
+      [:voiced, :alveolar, :plosive].to_set                   => [0x0064],
+      [:retroflex, :plosive].to_set                           => [0x0288],
+      [:voiced, :retroflex, :plosive].to_set                  => [0x0256],
+      [:palatal, :plosive].to_set                             => [0x0063],
+      [:voiced, :palatal, :plosive].to_set                    => [0x025f],
+      [:velar, :plosive].to_set                               => [0x006b],
+      [:voiced, :velar, :plosive].to_set                      => [0x0261],
+      [:uvular, :plosive].to_set                              => [0x0071],
+      [:voiced, :uvular, :plosive].to_set                     => [0x0262],
+      [:voiced, :epiglottal, :plosive].to_set                 => [0x02a1],
+      [:voiced, :glottal, :plosive].to_set                    => [0x0294],
+      [:bilabial, :fricative].to_set                          => [0x0278],
+      [:voiced, :bilabial, :fricative].to_set                 => [0x03b2],
+      [:labiodental, :fricative].to_set                       => [0x0066],
+      [:voiced, :labiodental, :fricative].to_set              => [0x0076],
+      [:dental, :fricative].to_set                            => [0x03b8],
+      [:voiced, :dental, :fricative].to_set                   => [0x00f0],
+      [:alveolar, :fricative].to_set                          => [0x0073],
+      [:voiced, :alveolar, :fricative].to_set                 => [0x007a],
+      [:postalveolar, :fricative].to_set                      => [0x0283],
+      [:voiced, :postalveolar, :fricative].to_set             => [0x0292],
+      [:retroflex, :fricative].to_set                         => [0x0282],
+      [:voiced, :retroflex, :fricative].to_set                => [0x0290],
+      [:palatal, :fricative].to_set                           => [0x00e7],
+      [:voiced, :palatal, :fricative].to_set                  => [0x029d],
+      [:velar, :fricative].to_set                             => [0x0078],
+      [:voiced, :velar, :fricative].to_set                    => [0x0263],
+      [:uvular, :fricative].to_set                            => [0x03c7],
+      [:voiced, :uvular, :fricative, :approximant].to_set     => [0x0281],
+      [:pharyngeal, :fricative].to_set                        => [0x0127],
+      [:voiced, :pharyngeal, :fricative, :approximant].to_set => [0x0295],
+      [:epiglottal, :fricative].to_set                        => [0x029c],
+      [:voiced, :epiglottal, :fricative, :approximant].to_set => [0x02a2],
+      [:glottal, :fricative, :approximant].to_set             => [0x0068],
+      [:voiced, :glottal, :fricative, :approximant].to_set    => [0x0266],
+      [:voiced, :bilabial, :approximant].to_set               => [0x03b2, 0x031e],
+      [:voiced, :labiodental, :approximant].to_set            => [0x028b],
+      [:voiced, :alveolar, :approximant].to_set               => [0x0279],
+      [:voiced, :retroflex, :approximant].to_set              => [0x027b],
+      [:voiced, :palatal, :approximant].to_set                => [0x006a],
+      [:voiced, :velar, :approximant].to_set                  => [0x0270],
+      [:voiced, :bilabial, :trill].to_set                     => [0x0299],
+      [:voiced, :alveolar, :trill].to_set                     => [0x0072],
+      [:voiced, :uvular, :trill].to_set                       => [0x0280],
+      [:voiced, :epiglottal, :trill].to_set                   => [0x044f],
+      [:voiced, :bilabial, :flap].to_set                      => [0x2c71, 0x031f],
+      [:voiced, :labiodental, :flap].to_set                   => [0x2c71],
+      [:voiced, :alveolar, :flap].to_set                      => [0x027e],
+      [:voiced, :retroflex, :flap].to_set                     => [0x027d],
+      [:voiced, :uvular, :flap].to_set                        => [0x0262, 0x0306],
+      [:voiced, :epiglottal, :flap].to_set                    => [0x02a1, 0x032f],
+      [:alveolar, :lateral, :fricative].to_set                => [0x026c],
+      [:voiced, :alveolar, :lateral, :fricative].to_set       => [0x026e],
+      [:voiced, :alveolar, :lateral, :approximant].to_set     => [0x006c],
+      [:voiced, :retroflex, :lateral, :approximant].to_set    => [0x026d],
+      [:voiced, :palatal, :lateral, :approximant].to_set      => [0x028e],
+      [:voiced, :velar, :lateral, :approximant].to_set        => [0x029f],
+      [:voiced, :alveolar, :lateral, :flap].to_set            => [0x027a],
+      [:voiced, :palatal, :lateral, :flap].to_set             => [0x028e, 0x032f],
+      [:voiced, :velar, :lateral, :flap].to_set               => [0x029f, 0x0306],
+      [:voiced, :close, :front].to_set                        => [0x0069],
+      [:voiced, :close, :front, :rounded].to_set              => [0x0079],
+      [:voiced, :close, :central].to_set                      => [0x0268],
+      [:voiced, :close, :central, :rounded].to_set            => [0x0289],
+      [:voiced, :close, :back].to_set                         => [0x026f],
+      [:voiced, :close, :back, :rounded].to_set               => [0x0075],
+      [:voiced, :near_close, :near_front].to_set              => [0x026a],
+      [:voiced, :near_close, :near_front, :rounded].to_set    => [0x028f],
+      [:voiced, :near_close, :near_back, :rounded].to_set     => [0x028a],
+      [:voiced, :close_mid, :front].to_set                    => [0x0065],
+      [:voiced, :close_mid, :front, :rounded].to_set          => [0x00f8],
+      [:voiced, :close_mid, :central].to_set                  => [0x0258],
+      [:voiced, :close_mid, :central, :rounded].to_set        => [0x0275],
+      [:voiced, :close_mid, :back].to_set                     => [0x0264],
+      [:voiced, :close_mid, :back, :rounded].to_set           => [0x006f],
+      [:voiced, :mid, :central].to_set                        => [0x0259],
+      [:voiced, :open_mid, :front].to_set                     => [0x025b],
+      [:voiced, :open_mid, :front, :rounded].to_set           => [0x0153],
+      [:voiced, :open_mid, :central].to_set                   => [0x025c],
+      [:voiced, :open_mid, :central, :rounded].to_set         => [0x025e],
+      [:voiced, :open_mid, :back].to_set                      => [0x028c],
+      [:voiced, :open_mid, :back, :rounded].to_set            => [0x0254],
+      [:voiced, :near_open, :front].to_set                    => [0x00e6],
+      [:voiced, :near_open, :central].to_set                  => [0x0250],
+      [:voiced, :open, :front].to_set                         => [0x0061],
+      [:voiced, :open, :front, :rounded].to_set               => [0x0276],
+      [:voiced, :open, :back].to_set                          => [0x0251],
+      [:voiced, :open, :back, :rounded].to_set                => [0x0252],
+      # This char will appear in Unicode 6.0
+      [:voiced, :retroflex, :lateral, :fricative].to_set      => [0xa78e],
+      # Not in UTF-8; used in SIL International's Charis/Doulos font's private
+      # use area
+      [:voiced, :palatal, :lateral, :fricative].to_set        => [0xf267],
+      [:voiced, :velar, :lateral, :fricative].to_set          => [0xf268],
+      [:voiced, :retroflex, :lateral, :flap].to_set           => [0xf269]
+    }
+
+    class << self
+      # Return the set corresponding to the kind of feature: manner or place of
+      # articulation, or height or backness.
+      def set(feature)
+        [MANNER, PLACE, BACKNESS, HEIGHT].each {|kind| return kind if kind.include? feature}
+        nil
+      end
+
+      # Given a Ruby :symbol feature class such as :coronal, return the
+      # corresponding features. If a single feature is given, just return the
+      # feature.
+      def expand(*args)
+        args = args.inject([].to_set) do |memo, obj|
+          memo << (CLASSES[obj] || obj)
+        end.flatten.to_set
+      end
+
+    end
+
+  end
+end

data/lib/phonology/sound.rb

@@ -0,0 +1,103 @@
+module Phonology
+
+  # A set of distinctive features
+  class Sound
+
+    attr_reader :features
+
+    def initialize(*features)
+      @features = if features.first.kind_of?(String)
+        Phonology.features(features.shift)
+      else
+        features.to_set
+      end
+    end
+
+    Features::ALL.each do |feature|
+      class_eval(<<-EOM, __FILE__, __LINE__ +1)
+        def #{feature}?
+          @features.include? :#{feature}
+        end
+      EOM
+    end
+
+    Features::CLASSES.each do |feature_class, values|
+      class_eval(<<-EOM, __FILE__, __LINE__ +1)
+        def #{feature_class}?
+          set = Features.expand(:#{feature_class})
+          !set.intersection(@features).empty?
+        end
+      EOM
+    end
+
+    # Get the IPA symbol for the sound.
+    def symbol
+      Phonology.symbol(features)
+    end
+
+    # Add a feature, replacing either the place or manner of articulation,
+    # or the height or backness. Returns self.
+    def <<(feature)
+      feature = feature.to_sym
+      (@features -= (Features.set(feature) || [])) << feature
+      self
+    end
+    alias add <<
+
+    # Remove a feature, and return self.
+    def >>(feature)
+      @features -= [feature.to_sym]
+      self
+    end
+
+    # Get the next sound, moving backwards in the mouth.
+    def backward
+      if consonantal?
+        index = Features::PLACE.index(place.first)
+        max = Features::PLACE.length
+        features = @features - Features::PLACE
+        until index > max do
+          index = index + 1
+          feature = Features::PLACE[index]
+          if self.class.exists?(features + [feature])
+            @features = features + [feature]
+            return self
+          end
+        end
+      end
+      self
+    end
+
+    def forward
+    end
+
+    # Get the sound's place of articulation.
+    def place
+      @features.intersection(Features::PLACE)
+    end
+
+    # Get the sound's manner of articulation.
+    def manner
+      @features.intersection(Features::MANNER)
+    end
+
+    # Get the sound's height.
+    def height
+      @features.intersection(Features::HEIGHT)
+    end
+
+    # Get the sound's backness.
+    def backness
+      @features.intersection(Features::BACKNESS)
+    end
+
+    def exists?
+      self.class.exists?(@features)
+    end
+
+    def self.exists?(features)
+      !! Features::SETS[features]
+    end
+
+  end
+end

data/lib/phonology/sounds.rb

@@ -0,0 +1,69 @@
+module Phonology
+
+  # An inventory of Phonological feature sets.
+  class Sounds
+
+    # A Hash with a set of features as keys, and UTF-8 codepoints for IPA
+    # letters as values.
+    attr :sets
+
+    # Get an instance, building its set from a list IPA characters.
+    def self.from_ipa(*chars)
+      chars = chars.flatten.map {|char| char.unpack("U*")}
+      new Features::SETS.select {|key, val| chars.include? val}
+    end
+
+    def initialize(sets)
+      @sets = sets
+    end
+
+    # Given an IPA symbol, return a corresponding set of distinctive features.
+    def features(symbol)
+      @sets.key(symbol.unpack("U*"))
+    end
+
+    # Given a set of features, return an IPA symbol
+    def symbol(*features)
+      codepoints(features).pack("U*")
+    end
+
+    def symbols
+      @sets.values.map {|symbol| symbol.pack("U*")}.to_set
+    end
+
+    # Given a set of features, return an array of UTF-8 codepoints.
+    def codepoints(features)
+      features = features.to_set.flatten
+      @sets[features] || (raise FeatureError, "No such set #{features.inspect}")
+    end
+
+    # Return an instance of Sounds whose sets include any of the given
+    # features.
+    def with(*features)
+      features = features.to_set
+      self.class.new @sets.select {|key, val| !key.intersection(features).empty?}
+    end
+
+    # Return feature sets that include all of the given features
+    def with_all(*features)
+      features = features.to_set
+      self.class.new @sets.select {|key, val| features.subset?(key)}
+    end
+
+    # Return an instance of Sounds whose sets exclude any of the given
+    # features.
+    def without(*features)
+      features = features.to_set
+      self.class.new @sets.select {|key, val| !features.subset?(key)}
+    end
+
+    # Return an instance of Sounds whose sets exclude all of the given
+    # features.
+    def without_any(*features)
+      features = features.to_set
+      self.class.new @sets.select {|key, val| key.intersection(features).empty?}
+    end
+
+  end
+
+end

data/lib/phonology/version.rb

@@ -0,0 +1,3 @@
+module Phonology
+  VERSION = "0.0.1"
+end

data/lib/phonology.rb

@@ -0,0 +1,22 @@
+require "set"
+require File.expand_path("../phonology/features", __FILE__)
+require File.expand_path("../phonology/sounds", __FILE__)
+require File.expand_path("../phonology/sound", __FILE__)
+
+module Phonology
+
+  extend self
+
+  def sounds
+    @sounds ||= Sounds.new Features::SETS
+  end
+
+  def symbol(*args)
+    sounds.symbol(*args)
+  end
+
+  def features(*args)
+    sounds.features(*args)
+  end
+
+end

data/test/features_test.rb

@@ -0,0 +1,10 @@
+require File.expand_path("../test_helper", __FILE__)
+
+class FeaturesTest < Test::Unit::TestCase
+
+  test "should expand feature groups" do
+    assert_equal [:dental, :alveolar, :postalveolar, :retroflex, :velar].to_set,
+        Phonology::Features.expand(:coronal, :dental, :velar)
+  end
+
+end

data/test/phonology_test.rb

@@ -0,0 +1,17 @@
+require File.expand_path("../test_helper", __FILE__)
+
+class PhonologyTest < Test::Unit::TestCase
+
+  test "sounds should return an instance of Sounds" do
+    assert_equal Phonology::Sounds, Phonology.sounds.class
+  end
+
+  test "should return feature set for symbol" do
+    assert_equal [:voiced, :bilabial, :nasal].to_set, Phonology.features("m")
+  end
+
+  test "should return a symbol for a feature set" do
+    assert_equal "d", Phonology.symbol(:voiced, :alveolar, :plosive)
+  end
+
+end

data/test/sound_test.rb

@@ -0,0 +1,84 @@
+require File.expand_path("../test_helper", __FILE__)
+
+class SoundTest < Test::Unit::TestCase
+
+  include Phonology
+
+  test "should return an IPA symbol" do
+    assert_equal "m", Sound.new(:voiced, :bilabial, :nasal).symbol
+  end
+
+  test "should instantiate from IPA symbol" do
+    assert_equal [:voiced, :bilabial, :nasal].to_set, Sound.new("m").features
+  end
+
+  test "should indicate individual features" do
+    assert Sound.new("n").nasal?
+  end
+
+  test "should indicate feature classes" do
+    assert Sound.new("n").coronal?
+    assert Sound.new("n").consonantal?
+    assert !Sound.new("n").vocalic?
+  end
+
+  test "should add/remove voice" do
+    sound = Sound.new("p")
+    sound << :voiced
+    assert_equal "b", sound.symbol
+    sound >> :voiced
+    assert_equal "p", sound.symbol
+  end
+
+  test "should add/remove rounding" do
+    sound = Sound.new("a")
+    sound << :rounded
+    assert_equal "\u0276", sound.symbol
+    sound >> :rounded
+    assert_equal "a", sound.symbol
+  end
+
+  test "should change manner of articulation" do
+    sound = Sound.new("m")
+    sound << :plosive
+    assert_equal "b", sound.symbol
+  end
+
+  test "should change place of articulation" do
+    assert_equal "n", Sound.new("m").add(:alveolar).symbol
+  end
+
+  test "should change backness" do
+    assert_equal "u", Sound.new("y").add(:back).symbol
+  end
+
+  test "should change height" do
+    assert_equal "i", Sound.new("a").add(:close).symbol
+  end
+
+  test "should get place of articulation" do
+    assert_equal :alveolar, Sound.new("r").place.first
+  end
+
+  test "should get manner of articulation" do
+    assert_equal :trill, Sound.new("r").manner.first
+  end
+
+  test "should get height" do
+    assert_equal :close_mid, Sound.new("e").height.first
+  end
+
+  test "should get backness" do
+    assert_equal :front, Sound.new("e").backness.first
+  end
+
+  test "should indicate if sound exists" do
+    assert !Sound.new(:front, :plosive).exists?
+    assert Sound.new(:bilabial, :plosive).exists?
+  end
+
+  test "should move sounds backwards" do
+    assert_equal "n", Sound.new("m").backward.backward.symbol
+  end
+
+end

data/test/sounds_test.rb

@@ -0,0 +1,32 @@
+require File.expand_path("../test_helper", __FILE__)
+
+class SoundsTest < Test::Unit::TestCase
+
+  def setup
+    @sounds = Phonology.sounds
+  end
+
+  def small_set
+    Phonology::Sounds.from_ipa("b", "p", "d", "t", "m", "n")
+  end
+
+  test "should return feature set for symbol" do
+    assert_equal [:voiced, :bilabial, :nasal].to_set, @sounds.features("m")
+  end
+
+  test "#with should return a set of sets that include any of the given features" do
+    assert_equal ["p", "b", "m", "n"].to_set, small_set.with(:bilabial, :nasal).symbols
+  end
+
+  test "#without should return a set of sets that exclude any of the given features" do
+    assert_equal ["p", "b", "n", "d", "t"].to_set, small_set.without(:bilabial, :nasal).symbols
+  end
+
+  test "#with_all should return a set of sets that include any of the given features" do
+    assert_equal ["m"].to_set, small_set.with_all(:bilabial, :nasal).symbols
+  end
+
+  test "#without_any should return a set of sets that exclude all of the given features" do
+    assert_equal ["d", "t"].to_set, small_set.without_any(:bilabial, :nasal).symbols
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,9 @@
+require "test/unit"
+require File.expand_path("../../lib/phonology", __FILE__)
+
+Test::Unit::TestCase.extend Module.new {
+  def test(name, &block)
+    define_method("test_#{name.gsub(/[^a-z0-9]/i, "_")}".to_sym, &block)
+  end
+  alias should test
+}

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: phonology
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Norman Clarke
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-06 00:00:00 -03:00
+default_executable: 
+dependencies: []
+
+description: A phonology library for Ruby.
+email: norman@njclarke.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/phonology.rb
+- lib/phonology/features.rb
+- lib/phonology/sound.rb
+- lib/phonology/sounds.rb
+- lib/phonology/version.rb
+- test/features_test.rb
+- test/phonology_test.rb
+- test/sound_test.rb
+- test/sounds_test.rb
+- test/test_helper.rb
+- README.md
+- LICENSE
+has_rdoc: true
+homepage: http://github.com/norman/phonology
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: "[none]"
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Phonology library for Ruby
+test_files: []
+