spanish 0.0.2

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,11 @@
+# Spanish
+
+This library provides (or rather, will provide) some linguistic tools for
+working with Spanish words.
+
+Plans include:
+
+* Syllabify any Spanish word.
+* Correctly conjugate any Spanish infinitive verb.
+* Given a conjugated verb, identify its conjugation and infinitive.
+* Correctly return gender, pluralization and agreement for nouns.

data/lib/spanish.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+require "phonology"
+require File.expand_path("../spanish/orthography", __FILE__)
+require File.expand_path("../spanish/phonology", __FILE__)
+require File.expand_path("../spanish/syllable", __FILE__)
+
+# This library provides some linguistic and orthographic tools for Spanish
+# words.
+module Spanish
+
+  extend self
+
+  # Returns an array of Spanish letters from string.
+  # Example:
+  #     Spanish.letters("chillar")
+  #     # => ["ch", "i", "ll", "a", "r"]
+  def letters(string)
+    string.scan(Orthography::LETTERS)
+  end
+
+  # Get an array of Phonology::Sounds from the string.
+  def get_sounds(string, *rules)
+    sequence = Orthography.translator.translate(string)
+    Phonology.rules.values.each do |rule|
+      sequence.apply_rule!(rule)
+    end
+    sequence
+  end
+
+  # Translate the Spanish string to International Phonetic Alphabet.
+  # Example:
+  #
+  #     Spanish.get_ipa("chavo")
+  #     # => 't͡ʃaβo
+  def get_ipa(string)
+    get_sounds(string).to_s
+  end
+
+end

data/lib/spanish/orthography.rb

@@ -0,0 +1,112 @@
+# encoding: utf-8
+module Spanish
+  module Orthography
+
+    extend self
+
+    LETTERS = /ch|ll|ñ|á|é|í|ó|ú|ü|[\w]/
+
+    SCANNER = lambda {|string| string.downcase.scan(/rr|ch|ll|ñ|á|é|í|ó|ú|ü|\w/)}
+
+    SOUNDS = ::Phonology::Inventory.from_ipa(
+      "m", "n", "ɲ", "ŋ", "p", "b", "t", "d", "k", "ɡ", "β", "f", "v", "ð", "s",
+      "z", "ʒ", "ʝ", "x", "ɣ", "j", "r", "ɾ", "l", "w", "i", "u", "e", "o", "a",
+      "θ", "ʎ"
+    )
+
+    # Note that unvoiced dental fricative is assumed for "z" (and "c"). This is
+    # not out of bias towards Spain, but because it is the most
+    # information-rich reading of the orthography. The same applies to the
+    # presevation of a distinction between "y" and "ll". Yeísmo and other
+    # common phenomena can be derived later with phonological rules.
+    RULES = Proc.new {
+      vowel = ["a", "á", "e", "é", "i", "í", "o", "ó", "u", "ú", "ü"]
+      close_front_vowel = ["i", "e", "í", "é"]
+      non_close_front_vowel = vowel - close_front_vowel
+      case curr_char
+      when "á"  then get(:voiced, :open, :front).hint(:primary_stress)
+      when "a"  then get(:voiced, :open, :front)
+      when "b"  then get(:voiced, :bilabial, :plosive)
+      when "c"  then precedes(close_front_vowel) ? get(:unvoiced, :dental, :fricative) : get(:unvoiced, :velar, :plosive)
+      when "ch" then get([:alveolar, :plosive], [:postalveolar, :fricative])
+      when "d"  then get(:voiced, :alveolar, :plosive)
+      when "é"  then get(:close_mid, :front).hint(:primary_stress)
+      when "e"  then get(:close_mid, :front)
+      when "f"  then get(:unvoiced, :labiodental, :fricative)
+      when "g"  then precedes(close_front_vowel) ? get(:unvoiced, :velar, :fricative) : get(:velar, :plosive, :voiced)
+      when "h"  then anticipate {|sound| sound.hint(:syllable_boundary).orthography.insert(0, "h")}
+      when "í"  then get(:close, :front).hint(:primary_stress)
+      when "i"
+        if precedes(vowel - ["i", "í"])
+          get(:palatal, :approximant)
+        else
+          get(:close, :front)
+        end
+      when "j"  then get(:unvoiced, :velar, :fricative)
+      when "k"  then get(:unvoiced, :velar, :plosive)
+      when "l"  then get(:alveolar, :lateral_approximant)
+      when "ll" then get(:palatal, :lateral_approximant) or get(:voiced, :palatal, :fricative)
+      when "m"  then get(:bilabial, :nasal, :voiced)
+      when "n"  then get(:alveolar, :nasal)
+      when "ñ"  then get(:palatal, :nasal)
+      when "ó"  then get(:close_mid, :back).hint(:primary_stress)
+      when "o"  then get(:close_mid, :back)
+      when "p"  then get(:unvoiced, :bilabial, :plosive)
+      when "q"  then get(:unvoiced, :velar, :plosive)
+      when "r"  then initial? ? get(:trill) : get(:flap)
+      when "rr" then get(:trill)
+      when "s"  then get(:unvoiced, :alveolar, :fricative)
+      when "t"  then get(:unvoiced, :alveolar, :plosive)
+      when "ú"
+        if follows("q") or between("g", close_front_vowel)
+          orthography.insert(1, "ú") && nil
+        else
+          get(:close, :back).hint(:primary_stress)
+        end
+      when "u"
+        if follows("q") or between("g", close_front_vowel)
+          orthography.insert(1, "u") && nil
+        elsif follows(vowel - ["i", "í"]) || precedes(vowel)
+          get(:velar, :approximant)
+        else
+          get(:close, :back)
+        end
+      when "ü"  then get(:velar, :approximant)
+      when "v"  then get(:voiced, :bilabial, :plosive)
+      when "w"  then get(:velar, :approximant)
+      when "x"
+        if initial?
+          get(:unvoiced, :velar, :fricative)
+        else
+          [get(:unvoiced, :velar, :plosive), Phonology::Sound.new("s")]
+        end
+
+      when "y"
+        if initial? && final?
+          get(:close, :front)
+        elsif final?
+          get(:palatal, :approximant)
+        elsif precedes(vowel)
+          get(:voiced, :palatal, :fricative)
+        elsif initial? and !precedes(vowel)
+          get(:close, :front)
+        elsif !precedes(vowel)
+          get(:palatal, :approximant)
+        end
+      when "z" then get(:unvoiced, :dental, :fricative)
+      end
+    }
+
+    # Get an instance of Phonology::OrthographyTranslater with scanner and sound
+    # inventory set for Spanish.
+    def translator
+      orth = ::Phonology::OrthographyTranslator.new
+      orth.scanner = SCANNER
+      orth.sounds  = SOUNDS
+      orth.rules   = RULES
+      orth
+    end
+
+  end
+
+end

data/lib/spanish/phonology.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+module Spanish
+
+  module Phonology
+
+    extend self
+
+    attr_reader :rules
+
+    @rules = {
+      :sprinantization => ::Phonology::Rule.new {
+        if voiced? and plosive? and !initial? and precedes(:vocoid) and !follows(:nasal)
+          if non_coronal?
+            add :fricative
+          elsif coronal? and !follows(:lateral_approximant)
+            add :fricative, :dental
+          end
+        end
+      },
+      :seseo => ::Phonology::Rule.new {
+        add :alveolar if dental? and unvoiced?
+      },
+      :voicing => ::Phonology::Rule.new {
+        voice if alveolar? and fricative? and precedes(:voiced, :non_vocoid)
+      }
+    }
+
+    def apply_rules(array)
+      rules.values.inject(array) {|result, rule| rule.apply(result)}
+    end
+
+  end
+
+end

data/lib/spanish/syllable.rb

@@ -0,0 +1,175 @@
+# @TODO
+# Problem words: insubstancialidad, descouella
+module Spanish
+  class Syllable
+
+    attr_accessor :onset, :coda, :nucleus, :stress
+
+    def initialize(sound = nil)
+      @onset = []
+      @nucleus = []
+      @coda = []
+      add sound if sound
+    end
+
+    def to_a
+      [onset, rime].flatten
+    end
+
+    def valid?
+      !nucleus.empty?
+    end
+
+    def rime
+      [nucleus, coda]
+    end
+
+    def to_s
+      string = to_a.map(&:symbol).join
+      (stress ? "\u02c8" : "") + string
+    end
+
+    def wants?(sound)
+      onset_wants?(sound) or nucleus_wants?(sound) or coda_wants?(sound)
+    end
+
+    def onset_wants?(sound)
+      if !nucleus.empty? || sound.vocalic?
+        false
+      elsif onset.empty?
+        sound.consonantal?
+      else
+        sound.liquid? || sound.approximant?
+      end
+    end
+
+    def nucleus_wants?(sound)
+      if !coda.empty? || nucleus.length == 2 || !sound.vocalic?
+        false
+      elsif nucleus.empty?
+        true
+      elsif nucleus.last != sound
+        !nucleus.last.hints.include?(:primary_stress) &&
+          !sound.hints.include?(:syllable_boundary) &&
+          (nucleus.last.close? || !nucleus.last.close? && sound.close?)
+      end
+    end
+
+    def coda_wants?(sound)
+      if nucleus.empty?
+        false
+      else
+        # Codas don't want a rising dipthong but will accept one at the end of words.
+        sound.consonantal? && !(sound.approximant? && sound.palatal?)
+      end
+    end
+
+    def <<(sound)
+      @stress = true if sound.hints.include?(:primary_stress)
+      if onset_wants?(sound)
+        @onset << sound
+      elsif nucleus_wants?(sound)
+        @nucleus << sound
+      else
+        @coda << sound
+      end
+    end
+    alias add <<
+
+    def empty?
+      onset.empty? && nucleus.empty? && coda.empty?
+    end
+
+    def self.apply_stress(syllables)
+      if syllables.detect {|s| s.stress}
+      elsif syllables.length == 1
+        syllables[0].stress = true
+      else
+        last = syllables.last.to_a
+        penult = syllables[-2].to_a
+        if last.last.vocalic? or last.last.nasal? or (last.last.alveolar? && last.last.fricative?)
+          syllables[-2].stress = true
+        else
+          syllables.last.stress = true
+        end
+      end
+      syllables
+    end
+
+    def self.syllabify(arg)
+      arg = arg.kind_of?(String) ? Spanish.get_sounds(arg) : arg
+      apply_stress(Syllables.new(arg).entries)
+    end
+
+    class Syllables
+
+      include Enumerable
+
+      attr :index, :sounds, :syllable
+
+      def initialize(sounds)
+        @sounds = sounds
+      end
+
+      def each(&block)
+        begin
+          sounds.each_index { |i| @index = i; append or do_yield(&block) }
+          do_yield(&block)
+        ensure
+          @index = 0
+          @syllable = nil
+        end
+      end
+
+      private
+
+      def do_yield(&block)
+        yield syllable
+        @syllable = Syllable.new(curr)
+      end
+
+      def syllable
+        @syllable ||= Syllable.new
+      end
+
+      def append
+        return if !curr
+        # Final consonantal has nowhere else to go.
+        if !nex && curr.consonantal?
+          syllable << curr
+        # If there's no room in the syllable, we're forced to start a new one.
+        elsif !syllable.wants? curr
+          false
+        # Spanish has a strong aversion to syllable-initial consonant clusters
+        # beginning with "s".
+        elsif syllable.wants?(curr) && nex && curr.alveolar? && curr.fricative? && nex.non_vocoid?
+          syllable << curr
+        # Otherwise, the preference is to be the onset of a new syllable. This
+        # is only possible when the syllable we would create has sonority rising
+        # towards the nucleus.
+        elsif nex && syllable.valid? && (nex.sonority - curr.sonority > 1)
+          false
+        # Default action is to append to current syllable.
+        else
+          syllable << curr
+        end
+      end
+
+      def curr
+        @sounds[index]
+      end
+
+      def prev
+        @sounds[index - 1] unless index == 0
+      end
+
+      def nex
+        @sounds[index + 1]
+      end
+
+    end
+
+
+  end
+
+end

data/lib/spanish/verb.rb

@@ -0,0 +1,38 @@
+module Spanish
+
+  module Features
+
+    extend self
+
+    attr_reader :person, :mood, :tense
+
+    # if no bits set, then 1st
+    @person = {
+      :second   => 1 << 0,
+      :third    => 1 << 1,
+      :plural   => 1 << 2,
+      :familiar => 1 << 3
+    }
+
+    # if no bits set, then indicative
+    @mood = {
+      :subjunctive => 1 << 0,
+      :progressive => 1 << 1,
+      :imperative  => 1 << 2,
+      :negative    => 1 << 3 # can only be combined with imperative
+    }
+
+    # if no bits set, then present
+    @tense = {
+      :preterite   => 1 << 0,
+      :imperfect   => 1 << 1,
+      :future      => 1 << 2,
+      :conditional => 1 << 3
+    }
+
+  end
+
+  class Verb
+  end
+
+end

data/lib/spanish/version.rb

@@ -0,0 +1,3 @@
+module Spanish
+  VERSION = "0.0.2"
+end

data/test/phonology_test.rb

@@ -0,0 +1,69 @@
+# encoding: utf-8
+require File.expand_path("../test_helper", __FILE__)
+
+class PhonologyTest < Test::Unit::TestCase
+
+  test "c as s or k" do
+    assert_sound "kasa", "casa"
+    assert_sound "bisi", "bici"
+    assert_sound "fɾanko", "franco"
+  end
+
+  test "x" do
+    assert_sound "eksamen", "examen"
+  end
+
+  test "g as ɣ, g, or x" do
+    assert_sound "ɡustaβo", "gustavo"
+    assert_sound "laɣo", "lago"
+    assert_sound "ximena", "gimena"
+    assert_sound "xeɾman", "germán"
+  end
+
+  test "sprirantization" do
+    assert_sound "alɣo", "algo"
+    assert_sound "ranɡo", "rango"
+    assert_sound "kaldo", "caldo"
+    assert_sound "kandaðo", "candado"
+  end
+
+  test "y" do
+    assert_sound "i", "y"
+    assert_sound "kaʝo", "cayó"
+    assert_sound "iɣwasu", "yguazú"
+    assert_sound "doj", "doy"
+  end
+
+  test "voicing" do
+    assert_sound "razɣo", "rasgo"
+    assert_sound "xazmin", "jazmín"
+  end
+
+  test "trilled r and flap r" do
+    assert_sound "ropa", "ropa"
+    assert_sound "foɾo", "foro"
+    assert_sound "foraɾ", "forrar"
+  end
+
+  test "q, g and u" do
+    assert_sound "ke", "que"
+    assert_sound "ɡwemes", "güemes"
+    assert_sound "ɡera", "guerra"
+    assert_sound "ɡiɲo", "guiño"
+    assert_sound "pinɡwino", "pingüino"
+  end
+
+  test "diphthongs" do
+    assert_sound "buo", "buho"
+    assert_sound "pua", "púa"
+    assert_sound "oeste",  "oeste"
+  end
+
+  private
+
+  def assert_sound(expected, given)
+    assert_equal expected, Spanish.get_ipa(given)
+    assert_equal given.downcase, Spanish.get_sounds(given).map(&:orthography).join
+  end
+
+end

data/test/syllabification_test.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+require File.expand_path("../test_helper", __FILE__)
+
+class SyllabificationTest < Test::Unit::TestCase
+
+  include Phonology
+  include Spanish
+
+  test "should add consonant to empty onset" do
+    s = Syllable.new
+    assert s.onset_wants? Sound.new("t")
+    assert s.onset_wants? Sound.new("l")
+    assert s.onset_wants? Sound.new("w")
+  end
+
+  test "should not add vowel to empty onsent" do
+    s = Syllable.new
+    assert !s.onset_wants?(Sound.new("o"))
+  end
+
+  test "can append consonant to onset if liquid" do
+    s = Syllable.new
+    s.onset << Sound.new("t")
+    assert s.onset_wants? Sound.new("l")
+    assert s.onset_wants? Sound.new("ɾ")
+  end
+
+  test "can append consonant to onset if approximant" do
+    s = Syllable.new
+    s.onset << Sound.new("k")
+    assert s.onset_wants? Sound.new("w")
+  end
+
+  test "can not append sound to onset if non-liquid and non-approximant" do
+    s = Syllable.new
+    s.onset << Sound.new("k")
+    assert !s.onset_wants?(Sound.new("n"))
+    assert !s.onset_wants?(Sound.new("r"))
+    assert !s.onset_wants?(Sound.new("s"))
+    assert !s.onset_wants?(Sound.new("a"))
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,10 @@
+require "test/unit"
+require File.expand_path("../../lib/spanish", __FILE__)
+include Spanish
+
+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,86 @@
+--- !ruby/object:Gem::Specification 
+name: spanish
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- Norman Clarke
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-20 00:00:00 -03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: phonology
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 0
+        - 5
+        version: 0.0.5
+  type: :runtime
+  version_requirements: *id001
+description: A Spanish phonology, orthography and grammar library for Ruby.
+email: norman@njclarke.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/spanish.rb
+- lib/spanish/orthography.rb
+- lib/spanish/phonology.rb
+- lib/spanish/syllable.rb
+- lib/spanish/verb.rb
+- lib/spanish/version.rb
+- test/phonology_test.rb
+- test/syllabification_test.rb
+- test/test_helper.rb
+- README.md
+- LICENSE
+has_rdoc: true
+homepage: http://github.com/norman/spanish
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 9
+      version: "1.9"
+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: Spanish phonology, orthography and grammar library for Ruby.
+test_files: []
+