language 0.6.0

data/HISTORY.rdoc

@@ -0,0 +1,10 @@
+= Release History
+
+== 0.6.0 / 2010-05-29
+
+This is the first release of Language, however the code was previously
+released with the English project. Hence the current version of
+Language matches the present version of English. Language combines
+all the features previously part of English that are language
+netural or multi-lingual. It threfore provide a dependency for
+the English library.

data/LICENSE

@@ -0,0 +1,23 @@
+The MIT License
+
+Copyright (c) 2009 Thomas Sawyer
+
+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/PROFILE

@@ -0,0 +1,23 @@
+--- 
+title  : Language
+suite  : rubyworks
+summary: Language Support Library
+license: MIT
+authors: Thomas Sawyer
+created: 2007-08-01
+
+description:
+  Language is a support library for other langauge libraries.
+  While some of it's contents are prefectly usable on there own,
+  most are generally intended to be subclassed and extended  by
+  specific language modules, such as English.
+
+resources:
+  homepage    : http://rubyworks.github.com/language
+  development : http://github.com/rubyworks/language
+  respository : git://github.com/rubyworks/language.git
+  subscribe   : rubyworks-mailinglist+subscribe@googlegroups.com
+
+copyright:
+  COpyright (c) 2007 Thomas Sawyer
+

data/README.rdoc

@@ -0,0 +1,38 @@
+= Language
+
+* home: http://rubyworks.github.com/language
+* work: http://github.com/rubyworks/language
+
+Language is a support library for other langauge libraries.
+While some of it's contents are prefectly usable on there own,
+most are generally intended to be subclassed and extended  by
+specific language modules, such as English.
+
+
+== SYNOPSIS
+
+  require 'language'
+
+  "How many words?".words  #=> ['How', 'many', 'words']
+
+
+== INSTALLATION
+
+The usual Rubygems way:
+
+  $ gem install language
+
+
+== COPYING
+
+(MIT License)
+
+Copyright (c) 2010 Thomas Sawyer
+
+English is distributed under the terms of the MIT license.
+
+See LICENCE for details.
+
+Some libraries are subtantial derivatives of other persons
+work. Fully copyright and licensing information is given
+for those in the corresponding source files.

data/REQUIRE

@@ -0,0 +1,2 @@
+development:
+  - syckle

data/VERSION

@@ -0,0 +1,5 @@
+name : language
+major: 0
+minor: 6
+patch: 0
+date : 2010-05-29

data/lib/language.rb

@@ -0,0 +1,5 @@
+require 'language/class'
+require 'language/censor'
+require 'language/words'
+require 'language/mixin'
+

data/lib/language/censor.rb

@@ -0,0 +1,97 @@
+require 'language/class'
+
+class Language
+
+  # = Censor
+  #
+  # This class allows one to define a resuable text filter.
+  # This is useful for removing or replacing curse words or
+  # senstive information from user input.
+
+  class Censor
+
+    # Default censor list.
+    def self.default_words
+      []
+    end
+
+    # Abritraty rules.
+    attr :rules
+
+    # Word-oriented rules.
+    attr :word_rules
+
+    # New Censor object.
+    #
+    def initialize()
+      @rules = []
+      @word_rules = []
+
+      self.class.default_words.each do |word|
+         word_rule(word)
+      end
+    end
+
+    # Create new rule. A rule consists of a string or regexp
+    # to match against.
+    #
+    # NOTE: The rules must be applied in order! So we cannot
+    # use a hash because the ordering is not guaranteed. So
+    # an array is used instead.
+    #
+    def rule(match, &edit)
+      edit = lambda{''} unless edit
+      @rules << [match, edit]
+    end
+
+    # Rules that apply only to words. This takes the regular
+    # expression and add word boundry matches to either side.
+    #
+    #   filter.word_rule(/damn/){ |w| 'darn' }
+    #
+    # Is equivalent to teh regular rule:
+    #
+    #   filter.rule(/\bdamn\b/){ |w| 'darn' }
+    #
+    def word_rule(match, &edit)
+      edit = lambda{''} unless edit
+      @word_rules << [/\b#{match}\b/, edit]
+    end
+
+    # Apply the set of rules (regular expression matches) to
+    # a string.
+    #
+    def filter(string)
+      rewritten_string = string.dup
+      rules.each do |match,edit|
+        rewritten_string.gsub!(match,edit)
+      end
+      return (rewritten_string or string)
+    end
+
+    alias_method :apply, :filter
+
+    # Is the string clear of any matching rules?
+    #
+    # Note that running a filter does not necessarily clear a
+    # a string of all matches, since the filter could apply
+    # edits that would also match the filter expressions.
+    #
+    def censored?(string)
+      case string
+      when *matches
+        false
+      else
+        true
+      end
+    end
+
+    #
+    #
+    def matches
+      rules.collect{ |match, modify| match }
+    end
+
+  end
+
+end

data/lib/language/class.rb

@@ -0,0 +1,159 @@
+class Language
+
+  #
+  def self.abbreviation
+    'lang'
+  end
+
+  #
+  def self.default
+    @default || abbreviation
+  end
+
+  #
+  def self.default=(lang)
+    @default = lang
+  end
+
+  #
+  def self.current
+    @current || default
+  end
+
+  #
+  def self.current=(lang)
+    @current = lang
+  end
+
+  #
+  def self.instance(string)
+    @cache ||= {}
+    @cache[string.object_id] = new(string)
+  end
+
+  #
+  def initialize(subject)
+    @self = subject
+  end
+
+end
+
+class String
+  # Higher-order function to invoke Language functions.
+  def lang
+    Language.instance(self)
+  end
+end
+
+class Array
+  # Higher-order function to invoke Language functions.
+  def lang
+    Language.instance(self)
+  end
+end
+
+class Integer
+  # Higher-order function to invoke Language functions.
+  def lang
+    Language.instance(self)
+  end
+end
+
+
+
+
+=begin
+module Language
+  extend self
+
+  # Subclass this in your specific language modules.
+  #
+  #   class English::String < Language::String
+  #
+  class String < ::String
+
+    #
+    def self.language
+      Language
+    end
+
+    #
+    def self.instance(string)
+      @cache ||= {}
+      @cache[string.object_id] = new(string)
+    end
+
+    #
+    def initialize(string)
+      super()
+      replace(string)
+    end
+
+    def language
+      @_language ||= self.class.language
+    end
+
+  end
+
+  # TODO: We can't actually subclass Integer.
+  # But we can fake it. However we need to sublass
+  # it just so #is_a? works. However subclassing it causes
+  # the .new method not to exist, how to fix?
+  #
+  class Integer #< ::Integer
+    instance_methods{ |m| private m unless /^__/ =~ m.to_s }
+
+    #
+    def self.language
+      Language
+    end
+
+    #
+    def self.instance(integer)
+      @cache ||= {}
+      @cache[integer] = new(integer)
+    end
+
+    #
+    def initialize(integer)
+      @integer = integer
+    end
+
+    #
+    def to_i
+      @integer
+    end
+
+    #
+    def method_missing(s,*a,&b)
+      @integer.__send__(s,*a,&b)
+    end
+
+    #
+    def language
+      @_language ||= self.class.language
+    end
+  end
+
+  #
+  class Array < ::Array
+
+    #
+    def self.language
+      Language
+    end
+
+    #
+    def self.instance(array)
+      @cache ||= {}
+      @cache[array.object_id] = new(array)
+    end
+
+    def language
+      @_language ||= self.class.language
+    end
+  end
+
+end
+=end
+

data/lib/language/codes.rb

@@ -0,0 +1,43 @@
+require 'language/class'
+
+class Language
+
+  # A hash of International 2- and 3-letter ISO639-1 and ISO639-2 language codes.
+  module Codes
+
+	  # Hash of ISO639 2--letter language codes
+	  ISO639_1 = {}
+
+	  # Hash of ISO639 3-letter language codes
+	  ISO639_2 = {}
+
+    file = File.join(File.dirname(__FILE__), 'codes_iso639.txt')
+
+	  File.readlines(file).each do |line|
+      next if /^#/ =~ line
+
+      codes3, codes2, desc = line[0,7].strip, line[9,6].strip, line[15...-1].strip
+
+      codes3 = codes3.split('/')
+      codes2 = codes2.split('/')
+
+      codes2.each do |code|
+        if ISO639_1.key?(code)
+          raise "Duplicate language code #{code}"
+	      end
+        ISO639_1[code] = desc
+		  end
+
+      codes3.each do |code|
+        if ISO639_2.key?(code)
+          raise "Duplicate language code #{code}"
+	      end
+        ISO639_2[code] = desc
+		  end
+
+	  end
+
+  end
+
+end
+

data/lib/language/codes_iso639.txt

@@ -0,0 +1,404 @@
+abk      ab    Abkhazian
+ace            Achinese
+ach            Acoli
+ada            Adangme
+aar      aa    Afar
+afh            Afrihili
+afr      af    Afrikaans
+afa            Afro-Asiatic (Other)
+aka            Akan
+akk            Akkadian
+alb/sqi  sq    Albanian
+ale            Aleut
+alg            Algonquian languages
+tut            Altaic (Other)
+amh      am    Amharic
+apa            Apache languages
+ara      ar    Arabic
+arc            Aramaic
+arp            Arapaho
+arn            Araucanian
+arw            Arawak
+arm/hye  hy    Armenian
+art            Artificial (Other)
+asm      as    Assamese
+ath            Athapascan languages
+map            Austronesian (Other)
+ava            Avaric
+ave            Avestan
+awa            Awadhi
+aym      ay    Aymara
+aze      az    Azerbaijani
+nah            Aztec
+ban            Balinese
+bat            Baltic (Other)
+bal            Baluchi
+bam            Bambara
+bai            Bamileke languages
+bad            Banda
+bnt            Bantu (Other)
+bas            Basa
+bak      ba    Bashkir
+baq/eus  eu    Basque
+bej            Beja
+bem            Bemba
+ben      bn    Bengali
+ber            Berber (Other)
+bho            Bhojpuri
+bih      bh    Bihari
+bik            Bikol
+bin            Bini
+bis      bi    Bislama
+bra            Braj
+bre      br    Breton
+bug            Buginese
+bul      bg    Bulgarian
+bua            Buriat
+bur/mya  my    Burmese
+bel      be    Byelorussian
+cad            Caddo
+car            Carib
+cat      ca    Catalan
+cau            Caucasian (Other)
+ceb            Cebuano
+cel            Celtic (Other)
+cai            Central American Indian (Other)
+chg            Chagatai
+cha            Chamorro
+che            Chechen
+chr            Cherokee
+chy            Cheyenne
+chb            Chibcha
+chi/zho  zh    Chinese
+chn            Chinook jargon
+cho            Choctaw
+chu            Church Slavic
+chv            Chuvash
+cop            Coptic
+cor            Cornish
+cos      co    Corsican
+cre            Cree
+mus            Creek
+crp            Creoles and Pidgins (Other)
+cpe            Creoles and Pidgins, English-based (Other)
+cpf            Creoles and Pidgins, French-based (Other)
+cpp            Creoles and Pidgins, Portuguese-based (Other)
+cus            Cushitic (Other)
+hrv      hr    Croatian
+ces/cze  cs    Czech
+dak            Dakota
+dan      da    Danish
+del            Delaware
+din            Dinka
+div            Divehi
+doi            Dogri
+dra            Dravidian (Other)
+dua            Duala
+dut/nla  nl    Dutch
+dum            Dutch, Middle (ca. 1050-1350)
+dyu            Dyula
+dzo      dz    Dzongkha
+efi            Efik
+egy            Egyptian (Ancient)
+eka            Ekajuk
+elx            Elamite
+eng      en    English
+enm            English, Middle (ca. 1100-1500)
+ang            English, Old (ca. 450-1100)
+esk            Eskimo (Other)
+epo      eo    Esperanto
+est      et    Estonian
+ewe            Ewe
+ewo            Ewondo
+fan            Fang
+fat            Fanti
+fao      fo    Faroese
+fij      fj    Fijian
+fin      fi    Finnish
+fiu            Finno-Ugrian (Other)
+fon            Fon
+fra/fre  fr    French
+frm            French, Middle (ca. 1400-1600)
+fro            French, Old (842- ca. 1400)
+fry      fy    Frisian
+ful            Fulah
+gaa            Ga
+gae/gdh        Gaelic (Scots)
+glg      gl    Gallegan
+lug            Ganda
+gay            Gayo
+gez            Geez
+geo/kat  ka    Georgian
+deu/ger  de    German
+gmh            German, Middle High (ca. 1050-1500)
+goh            German, Old High (ca. 750-1050)
+gem            Germanic (Other)
+gil            Gilbertese
+gon            Gondi
+got            Gothic
+grb            Grebo
+grc            Greek, Ancient (to 1453)
+ell/gre  el    Greek, Modern (1453-)
+kal      kl    Greenlandic
+grn      gn    Guarani
+guj      gu    Gujarati
+hai            Haida
+hau      ha    Hausa
+haw            Hawaiian
+heb      he    Hebrew
+her            Herero
+hil            Hiligaynon
+him            Himachali
+hin      hi    Hindi
+hmo            Hiri Motu
+hun      hu    Hungarian
+hup            Hupa
+iba            Iban
+ice/isl  is    Icelandic
+ibo            Igbo
+ijo            Ijo
+ilo            Iloko
+inc            Indic (Other)
+ine            Indo-European (Other)
+ind      id    Indonesian
+ina      ia    Interlingua (International Auxiliary language Association)
+ile            Interlingue
+iku      iu    Inuktitut
+ipk      ik    Inupiak
+ira            Iranian (Other)
+gai/iri  ga    Irish
+sga            Irish, Old (to 900)
+mga            Irish, Middle (900 - 1200)
+iro            Iroquoian languages
+ita      it    Italian
+jpn      ja    Japanese
+jav      jv    Javanese
+jrb            Judeo-Arabic
+jpr            Judeo-Persian
+kab            Kabyle
+kac            Kachin
+kam            Kamba
+kan      kn    Kannada
+kau            Kanuri
+kaa            Kara-Kalpak
+kar            Karen
+kas      ks    Kashmiri
+kaw            Kawi
+kaz      kk    Kazakh
+kha            Khasi
+khm      km    Khmer
+khi            Khoisan (Other)
+kho            Khotanese
+kik            Kikuyu
+kin      rw    Kinyarwanda
+kir      ky    Kirghiz
+kom            Komi
+kon            Kongo
+kok            Konkani
+kor      ko    Korean
+kpe            Kpelle
+kro            Kru
+kua            Kuanyama
+kum            Kumyk
+kur      ku    Kurdish
+kru            Kurukh
+kus            Kusaie
+kut            Kutenai
+lad            Ladino
+lah            Lahnda
+lam            Lamba
+oci      oc    Langue d'Oc (post 1500)
+lao      lo    Lao
+lat      la    Latin
+lav      lv    Latvian
+ltz            Letzeburgesch
+lez            Lezghian
+lin      ln    Lingala
+lit      lt    Lithuanian
+loz            Lozi
+lub            Luba-Katanga
+lui            Luiseno
+lun            Lunda
+luo            Luo (Kenya and Tanzania)
+mac/mke  mk    Macedonian
+mad            Madurese
+mag            Magahi
+mai            Maithili
+mak            Makasar
+mlg      mg    Malagasy
+may/msa  ms    Malay
+mal            Malayalam
+mlt      ml    Maltese
+man            Mandingo
+mni            Manipuri
+mno            Manobo languages
+max            Manx
+mao/mri  mi    Maori
+mar      mr    Marathi
+chm            Mari
+mah            Marshall
+mwr            Marwari
+mas            Masai
+myn            Mayan languages
+men            Mende
+mic            Micmac
+min            Minangkabau
+mis            Miscellaneous (Other)
+moh            Mohawk
+mol      mo    Moldavian
+mkh            Mon-Kmer (Other)
+lol            Mongo
+mon      mn    Mongolian
+mos            Mossi
+mul            Multiple languages
+mun            Munda languages
+nau      na    Nauru
+nav            Navajo
+nde            Ndebele, North
+nbl            Ndebele, South
+ndo            Ndongo
+nep      ne    Nepali
+new            Newari
+nic            Niger-Kordofanian (Other)
+ssa            Nilo-Saharan (Other)
+niu            Niuean
+non            Norse, Old
+nai            North American Indian (Other)
+nor      no    Norwegian
+nno            Norwegian (Nynorsk)
+nub            Nubian languages
+nym            Nyamwezi
+nya            Nyanja
+nyn            Nyankole
+nyo            Nyoro
+nzi            Nzima
+oji            Ojibwa
+ori      or    Oriya
+orm      om    Oromo
+osa            Osage
+oss            Ossetic
+oto            Otomian languages
+pal            Pahlavi
+pau            Palauan
+pli            Pali
+pam            Pampanga
+pag            Pangasinan
+pan      pa    Panjabi
+pap            Papiamento
+paa            Papuan-Australian (Other)
+fas/per  fa    Persian
+peo            Persian, Old (ca 600 - 400 B.C.)
+phn            Phoenician
+pol      pl    Polish
+pon            Ponape
+por      pt    Portuguese
+pra            Prakrit languages
+pro            Provencal, Old (to 1500)
+pus      ps    Pushto
+que      qu    Quechua
+roh      rm    Rhaeto-Romance
+raj            Rajasthani
+rar            Rarotongan
+roa            Romance (Other)
+ron/rum  ro    Romanian
+rom            Romany
+run      rn    Rundi
+rus      ru    Russian
+sal            Salishan languages
+sam            Samaritan Aramaic
+smi            Sami languages
+smo      sm    Samoan
+sad            Sandawe
+sag      sg    Sango
+san      sa    Sanskrit
+srd            Sardinian
+sco            Scots
+sel            Selkup
+sem            Semitic (Other)
+         sr    Serbian
+scr      sh    Serbo-Croatian
+srr            Serer
+shn            Shan
+sna      sn    Shona
+sid            Sidamo
+bla            Siksika
+snd      sd    Sindhi
+sin      si    Singhalese
+sit            Sino-Tibetan (Other)
+sio            Siouan languages
+sla            Slavic (Other)
+         ss    Siswati
+slk/slo  sk    Slovak
+slv      sl    Slovenian
+sog            Sogdian
+som      so    Somali
+son            Songhai
+wen            Sorbian languages
+nso            Sotho, Northern
+sot      st    Sotho, Southern
+sai            South American Indian (Other)
+esl/spa  es    Spanish
+suk            Sukuma
+sux            Sumerian
+sun      su    Sudanese
+sus            Susu
+swa      sw    Swahili
+ssw            Swazi
+sve/swe  sv    Swedish
+syr            Syriac
+tgl      tl    Tagalog
+tah            Tahitian
+tgk      tg    Tajik
+tmh            Tamashek
+tam      ta    Tamil
+tat      tt    Tatar
+tel      te    Telugu
+ter            Tereno
+tha      th    Thai
+bod/tib  bo    Tibetan
+tig            Tigre
+tir      ti    Tigrinya
+tem            Timne
+tiv            Tivi
+tli            Tlingit
+tog      to    Tonga (Nyasa)
+ton            Tonga (Tonga Islands)
+tru            Truk
+tsi            Tsimshian
+tso      ts    Tsonga
+tsn      tn    Tswana
+tum            Tumbuka
+tur      tr    Turkish
+ota            Ottoman
+tuk      tk    Turkmen
+tyv            Tuvinian
+twi      tw    Twi
+uga            Ugaritic
+uig      ug    Uighur
+ukr      uk    Ukrainian
+umb            Umbundu
+und            Undetermined
+urd      ur    Urdu
+uzb      uz    Uzbek
+vai            Vai
+ven            Venda
+vie      vi    Vietnamese
+vol      vo    Volap�k
+vot            Votic
+wak            Wakashan languages
+wal            Walamo
+war            Waray
+was            Washo
+cym/wel  cy    Welsh
+wol      wo    Wolof
+xho      xh    Xhosa
+sah            Yakut
+yao            Yao
+yap            Yap
+yid      yi    Yiddish
+yor      yo    Yoruba
+zap            Zapotec
+zen            Zenaga
+zha      za    Zhuang
+zul      zu    Zulu
+zun            Zuni

data/lib/language/current.rb

@@ -0,0 +1 @@
+

data/lib/language/dsl.rb

@@ -0,0 +1 @@
+

data/lib/language/matcher.rb

@@ -0,0 +1,147 @@
+require 'language/class'
+
+class Language
+
+  #= Matcher
+  #
+  # Matcher derives from Ruby Quiz #103, the DictionaryMatcher quiz.
+
+  class Matcher
+
+    attr_reader :word_count
+
+    #Contains the index matched, and the word matched
+    class MatchData < Struct.new(:index,:match)
+      def inspect
+        "#{match.inspect}@#{index}"
+      end
+    end
+
+    def inspect
+      to_s
+    end
+
+    #Create a DictionaryMatcher with no words in it
+    def initialize
+      @trie = {}
+      @word_count = 0
+    end
+
+    #Add a word to the DictionaryMatcher
+    def add(word)
+      @word_count += 1
+      container = @trie
+      containers=[]
+
+      i=0
+      word.each_byte do |b|
+        container[b] = {} unless container.has_key? b
+        container[:depth]=i
+        containers << container
+        container = container[b]
+        i+=1
+      end
+      containers << container
+
+      container[0] = true # Mark end of word
+      container[:depth]=i
+
+      ff=compute_failure_function word
+      ff.zip(containers).each do |pointto,container|
+        container[:failure]=containers[pointto] if pointto
+      end
+
+      self
+
+    end
+
+    alias << add
+
+    def compute_failure_function p
+      m=p.size
+      pi=[nil,0]
+      k=0
+      2.upto m do |q|
+        k=pi[k] while k>0 and p[k] != p[q-1]
+        k=k+1 if p[k]==p[q-1]
+        pi[q]=k
+      end
+      pi
+    end
+    private :compute_failure_function
+
+     #Determine whether +string+ was previously <tt>add</tt>ed to the
+     #Trie.
+    def include?(word)
+      container = @trie
+      word.each_byte do |b|
+        break unless container.has_key? b
+        container = container[b]
+      end
+      container[0]
+    end
+
+     #Determines whether one of the words in the DictionaryMatcher is a
+     #substring of
+     #+string+. Returns the index of the match if found, +nil+ if not
+     #found.
+    def =~ text
+      internal_match(text){|md| return md.index}
+      nil
+    end
+
+     #Determine whether one of the words in the DictionaryMatcher is a
+     #substring of
+     #+string+. Returns a DictionaryMatcher::MatchData object if found,
+     #+nil+ if not #found.
+    def match text
+      internal_match(text){|md| return md}
+      nil
+    end
+
+    def internal_match string
+        node=@trie
+        pos=0
+        string.each_byte do |b|
+	   advance=false
+	   until advance
+	      nextnode=node[b]
+	      if not nextnode
+	         if node[:failure]
+		    node=node[:failure]
+	         else
+		    advance=true
+	         end
+	      elsif nextnode[0]
+	         yield MatchData.new(pos, string[pos+1-nextnode[:depth],nextnode[:depth]])
+	         advance=true
+	         node=@trie
+	      else
+	         advance=true
+	         node=nextnode
+	      end
+	      pos+=1
+	   end
+        end
+    end
+    private :internal_match
+
+     #Scans +string+ for all occurrances of strings in the
+     #DictionaryMatcher.
+     #Overlapping matches are skipped (only the first one is yielded), and
+     #when some strings in the
+     #DictionaryMatcher are substrings of others, only the shortest match
+     #at a given position is found.
+    def scan(text, &block)
+      matches=[]
+      block= lambda{ |md| matches << md } unless block
+      internal_match(text,&block)
+      matches
+    end
+
+    #Case equality. Similar to =~.
+    alias_method :===, :=~
+  end
+
+end
+

data/lib/language/mixin.rb

@@ -0,0 +1,32 @@
+require 'language/class'
+
+class Language
+
+  module Mixin
+    #
+    def method_missing(s,*a,&b)
+      return super(s,*a,&b) if s == Language.current.to_sym
+
+      lang = __send__(Language.current)
+      if lang && lang.respond_to?(s)
+        lang.__send__(s,*a,&b)
+      else
+        super(s,*a,&b)
+      end
+    end
+  end
+
+end
+
+class String
+  include Language::Mixin
+end
+
+class Numeric
+  include Language::Mixin
+end
+
+class Array
+  include Language::Mixin
+end
+

data/lib/language/words.rb

@@ -0,0 +1,152 @@
+# This module charaterizes the most common forms of Orthography
+# in computer systems --words divided by spaces, used paragraphs
+# by blank lines, and so on.
+
+require 'language/class'
+
+class Language
+
+  # If block given, iterate through each word.
+  #
+  #   "a string".each_word { |word, range| ... }
+  #    
+  # Returns an array of words.
+  #
+  #   "abc 123".words  #=> ["abc","123"]
+  #
+  def self.words(string, &yld)
+    if block_given?
+      string.scan(/([-'\w]+)/).each do |word|
+        range = $~.begin(0)...$~.end(0)
+        if yld.arity == 1
+          yld.call(word)
+        else
+          yld.call(word, range)
+        end
+      end
+    else
+      string.scan(/([-'\w]+)/).flatten
+    end
+  end
+
+  #
+  def self.sentences(string, &yld)
+    if block_given?
+      string.scan(/(.*?\.\ )/).each do |sentence|
+        range = $~.begin(0)...$~.end(0)
+        if yld.arity == 1
+          yld.call(sentence)
+        else
+          yld.call(sentence, range)
+        end
+      end
+    else
+      string.scan(/(.*?\.\ )/)
+    end
+  end
+
+  #
+  def self.paragraphs(string, &yld)
+    if block_given?
+      string.scan(/(.*?\n\s{2,})/).each do |paragraph|
+        range = $~.begin(0)...$~.end(0)
+        if yld.arity == 1
+          yld.call(paragraph)
+        else
+          yld.call(paragraph, range)
+        end
+      end
+    else
+      string.scan(/(.*?\n\s{2,})/)
+    end
+  end
+
+  # Word wrap a string not exceeding max width.
+  #
+  #   puts "this is a test".word_wrap(4)
+  #
+  # _produces_
+  #
+  #   this
+  #   is a
+  #   test
+  #
+  # CREDIT: Gavin Kistner
+  # CREDIT: Dayne Broderson
+
+  def self.word_wrap(string, col_width=79)
+    string = string.gsub( /(\S{#{col_width}})(?=\S)/, '\1 ' )
+    string = string.gsub( /(.{1,#{col_width}})(?:\s+|$)/, "\\1\n" )
+    string
+  end
+
+=begin
+  # TODO: This is alternateive from glue: worth providing?
+  #
+  # Enforces a maximum width of a string inside an
+  # html container. If the string exceeds this maximum width
+  # the string gets wraped.
+  #
+  # Not really useful, better use the CSS overflow: hidden
+  # functionality.
+  #
+  # === Input:
+  # the string to be wrapped
+  # the enforced width
+  # the separator used for wrapping
+  #
+  # === Output:
+  # the wrapped string
+  #
+  # === Example:
+  #  text = "1111111111111111111111111111111111111111111"
+  #  text = wrap(text, 10, " ")
+  #  p text # => "1111111111 1111111111 1111111111"
+  #
+  # See the test cases to better understand the behaviour!
+
+  #   def wrap(width = 20, separator = " ")
+  #     re = /([^#{separator}]{1,#{width}})/
+  #     scan(re).join(separator)
+  #   end
+=end
+
+  def words(&blk)
+    self.class.words(@self, &blk)
+  end
+
+  #
+  def each_word(&blk)
+    words(&blk)
+  end
+
+  def sentences(&yld)
+    self.class.sentences(@self, &blk)
+  end
+
+  #
+  def each_sentence(&blk)
+    sentences(&blk)
+  end
+
+  def paragrpahs(&yld)
+    self.class.paragraphs(@self, &blk)
+  end
+
+  #
+  def each_paragraph(&blk)
+    paragraphs(&blk)
+  end
+
+  #
+  def word_wrap(col_width=79)
+    self.class.word_wrap(@self, col_width)
+  end
+
+  # As with #word_wrap, but modifies the string in place.
+  def word_wrap!(col_width=79)
+    @self.replace(word_wrap(col_width=79))
+  end
+
+end
+

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: language
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 6
+  - 0
+  version: 0.6.0
+platform: ruby
+authors: 
+- Thomas Sawyer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-28 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: Language is a support library for other langauge libraries. While some of it's contents are prefectly usable on there own, most are generally intended to be subclassed and extended  by specific language modules, such as English.
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- lib/language/censor.rb
+- lib/language/class.rb
+- lib/language/codes.rb
+- lib/language/codes_iso639.txt
+- lib/language/current.rb
+- lib/language/dsl.rb
+- lib/language/matcher.rb
+- lib/language/mixin.rb
+- lib/language/words.rb
+- lib/language.rb
+- HISTORY.rdoc
+- PROFILE
+- LICENSE
+- README.rdoc
+- REQUIRE
+- VERSION
+has_rdoc: true
+homepage: http://rubyworks.github.com/language
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --title
+- Language API
+- --main
+- README.rdoc
+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: language
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Language Support Library
+test_files: []
+