phonology 0.0.1 → 0.0.5

data/lib/phonology/features.rb

@@ -8,8 +8,9 @@ module Phonology
 
     # Pulmonic consonants
     PULMONIC = [:nasal, :plosive, :fricative, :approximant, :trill, :flap,
-      :lateral, :bilabial, :labiodental, :dental, :alveolar, :postalveolar,
-      :retroflex, :palatal, :velar, :uvular, :pharyngeal, :epiglottal, :glottal]
+      :lateral_fricative, :lateral_approximant, :lateral_flap, :bilabial,
+      :labiodental, :dental, :alveolar, :postalveolar, :retroflex, :palatal,
+      :velar, :uvular, :pharyngeal, :epiglottal, :glottal]
 
     # Non-pulmonic consonants
     NON_PULMONIC = [:click, :implosive, :ejective]
@@ -25,7 +26,8 @@ module Phonology
     ALL = ([:voiced] + PULMONIC + NON_PULMONIC + VOCALIC).to_set
 
     # Manner of articulation features
-    MANNER = [:nasal, :plosive, :fricative, :approximant, :trill, :flap, :lateral] + NON_PULMONIC
+    MANNER = [:nasal, :plosive, :fricative, :approximant, :trill, :flap, :lateral_fricative,
+      :lateral_approximant, :lateral_flap] + NON_PULMONIC
 
     # Place of articulation features
     PLACE = CONSONANTAL.to_a - MANNER
@@ -42,122 +44,135 @@ module Phonology
       :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,
+      :lateral      => [:lateral_fricative, :lateral_approximant, :lateral_flap].to_set,
+      :liquid       => [:flap, :lateral_fricative, :lateral_approximant, :lateral_flap].to_set,
+      :vocalic      => (VOCALIC + [:rounded]).to_set,
+      :vocoid       => (VOCALIC + [:approximant]).to_set,
+      :non_pulmonic => NON_PULMONIC.to_set,
+      :pulmonic     => PULMONIC.to_set,
       :consonantal  => CONSONANTAL
     }
 
+    # IPA diacritics for some sound modifiers such as devoicing, affricitization, etc.
+    DIACRITICS = {
+      :affricate => [0x0361]
+    }
+
     # 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]
+      [: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],
+      [:voiced, :retroflex, :lateral_fricative].to_set          => [0xa78e],
+      [:voiced, :palatal, :lateral_fricative].to_set            => [0xf267],
+      [:voiced, :velar, :lateral_fricative].to_set              => [0xf268],
+      [:voiced, :retroflex, :lateral_flap].to_set               => [0xf269],
+      [:voiced, :bilabial, :velar, :approximant].to_set         => [0x0077],
+      [:bilabial, :velar, :approximant].to_set                  => [0x268d],
+      [:voiced, :bilabial, :palatal, :approximant].to_set       => [0x0265],
+      [:voiced, :velar, :alveolar, :lateral_approximant].to_set => [0x026b],
+      [:palatal, :alveolar, :fricative].to_set                  => [0x0255],
+      [:voiced, :palatal, :alveolar, :fricative].to_set         => [0x0291],
+      [:palatal, :velar, :fricative].to_set                     => [0x0267]
     }
+    SETS.each {|k, v| k.freeze}
 
     class << self
       # Return the set corresponding to the kind of feature: manner or place of
@@ -171,11 +186,19 @@ module Phonology
       # corresponding features. If a single feature is given, just return the
       # feature.
       def expand(*args)
-        args = args.inject([].to_set) do |memo, obj|
+        args = args.first.kind_of?(Set) ? args.shift.to_a : args.flatten
+        args.inject([].to_set) do |memo, obj|
           memo << (CLASSES[obj] || obj)
         end.flatten.to_set
       end
 
+      def place_groups(*args)
+        args = args.first.kind_of?(Set) ? args.shift : args.flatten.to_set
+        [:labial, :coronal, :dorsal, :radical].map do |fclass|
+          fclass unless (CLASSES[fclass] & args).empty?
+        end.compact.uniq
+      end
+
     end
 
   end

data/lib/phonology/{sounds.rb → inventory.rb}

@@ -1,7 +1,7 @@
 module Phonology
 
   # An inventory of Phonological feature sets.
-  class Sounds
+  class Inventory
 
     # A Hash with a set of features as keys, and UTF-8 codepoints for IPA
     # letters as values.
@@ -32,38 +32,58 @@ module Phonology
     end
 
     # Given a set of features, return an array of UTF-8 codepoints.
-    def codepoints(features)
-      features = features.to_set.flatten
+    def codepoints(*features)
+      features = setify(*features)
       @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?}
+      pos, neg = mangle_args(*features)
+      self.class.new(@sets.select do |key, val|
+        !key.intersection(pos).empty?
+      end).without_any(neg)
     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)}
+      pos, neg = mangle_args(*features)
+      self.class.new(@sets.select do |key, val|
+        pos.subset?(key)
+      end).without_any(neg)
     end
 
     # Return an instance of Sounds whose sets exclude any of the given
     # features.
     def without(*features)
-      features = features.to_set
+      features = setify(*features)
       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
+      features = setify(*features)
       self.class.new @sets.select {|key, val| key.intersection(features).empty?}
     end
 
+    private
+
+    def mangle_args(*args)
+      pos = setify(*args)
+      neg = extract_negations(pos)
+      [pos.select {|f| f !~ /\A(non_|un)/}.compact.to_set, neg]
+    end
+
+    def setify(*args)
+      Features.expand(args.first.kind_of?(Set) ? args.shift : args.flatten.to_set)
+    end
+
+    def extract_negations(set)
+      Features.expand(*set.map {|feat| feat =~ /\A(non_|un)([a-z_]*)\z/ && $2.to_sym}.compact)
+    end
+
   end
 
 end

data/lib/phonology/orthography.rb

@@ -0,0 +1,117 @@
+module Phonology
+
+  module OrthographyTranslatorDSL
+
+    attr_accessor :last_sound, :anticipation
+
+    def method_missing(sym, *args, &block)
+      last_sound.__send__(sym, *args, &block)
+    end
+
+    def anticipate(&block)
+      @anticipation = block
+      nil
+    end
+
+    def curr_char
+      array[@index]
+    end
+
+    def next_char(offset = 1)
+      array[@index + offset]
+    end
+
+    def prev_char(offset = 1)
+      array[@index - offset] unless @index == 0
+    end
+
+    def follows(*chars)
+      chars.flatten.each {|c| return true if c == prev_char}
+      false
+    end
+
+    def precedes(*chars)
+      return false if !next_char
+      chars.flatten.each {|c| return true if c == next_char}
+      false
+    end
+
+    def between(before, after)
+      follows(*before) && precedes(*after)
+    end
+
+    def initial?
+      @index == 0
+    end
+
+    def final?
+      !next_char
+    end
+
+    def get(*features)
+      if features.first.kind_of?(Array)
+        get_affricate(*features)
+      else
+        match = sounds.with_all(*features)
+        return nil if match.sets.empty? || match.sets.length > 1
+        @last_sound = Sound.new *match.sets.keys.first.to_a
+      end
+      @last_sound.orthography = curr_char
+      do_anticipation
+    end
+
+    private
+
+    def get_affricate(*features)
+      @last_sound = Phonology::Affricate.new(features[0], features[1])
+    end
+
+    def do_anticipation
+      if @anticipation
+        @anticipation.call(last_sound)
+        @anticipation = nil
+      end
+      return last_sound
+    end
+
+  end
+
+  class OrthographyTranslator
+
+    attr_accessor :rules, :scanner, :sounds, :string
+
+    include OrthographyTranslatorDSL
+
+    # Translate orthorgraphy to IPA
+    def translate(string)
+      @string = string
+      @max = array.length
+      SoundSequence.new(array.each_index.map do |index|
+        @index = index
+        instance_eval(&@rules)
+      end.flatten.compact)
+    ensure
+      @max = 0
+      @string = nil
+      @array = nil
+      @index = nil
+      @last_sound = nil
+    end
+
+    def set_rules(&block)
+      @rules = block
+    end
+
+    private
+
+    def array
+      @array ||= scan
+    end
+
+    def scan
+      scanner ? scanner.call(string) : string.split(//u)
+    end
+
+  end
+
+end

data/lib/phonology/rule.rb

@@ -0,0 +1,103 @@
+module Phonology
+
+  class RulesDSL
+
+    attr :array, :index
+
+    def initialize(array)
+      @array = array
+    end
+
+    def method_missing(sym, *args, &block)
+      curr_sound.__send__(sym, *args, &block)
+    end
+
+    def apply(&block)
+      array.each_index.map do |index|
+        @index = index
+        instance_eval(&block)
+        get_result
+      end
+    end
+
+    def delete(*args)
+      if !args.empty?
+        curr_sound.delete(*args)
+      else
+        array[@index] = nil
+      end
+    end
+
+    def insert(*args)
+      @result = [curr_sound, Sound.new(*args)]
+    end
+
+    def curr_sound
+      array[@index]
+    end
+
+    def next_sound(offset = 1)
+      !final? && array[@index + offset]
+    end
+
+    def prev_sound(offset = 1)
+      !initial? && array[@index - offset]
+    end
+
+    def voice
+      curr_sound << :voiced
+    end
+
+    def devoice
+      curr_sound >> :voiced
+    end
+
+    def precedes(*features)
+      return false if !next_sound
+      features.flatten.each {|f| return false unless next_sound.send(:"#{f}?")}
+      true
+    end
+
+    def follows(*features)
+      return false if initial?
+      features.flatten.each {|f| return false unless prev_sound.send(:"#{f}?")}
+      true
+    end
+
+    def initial?
+      @index == 0
+    end
+
+    def final?
+      @index == @max
+    end
+
+    private
+
+    def get_result
+      if !@result
+        curr_sound
+      else
+        result = @result
+        @result = nil
+        result
+      end
+    end
+
+  end
+
+  class Rule
+
+    attr :rule
+
+    def initialize(&block)
+      @rule = block
+    end
+
+    def apply(sounds)
+      dsl = RulesDSL.new(sounds)
+      dsl.apply(&rule).flatten
+    end
+
+  end
+end

data/lib/phonology/sound.rb

@@ -1,22 +1,18 @@
 module Phonology
 
-  # A set of distinctive features
-  class Sound
+  module SoundBase
 
-    attr_reader :features
-
-    def initialize(*features)
-      @features = if features.first.kind_of?(String)
-        Phonology.features(features.shift)
-      else
-        features.to_set
-      end
-    end
+    attr_accessor :features, :orthography, :hints
+    protected :features=, :hints=
 
     Features::ALL.each do |feature|
       class_eval(<<-EOM, __FILE__, __LINE__ +1)
         def #{feature}?
-          @features.include? :#{feature}
+          features.include? :#{feature}
+        end
+
+        def non_#{feature}?
+          !#{feature}?
         end
       EOM
     end
@@ -25,79 +21,176 @@ module Phonology
       class_eval(<<-EOM, __FILE__, __LINE__ +1)
         def #{feature_class}?
           set = Features.expand(:#{feature_class})
-          !set.intersection(@features).empty?
+          !set.intersection(features).empty?
+        end
+
+        def non_#{feature_class}?
+          !#{feature_class}?
         end
       EOM
     end
 
-    # Get the IPA symbol for the sound.
-    def symbol
-      Phonology.symbol(features)
+    alias unvoiced? non_voiced?
+
+    def sonority
+      case
+      when vocalic? then 5
+      when approximant? then 4
+      when liquid? then 3
+      when nasal? then 2
+      when fricative? then 1
+      else 0
+      end
     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
+    # Orthography hints that can be useful to consult when applying rules.
+    def hints
+      @hints ||= []
     end
-    alias add <<
 
-    # Remove a feature, and return self.
-    def >>(feature)
-      @features -= [feature.to_sym]
+    # TODO set up list of valid hints
+    def hint(*args)
+      self.hints += args.flatten
       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
+    def orthography
+      @orthography ||= ""
+    end
+
+    def codepoints
+      raise NotImplementedError
+    end
+
+    def exists?
+      raise NotImplementedError
     end
 
-    def forward
+    # Get the IPA codepoints for the sound, including any diacritics.
+    def symbol
+      codepoints.pack("U*")
+    end
+
+    # Does the sound have more than one place of articulation?
+    def coarticulated?
+      place.size > 1
     end
 
     # Get the sound's place of articulation.
     def place
-      @features.intersection(Features::PLACE)
+      features.intersection(Features::PLACE)
     end
 
     # Get the sound's manner of articulation.
     def manner
-      @features.intersection(Features::MANNER)
+      features.intersection(Features::MANNER)
     end
 
     # Get the sound's height.
     def height
-      @features.intersection(Features::HEIGHT)
+      features.intersection(Features::HEIGHT)
     end
 
     # Get the sound's backness.
     def backness
-      @features.intersection(Features::BACKNESS)
+      features.intersection(Features::BACKNESS)
     end
 
-    def exists?
-      self.class.exists?(@features)
+    # Get the place groups (:coronal, :dorsal, etc). Normally there should only be one.
+    def place_groups
+      Features.place_groups(features)
     end
 
+  end
+
+  # A set of distinctive features
+  class Sound
+
+    include SoundBase
+
+    # Does the group of features exist in human speech?
     def self.exists?(features)
       !! Features::SETS[features]
     end
 
+    def initialize(*features)
+      if features.first.kind_of?(String)
+        self.features = Phonology.features_for(features.shift).clone
+      else
+        self.features = features.to_set
+      end
+    end
+
+    # Get the IPA codepoints for the sound, excluding any diacritics.
+    def codepoints
+      Phonology.sounds.codepoints(features)
+    end
+
+    # Add a feature, replacing either the place or manner of articulation,
+    # or the height or backness. Returns self.
+    def <<(*args)
+      args.to_a.flatten.each do |feature|
+        features.subtract Features.set(feature).to_a
+        add! feature
+      end
+      self
+    end
+    alias add <<
+
+    # Add a feature without replacing place or manner.
+    def add!(feature)
+      features.add feature.to_sym
+      self
+    end
+
+    # Remove a feature, and return self.
+    def >>(*args)
+      args.to_a.flatten.each do |feature|
+        features.delete feature.to_sym
+      end
+      self
+    end
+    alias delete >>
+
+    # Does the sound exist?
+    def exists?
+      self.class.exists?(features)
+    end
+
+  end
+
+
+  # A sound which begins plosive and finished fricative.
+  class Affricate
+
+    include SoundBase
+
+    attr_accessor :onset, :release
+    protected :onset=, :release=
+
+    def initialize(onset, release)
+      self.onset = get_sound(onset)
+      self.release = get_sound(release)
+    end
+
+    def exists?
+      onset.exists? && release.exists?
+    end
+
+    def features
+      onset.features + release.features
+    end
+
+    def codepoints
+      [onset.codepoints, Features::DIACRITICS[:affricate], release.codepoints].flatten
+    end
+
+    private
+
+    def get_sound(arg)
+      arg.kind_of?(Sound) ? arg : Sound.new(*arg)
+    end
+
   end
+
 end

data/lib/phonology/sound_sequence.rb

@@ -0,0 +1,45 @@
+module Phonology
+
+  # A collection of sounds
+  class SoundSequence
+
+    attr :sounds
+
+    def method_missing(sym, *args, &block)
+      @sounds.__send__(sym, *args, &block)
+    end
+
+    def initialize(arg)
+      # String of ipa symbols
+      if arg.kind_of? String
+        @sounds = arg.split('').map {|letter| Sound.new(letter)}
+      else
+        @sounds = arg.to_a
+      end
+    end
+
+    def symbols
+      compact.map(&:symbol).join
+    end
+    alias ipa symbols
+    alias to_s symbols
+    alias to_str symbols
+
+    def orthography
+      compact.map(&:orthography).join
+    end
+
+    # Apply rule and get a new instance of SoundSequence.
+    def apply_rule(rule)
+      self.class.new rule.apply(@sounds)
+    end
+
+    # Apply rule in place.
+    def apply_rule!(rule)
+      @sounds = rule.apply(@sounds)
+      self
+    end
+
+
+  end
+end

data/lib/phonology/version.rb

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

data/lib/phonology.rb

@@ -1,21 +1,24 @@
 require "set"
 require File.expand_path("../phonology/features", __FILE__)
-require File.expand_path("../phonology/sounds", __FILE__)
+require File.expand_path("../phonology/inventory", __FILE__)
 require File.expand_path("../phonology/sound", __FILE__)
+require File.expand_path("../phonology/sound_sequence", __FILE__)
+require File.expand_path("../phonology/orthography", __FILE__)
+require File.expand_path("../phonology/rule", __FILE__)
 
 module Phonology
 
   extend self
 
   def sounds
-    @sounds ||= Sounds.new Features::SETS
+    @sounds ||= Inventory.new(Features::SETS).freeze
   end
 
-  def symbol(*args)
+  def symbol_for(*args)
     sounds.symbol(*args)
   end
 
-  def features(*args)
+  def features_for(*args)
     sounds.features(*args)
   end
 

data/test/affricate_test.rb

@@ -0,0 +1,21 @@
+require File.expand_path("../test_helper", __FILE__)
+
+class AffricateTest < Test::Unit::TestCase
+  include Phonology
+
+  def setup
+    @affricate = Affricate.new("t", "s")
+  end
+
+  test "should get symbol for affricate" do
+    assert_equal [116, 865, 115], @affricate.symbol.unpack("U*")
+  end
+
+  test "should act like a sound" do
+    assert @affricate.exists?
+    assert @affricate.coronal?
+    assert @affricate.plosive?
+    assert @affricate.fricative?
+  end
+
+end

data/test/features_test.rb

@@ -2,9 +2,17 @@ require File.expand_path("../test_helper", __FILE__)
 
 class FeaturesTest < Test::Unit::TestCase
 
-  test "should expand feature groups" do
+  include Phonology
+
+  test "should expand place groups" do
     assert_equal [:dental, :alveolar, :postalveolar, :retroflex, :velar].to_set,
-        Phonology::Features.expand(:coronal, :dental, :velar)
+        Features.expand(:coronal, :dental, :velar)
+  end
+
+  test "should contract place groups" do
+    assert_equal [:coronal], Features.place_groups([:alveolar, :plosive, :postalveolar, :fricative])
+    assert_equal [:coronal], Features.place_groups([:alveolar, :plosive, :postalveolar, :fricative].to_set)
+    assert_equal [:coronal], Features.place_groups(:alveolar, :plosive, :postalveolar, :fricative)
   end
 
 end

data/test/{sounds_test.rb → inventory_test.rb}

@@ -7,7 +7,7 @@ class SoundsTest < Test::Unit::TestCase
   end
 
   def small_set
-    Phonology::Sounds.from_ipa("b", "p", "d", "t", "m", "n")
+    Phonology::Inventory.from_ipa("b", "p", "d", "t", "m", "n")
   end
 
   test "should return feature set for symbol" do
@@ -29,4 +29,17 @@ class SoundsTest < Test::Unit::TestCase
   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
+
+  test "should expand features" do
+    assert_equal ["t", "d", "n"].to_set, small_set.with(:coronal).symbols
+  end
+
+  test "#with should exclude negative features" do
+    assert_equal ["t", "d"].to_set, small_set.with(:coronal, :non_nasal).symbols
+  end
+
+  test "#with_all should exclude negative features" do
+    assert_equal ["t"].to_set, small_set.with_all(:alveolar, :unvoiced).symbols
+  end
+
 end

data/test/phonology_test.rb

@@ -2,16 +2,16 @@ 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
+  test "sounds should return an instance of Inventory" do
+    assert_equal Phonology::Inventory, Phonology.sounds.class
   end
 
   test "should return feature set for symbol" do
-    assert_equal [:voiced, :bilabial, :nasal].to_set, Phonology.features("m")
+    assert_equal [:voiced, :bilabial, :nasal].to_set, Phonology.features_for("m")
   end
 
   test "should return a symbol for a feature set" do
-    assert_equal "d", Phonology.symbol(:voiced, :alveolar, :plosive)
+    assert_equal "d", Phonology.symbol_for(:voiced, :alveolar, :plosive)
   end
 
 end

data/test/rule_test.rb

@@ -0,0 +1,40 @@
+require File.expand_path("../test_helper", __FILE__)
+
+class RuleTest < Test::Unit::TestCase
+
+  include Phonology
+
+  test "should delegate to current sound" do
+    assert_rule "amta", "anta" do
+      add :alveolar if nasal? and precedes :alveolar
+    end
+  end
+
+  test "should delete sound" do
+    assert_rule "amta", "ama" do
+      delete if alveolar? and follows :nasal
+    end
+  end
+
+  test "should insert sound" do
+    assert_rule "pta", "pata" do
+      insert "a" if plosive? and precedes :plosive
+    end
+  end
+
+  test "should devoice" do
+    assert_rule "bta", "pta" do
+      devoice if plosive? and precedes(:plosive, :unvoiced)
+    end
+  end
+
+  private
+
+  def assert_rule(given, expected, &block)
+    rule = Rule.new &block
+    sounds = SoundSequence.new(given)
+    assert_equal expected, sounds.apply_rule!(rule).to_s
+  end
+
+
+end

data/test/sound_test.rb

@@ -4,6 +4,22 @@ class SoundTest < Test::Unit::TestCase
 
   include Phonology
 
+  test "vowels should be more sonorous than approximants" do
+    assert Sound.new("o").sonority > Sound.new("w").sonority
+  end
+
+  test "approximants should be more sonorous than liquids" do
+    assert Sound.new("j").sonority > Sound.new("l").sonority
+  end
+
+  test "liquids should be more sonorous than nasals" do
+    assert Sound.new("l").sonority > Sound.new("n").sonority
+  end
+
+  test "nasals should be more sonorous than non-nasal consonants" do
+    assert Sound.new("n").sonority > Sound.new("z").sonority
+  end
+
   test "should return an IPA symbol" do
     assert_equal "m", Sound.new(:voiced, :bilabial, :nasal).symbol
   end
@@ -60,6 +76,10 @@ class SoundTest < Test::Unit::TestCase
     assert_equal :alveolar, Sound.new("r").place.first
   end
 
+  test "should indicate if sound is coarticulated" do
+    assert Sound.new("w").coarticulated?
+  end
+
   test "should get manner of articulation" do
     assert_equal :trill, Sound.new("r").manner.first
   end
@@ -72,13 +92,9 @@ class SoundTest < Test::Unit::TestCase
     assert_equal :front, Sound.new("e").backness.first
   end
 
-  test "should indicate if sound exists" do
+  test "should indicate if simple 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

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 5
+  version: 0.0.5
 platform: ruby
 authors: 
 - Norman Clarke
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-06 00:00:00 -03:00
+date: 2010-05-20 00:00:00 -03:00
 default_executable: 
 dependencies: []
 
@@ -29,13 +29,18 @@ extra_rdoc_files: []
 files: 
 - lib/phonology.rb
 - lib/phonology/features.rb
+- lib/phonology/inventory.rb
+- lib/phonology/orthography.rb
+- lib/phonology/rule.rb
 - lib/phonology/sound.rb
-- lib/phonology/sounds.rb
+- lib/phonology/sound_sequence.rb
 - lib/phonology/version.rb
+- test/affricate_test.rb
 - test/features_test.rb
+- test/inventory_test.rb
 - test/phonology_test.rb
+- test/rule_test.rb
 - test/sound_test.rb
-- test/sounds_test.rb
 - test/test_helper.rb
 - README.md
 - LICENSE