langue 0.0.2

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in langue.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Takahiro Kondo
+
+MIT License
+
+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,57 @@
+What is langue
+==============
+
+It is the foundation to provide the operations to the natural languages.
+
+Installation
+------------
+
+Add this line to your application's Gemfile:
+
+    gem 'langue'
+
+    # When using Japanese
+    gem 'langue-japanese'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install langue
+    $ gem install langue-japanese
+
+Usage
+-----
+
+    # coding: utf-8
+    require 'langue-japanese'
+
+    # Get a language class
+    language = Langue['japanese'].new
+
+    # Split to morphemes a text
+    morphemes = language.parse('今日は妹と一緒にお買い物してきたよ。楽しかった〜')
+
+    # Create a structured text from the morphemes
+    text = language.structure(morphemes)
+
+    # When using English
+    require 'langue-english'
+
+    other_language = Langue['english'].new
+
+If tiresome to require gem for each language, you will write the code following
+instead:
+
+    require 'langue/all'
+
+Contributing
+------------
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/langue.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/langue/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Takahiro Kondo"]
+  gem.email         = ["kondo@atedesign.net"]
+  gem.description   = %q{It is the foundation to provide the operations to the natural languages.}
+  gem.summary       = %q{The foundation for the natural languages}
+  gem.homepage      = ""
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "langue"
+  gem.require_paths = ["lib"]
+  gem.version       = Langue::VERSION
+
+  gem.add_runtime_dependency 'activesupport'
+
+  gem.add_development_dependency 'rspec'
+end

data/lib/langue.rb

@@ -0,0 +1,47 @@
+require 'langue/version'
+require 'langue/language'
+require 'langue/exceptions'
+
+module Langue
+  extend self
+
+  @languages = {}
+
+  def languages
+    @languages.values
+  end
+
+  def support(language_class)
+    id = to_language_id(language_class)
+    raise LanguageAlreadySupported, "'#{language_class.name}' language is supported already" if @languages.key?(id)
+    @languages[id] = language_class
+  end
+
+  def unsupport(language_spec)
+    id = to_language_id(language_spec)
+    raise unsupported!(language_spec) unless @languages.key?(id)
+    @languages.delete(id)
+  end
+
+  def unsupport_all
+    @languages.clear
+  end
+
+  def language(language_spec)
+    id = to_language_id(language_spec)
+    raise unsupported!(language_spec) unless @languages.key?(id)
+    @languages[id]
+  end
+  alias [] language
+
+  private
+
+  def to_language_id(language_spec)
+    Class === language_spec ? language_spec.id : language_spec.to_s.downcase
+  end
+
+  def unsupported!(language_spec)
+    name = Class === language_spec ? language_spec.name : language_spec
+    raise LanguageUnsupported, "'#{name}' language is unsupported"
+  end
+end

data/lib/langue/all.rb

@@ -0,0 +1,3 @@
+Gem::Specification.each do |gem|
+  require gem.name if gem.name =~ /^langue-/
+end

data/lib/langue/exceptions.rb

@@ -0,0 +1,5 @@
+module Langue
+  class InvalidDefinition        < StandardError; end
+  class LanguageUnsupported      < StandardError; end
+  class LanguageAlreadySupported < StandardError; end
+end

data/lib/langue/language.rb

@@ -0,0 +1,31 @@
+require 'active_support/core_ext/string/inflections'
+
+require 'langue/exceptions'
+
+module Langue
+  class Language
+    class << self
+      def id
+        parts = name.split('::').reverse.drop_while { |part| part == 'Language' }
+        raise InvalidDefinition, "'#{name}' is invalid definition" if parts.empty?
+        parts.first.underscore
+      end
+
+      def depend_to(orig_method_name, *gems)
+        method_name = "_#{orig_method_name}"
+        alias_method(method_name, orig_method_name) unless respond_to?(method_name)
+
+        define_method(orig_method_name) do |*args|
+          gems.each { |gem| require gem }
+          value = __send__(method_name, *args)
+          self.class.class_eval { alias_method(orig_method_name, method_name) }
+          value
+        end
+      end
+    end
+
+    def initialize(options = {})
+      @options = options
+    end
+  end
+end

data/lib/langue/morpheme.rb

@@ -0,0 +1,30 @@
+module Langue
+  class Morpheme
+    KEYS = %w(
+      text
+      part_of_speech
+      categories
+      inflection
+      inflection_type
+      root_form
+      yomi
+      pronunciation
+    ).map(&:to_sym)
+
+    def initialize(attrs)
+      KEYS.each { |key| instance_variable_set("@#{key}", attrs[key]) }
+    end
+
+    attr_reader(*KEYS)
+
+    def classified?(part_of_speech, *categories)
+      got = [@part_of_speech] + @categories
+      expected = [part_of_speech] + categories
+      expected.zip(got).all? { |pair| pair[0] == pair[1] }
+    end
+
+    def inflected?(inflection)
+      @inflection == inflection
+    end
+  end
+end

data/lib/langue/morphemes.rb

@@ -0,0 +1,22 @@
+require 'langue/morpheme'
+
+module Langue
+  class Morphemes < Array
+    def valid?
+      all? { |morpheme| Morpheme === morpheme }
+    end
+
+    def at(index)
+      morpheme = self[index]
+      morpheme.nil? || !block_given? ? morpheme : yield(morpheme)
+    end
+
+#     def match?(index, text)
+#       at(index) {|morpheme| morpheme.text == text}
+#     end
+
+#     def after(index)
+#       self[index..-1]
+#     end
+  end
+end

data/lib/langue/sentence.rb

@@ -0,0 +1,18 @@
+require 'langue/morphemes'
+require 'langue/word'
+
+module Langue
+  class Sentence < Array
+    def valid?
+      all? { |word| Word === word && word.valid? }
+    end
+
+    def words
+      self
+    end
+
+    def morphemes
+      @morphemes ||= Morphemes.new(flatten)
+    end
+  end
+end

data/lib/langue/text.rb

@@ -0,0 +1,22 @@
+require 'langue/morphemes'
+require 'langue/sentence'
+
+module Langue
+  class Text < Array
+    def valid?
+      all? { |sentence| Sentence === sentence && sentence.valid? }
+    end
+
+    def sentences
+      self
+    end
+
+    def words
+      @words ||= inject(&:+)
+    end
+
+    def morphemes
+      @morphemes ||= Morphemes.new(flatten)
+    end
+  end
+end

data/lib/langue/version.rb

@@ -0,0 +1,3 @@
+module Langue
+  VERSION = '0.0.2'
+end

data/lib/langue/word.rb

@@ -0,0 +1,64 @@
+require 'langue/morphemes'
+require 'langue/morpheme'
+
+module Langue
+  class Word < Array
+    def valid?
+      all? { |morpheme| Morpheme === morpheme }
+    end
+
+    def morphemes
+      @morphemes ||= Morphemes.new(self)
+    end
+
+    alias key_morpheme last
+
+    def text
+      @text = not_empty? { map(&:text) } unless instance_variable_defined?(:@text)
+      @text
+    end
+
+    def inflection
+      @inflection = value_in_key_morpheme(:inflection) unless instance_variable_defined?(:@inflection)
+      @inflection
+    end
+
+    def inflection_type
+      @inflection_type = value_in_key_morpheme(:inflection_type) unless instance_variable_defined?(:@inflection_type)
+      @inflection_type
+    end
+
+    def root_form
+      @root_form = not_empty? { self[0..-2].map(&:text) + self[-1, 1].map(&:root_form) } unless instance_variable_defined?(:@root_form)
+      @root_form
+    end
+
+    def yomi
+      @yomi = join_values(:yomi) unless instance_variable_defined?(:@yomi)
+      @yomi
+    end
+
+    def pronunciation
+      @pronunciation = join_values(:pronunciation) unless instance_variable_defined?(:@pronunciation)
+      @pronunciation
+    end
+
+    private
+
+    def not_empty?
+      empty? ? nil : yield.join
+    end
+
+    def value_in_key_morpheme(key)
+      morpheme = key_morpheme
+      morpheme.nil? ? nil : morpheme.__send__(key)
+    end
+
+    def join_values(key)
+      empty? ? nil : begin
+                       values = map(&key)
+                       values.any? { |value| value.nil? } ? nil : values.join
+                     end
+    end
+  end
+end

data/spec/langue/language_spec.rb

@@ -0,0 +1,46 @@
+require 'langue/language'
+
+module Example
+  class LanguageExample < Langue::Language
+    def parse(text)
+      text
+    end
+    depend_to :parse, 'example/language_example/parser'
+  end
+
+  class Language < Langue::Language
+  end
+end
+
+class Language < Langue::Language
+end
+
+describe Langue::Language, '.id' do
+  it 'returns the class name based underscore' do
+    Example::LanguageExample.id.should == 'language_example'
+  end
+
+  it 'returns the class name of the parent that are separated by the namespace if the name of the language class is "Language"' do
+    Example::Language.id.should == 'example'
+  end
+
+  it 'raises Langue::InvalidDefinition if the name of the language class is "Language" and it is the top level object' do
+    lambda { Language.id }.should raise_error(Langue::InvalidDefinition, /'Language'/)
+  end
+end
+
+describe Langue::Language, '.depend_to' do
+  before do
+    @language = Example::LanguageExample.new
+  end
+
+  it 'calls require method' do
+    @language.should_receive(:require).with('example/language_example/parser')
+    @language.parse('text')
+  end
+
+  it 'does not call require method more than once' do
+    @language.should_not_receive(:require)
+    @language.parse('text')
+  end
+end

data/spec/langue/morpheme_spec.rb

@@ -0,0 +1,105 @@
+require 'langue/morpheme'
+
+describe Langue::Morpheme, ' accessors' do
+  before do
+    @morpheme = described_class.new(
+      :text            => 'text',
+      :part_of_speech  => 'part_of_speech',
+      :categories      => %w(category1 category2),
+      :inflection      => 'inflection',
+      :inflection_type => 'inflection_type',
+      :root_form       => 'root_form',
+      :yomi            => 'yomi',
+      :pronunciation   => 'pronunciation'
+    )
+  end
+
+  it 'returns the text by text method' do
+    @morpheme.text.should == 'text'
+  end
+
+  it 'returns the part of speech by part_of_speech method' do
+    @morpheme.part_of_speech.should == 'part_of_speech'
+  end
+
+  it 'returns the categories by categories method' do
+    @morpheme.categories.should == %w(category1 category2)
+  end
+
+  it 'returns the inflection by inflection method' do
+    @morpheme.inflection.should == 'inflection'
+  end
+
+  it 'returns the type of the inflection by inflection_type method' do
+    @morpheme.inflection_type.should == 'inflection_type'
+  end
+
+  it 'returns the root form by root_form method' do
+    @morpheme.root_form.should == 'root_form'
+  end
+
+  it 'returns the yomi by yomi method' do
+    @morpheme.yomi.should == 'yomi'
+  end
+
+  it 'returns the pronunciation by pronunciation method' do
+    @morpheme.pronunciation.should == 'pronunciation'
+  end
+end
+
+describe Langue::Morpheme, '#classified?' do
+  before do
+    @morpheme = described_class.new(
+      :part_of_speech => 'part_of_speech',
+      :categories     => %w(category1 category2)
+    )
+  end
+
+  it 'returns true if part of speech matched' do
+    @morpheme.should be_classified('part_of_speech')
+  end
+
+  it 'returns false if part of speech did not match' do
+    @morpheme.should_not be_classified('part_0f_speech')
+  end
+
+  context 'with fewer than the categories' do
+    it 'returns true if matched' do
+      @morpheme.should be_classified('part_of_speech', 'category1')
+    end
+
+    it 'returns false if not matched' do
+      @morpheme.should_not be_classified('part_of_speech', 'category10')
+    end
+  end
+
+  context 'with equal to the categories' do
+    it 'returns true if matched' do
+      @morpheme.should be_classified('part_of_speech', 'category1', 'category2')
+    end
+
+    it 'returns false if not matched' do
+      @morpheme.should_not be_classified('part_of_speech', 'category1', 'category20')
+    end
+  end
+
+  context 'with many than the categories' do
+    it 'returns false' do
+      @morpheme.should_not be_classified('part_of_speech', 'category1', 'category2', 'category3')
+    end
+  end
+end
+
+describe Langue::Morpheme, '#inflected?' do
+  before do
+    @morpheme = described_class.new(:inflection => 'inflection')
+  end
+
+  it 'returns true if inflection matched' do
+    @morpheme.should be_inflected('inflection')
+  end
+
+  it 'returns false if inflection did not match' do
+    @morpheme.should_not be_inflected('inflecti0n')
+  end
+end

data/spec/langue/morphemes_spec.rb

@@ -0,0 +1,73 @@
+require 'langue/morphemes'
+
+describe Langue::Morphemes, '#valid?' do
+  before do
+    @morphemes = described_class.new([
+      Langue::Morpheme.new({}),
+      Langue::Morpheme.new({}),
+      Langue::Morpheme.new({})
+    ])
+  end
+
+  context 'with all morphemes' do
+    it 'returns true' do
+      @morphemes.should be_valid
+    end
+  end
+
+  context 'with including non-morpheme' do
+    before do
+      @morphemes[1] = 'invalid_as_morpheme'
+    end
+
+    it do
+      @morphemes.should_not be_valid
+    end
+  end
+end
+
+describe Langue::Morphemes, '#at' do
+  before do
+    @morphemes = described_class.new([1, 2, 3])
+  end
+
+  it 'returns a morpheme at the position of the index' do
+    morpheme = @morphemes.at(0)
+    morpheme.should == 1
+  end
+
+  context 'with do not have a morpheme at the position of the index' do
+    it 'returns nil' do
+      morpheme = @morphemes.at(3)
+      morpheme.should be_nil
+    end
+  end
+
+  context 'with a block' do
+    it 'passes to the block a morpheme at the position of the index' do
+      @morphemes.at(0) { |morpheme| morpheme.should == 1 }
+    end
+
+    it 'returns the value returned from the block' do
+      value = @morphemes.at(0) { |morpheme| 'value' }
+      value.should == 'value'
+    end
+
+    context 'with do not have a morpheme at the position of the index' do
+      it 'does not call the block' do
+        lambda { @morphemes.at(3) { |morpheme| fail } }.should_not raise_error
+      end
+
+      it 'returns nil' do
+        value = @morphemes.at(3) { |morpheme| fail }
+        value.should be_nil
+      end
+    end
+  end
+end
+
+# describe Langue::Morphemes, '#match?' do
+# end
+
+# describe Langue::Morphemes, '#after' do
+# end

data/spec/langue/sentence_spec.rb

@@ -0,0 +1,57 @@
+require 'langue/sentence'
+
+describe Langue::Sentence, '#valid?' do
+  before do
+    @sentence = described_class.new([
+      Langue::Word.new,
+      Langue::Word.new,
+      Langue::Word.new
+    ])
+  end
+
+  context 'with all words' do
+    it 'returns true' do
+      @sentence.should be_valid
+    end
+  end
+
+  context 'with including non-word' do
+    before do
+      @sentence[1] = 'invalid_as_word'
+    end
+
+    it 'returns false' do
+      @sentence.should_not be_valid
+    end
+  end
+end
+
+describe Langue::Sentence, '#words' do
+  before do
+    sentence = described_class.new([[1, 2], [3, 4]])
+    @words = sentence.words
+  end
+
+  it 'returns an instance of Array' do
+    @words.should be_an Array
+  end
+
+  it 'returns the words' do
+    @words.should == [[1, 2], [3, 4]]
+  end
+end
+
+describe Langue::Sentence, '#morphemes' do
+  before do
+    sentence = described_class.new([[1, 2], [3, 4]])
+    @morphemes = sentence.morphemes
+  end
+
+  it 'returns an instance of Langue::Morphemes' do
+    @morphemes.should be_a Langue::Morphemes
+  end
+
+  it 'returns the morphemes in the words' do
+    @morphemes.should == [1, 2, 3, 4]
+  end
+end

data/spec/langue/text_spec.rb

@@ -0,0 +1,72 @@
+require 'langue/text'
+
+describe Langue::Text, '#valid?' do
+  before do
+    @text = described_class.new([
+      Langue::Sentence.new,
+      Langue::Sentence.new,
+      Langue::Sentence.new
+    ])
+  end
+
+  context 'with all sentences' do
+    it 'returns true' do
+      @text.should be_valid
+    end
+  end
+
+  context 'with including non-sentence' do
+    before do
+      @text[1] = 'invalid_as_sentence'
+    end
+
+    it 'returns false' do
+      @text.should_not be_valid
+    end
+  end
+end
+
+describe Langue::Text, '#sentences' do
+  before do
+    text = described_class.new([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
+    @sentences = text.sentences
+  end
+
+  it 'returns an instance of Array' do
+    @sentences.should be_an Array
+  end
+
+  it 'returns the sentences' do
+    @sentences.should == [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
+  end
+end
+
+describe Langue::Text, '#words' do
+  before do
+    text = described_class.new([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
+    @words = text.words
+  end
+
+  it 'returns an instance of Array' do
+    @words.should be_an Array
+  end
+
+  it 'returns the words in the sentences' do
+    @words.should == [[1, 2], [3, 4], [5, 6], [7, 8]]
+  end
+end
+
+describe Langue::Text, '#morphemes' do
+  before do
+    text = described_class.new([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
+    @morphemes = text.morphemes
+  end
+
+  it 'returns an instance of Langue::Morphemes' do
+    @morphemes.should be_a Langue::Morphemes
+  end
+
+  it 'returns the morphemes in the words in the sentences' do
+    @morphemes.should == [1, 2, 3, 4, 5, 6, 7, 8]
+  end
+end

data/spec/langue/word_spec.rb

@@ -0,0 +1,261 @@
+require 'langue/word'
+
+describe Langue::Word, '#valid?' do
+  before do
+    @word = described_class.new([
+      Langue::Morpheme.new({}),
+      Langue::Morpheme.new({}),
+      Langue::Morpheme.new({})
+    ])
+  end
+
+  context 'with all morphemes' do
+    it 'returns true' do
+      @word.should be_valid
+    end
+  end
+
+  context 'with including non-morpheme' do
+    before do
+      @word[1] = 'invalid_as_morpheme'
+    end
+
+    it 'returns false' do
+      @word.should_not be_valid
+    end
+  end
+end
+
+describe Langue::Word, '#morphemes' do
+  before do
+    word = described_class.new([1, 2, 3])
+    @morphemes = word.morphemes
+  end
+
+  it 'returns an instance of Langue::Morphemes' do
+    @morphemes.should be_a Langue::Morphemes
+  end
+
+  it 'returns ' do
+    @morphemes.should == [1, 2, 3]
+  end
+end
+
+describe Langue::Word, '#key_morpheme' do
+  before do
+    word = described_class.new([1, 2, 3])
+    @morpheme = word.key_morpheme
+  end
+
+  it 'returns the last morpheme' do
+    @morpheme.should == 3
+  end
+
+  context 'with do not have morphemes' do
+    before do
+      word = described_class.new
+      @morpheme = word.key_morpheme
+    end
+
+    it 'returns nil' do
+      @morpheme.should be_nil
+    end
+  end
+end
+
+describe Langue::Word, '#text' do
+  before do
+    word = described_class.new([
+      stub.tap { |s| s.stub!(:text).and_return('text1') },
+      stub.tap { |s| s.stub!(:text).and_return('text2') },
+      stub.tap { |s| s.stub!(:text).and_return('text3') }
+    ])
+
+    @text = word.text
+  end
+
+  it 'returns a concatenated string of the text of the morphemes' do
+    @text.should == 'text1text2text3'
+  end
+end
+
+describe Langue::Word, '#inflection' do
+  before do
+    word = described_class.new([
+      stub.tap { |s| s.stub!(:inflection).and_return('inflection1') },
+      stub.tap { |s| s.stub!(:inflection).and_return('inflection2') },
+      stub.tap { |s| s.stub!(:inflection).and_return('inflection3') }
+    ])
+
+    @inflection = word.inflection
+  end
+
+  it 'returns the inflection of the last morpheme' do
+    @inflection.should == 'inflection3'
+  end
+
+  context 'with do not have morphemes' do
+    before do
+      word = described_class.new
+      @inflection = word.inflection
+    end
+
+    it 'returns nil' do
+      @inflection.should be_nil
+    end
+  end
+end
+
+describe Langue::Word, '#inflection_type' do
+  before do
+    word = described_class.new([
+      stub.tap { |s| s.stub!(:inflection_type).and_return('inflection_type1') },
+      stub.tap { |s| s.stub!(:inflection_type).and_return('inflection_type2') },
+      stub.tap { |s| s.stub!(:inflection_type).and_return('inflection_type3') }
+    ])
+
+    @inflection_type = word.inflection_type
+  end
+
+  it 'returns the type of the inflection of the last morpheme' do
+    @inflection_type.should == 'inflection_type3'
+  end
+
+  context 'with do not have morphemes' do
+    before do
+      word = described_class.new
+      @inflection_type = word.inflection_type
+    end
+
+    it 'returns nil' do
+      @inflection_type.should be_nil
+    end
+  end
+end
+
+describe Langue::Word, '#root_form' do
+  before do
+    word = described_class.new([
+      stub.tap { |s| s.stub!(:text).and_return('text1') },
+      stub.tap { |s| s.stub!(:text).and_return('text2') },
+      stub.tap { |s| s.stub!(:root_form).and_return('root_form3') }
+    ])
+
+    @root_form = word.root_form
+  end
+
+  it 'makes only the last of the text of the morphemes the root form, and returns a concatenated string' do
+    @root_form.should == 'text1text2root_form3'
+  end
+
+  context 'with have a morpheme' do
+    before do
+      word = described_class.new([
+        stub.tap { |s| s.stub!(:root_form).and_return('root_form1') }
+      ])
+
+      @root_form = word.root_form
+    end
+
+    it 'returns the root form text of the morpheme' do
+      @root_form.should == 'root_form1'
+    end
+  end
+
+  context 'with do not have morphemes' do
+    before do
+      word = described_class.new
+      @root_form = word.root_form
+    end
+
+    it 'returns nil' do
+      @root_form.should be_nil
+    end
+  end
+end
+
+describe Langue::Word, '#yomi' do
+  before do
+    word = described_class.new([
+      stub.tap { |s| s.stub!(:yomi).and_return('yomi1') },
+      stub.tap { |s| s.stub!(:yomi).and_return('yomi2') },
+      stub.tap { |s| s.stub!(:yomi).and_return('yomi3') }
+    ])
+
+    @yomi = word.yomi
+  end
+
+  it 'returns a concatenated string of the yomi of the morphemes' do
+    @yomi.should == 'yomi1yomi2yomi3'
+  end
+
+  context 'with have morpheme without a yomi' do
+    before do
+      word = described_class.new([
+        stub.tap { |s| s.stub!(:yomi).and_return('yomi1') },
+        stub.tap { |s| s.stub!(:yomi).and_return(nil)     },
+        stub.tap { |s| s.stub!(:yomi).and_return('yomi3') }
+      ])
+
+      @yomi = word.yomi
+    end
+
+    it 'returns nil' do
+      @yomi.should be_nil
+    end
+  end
+
+  context 'with do not have morphemes' do
+    before do
+      word = described_class.new
+      @yomi = word.yomi
+    end
+
+    it 'returns nil' do
+      @yomi.should be_nil
+    end
+  end
+end
+
+describe Langue::Word, '#pronunciation' do
+  before do
+    word = described_class.new([
+      stub.tap { |s| s.stub!(:pronunciation).and_return('pronunciation1') },
+      stub.tap { |s| s.stub!(:pronunciation).and_return('pronunciation2') },
+      stub.tap { |s| s.stub!(:pronunciation).and_return('pronunciation3') }
+    ])
+
+    @pronunciation = word.pronunciation
+  end
+
+  it 'returns a concatenated string of the pronunciation of the morphemes' do
+    @pronunciation.should == 'pronunciation1pronunciation2pronunciation3'
+  end
+
+  context 'with have morpheme without a pronunciation' do
+    before do
+      word = described_class.new([
+        stub.tap { |s| s.stub!(:pronunciation).and_return('pronunciation1') },
+        stub.tap { |s| s.stub!(:pronunciation).and_return(nil)              },
+        stub.tap { |s| s.stub!(:pronunciation).and_return('pronunciation3') }
+      ])
+
+      @pronunciation = word.pronunciation
+    end
+
+    it 'returns nil' do
+      @pronunciation.should be_nil
+    end
+  end
+
+  context 'with do not have morphemes' do
+    before do
+      word = described_class.new
+      @pronunciation = word.pronunciation
+    end
+
+    it 'returns nil' do
+      @pronunciation.should be_nil
+    end
+  end
+end

data/spec/langue_spec.rb

@@ -0,0 +1,134 @@
+require 'langue'
+
+class LanguageExample      < Langue::Language; end
+class OtherLanguageExample < Langue::Language; end
+
+describe Langue do
+  it 'is an instance of Module' do
+    described_class.should be_an_instance_of Module
+  end
+
+  it 'has VERSION constant' do
+    described_class.should be_const_defined :VERSION
+  end
+end
+
+describe Langue, '.languages' do
+  before do
+    @languages = described_class.languages
+  end
+
+  it 'returns an instance of Array' do
+    @languages.should be_an Array
+  end
+
+  it 'returns an empty array in default' do
+    @languages.should be_empty
+  end
+end
+
+describe Langue, '.support' do
+  before do
+    described_class.unsupport_all
+    described_class.support(LanguageExample)
+  end
+
+  it 'adds to the supported languages' do
+    language = described_class.languages.first
+    language.should == LanguageExample
+  end
+
+  context 'with already a supported language' do
+    it "raises #{described_class}::LanguageAlreadySupported" do
+      lambda { described_class.support(LanguageExample) }.should raise_error(Langue::LanguageAlreadySupported, /LanguageExample/)
+    end
+  end
+end
+
+describe Langue, '.unsupport' do
+  before do
+    described_class.unsupport_all
+    described_class.support(LanguageExample)
+    described_class.unsupport(LanguageExample)
+  end
+
+  it 'removes from the supported languages' do
+    languages = described_class.languages
+    languages.should be_empty
+  end
+
+  context 'with not a class' do
+    before do
+      described_class.unsupport_all
+      described_class.support(LanguageExample)
+      described_class.unsupport('language_example')
+    end
+
+    it 'removes from the supported languages' do
+      languages = described_class.languages
+      languages.should be_empty
+    end
+  end
+
+  context 'with an unsupported language' do
+    before do
+      described_class.unsupport_all
+    end
+
+    it "raises #{described_class}::LanguageUnsupported" do
+      lambda { described_class.unsupport(OtherLanguageExample) }.should raise_error(Langue::LanguageUnsupported, /OtherLanguageExample/)
+    end
+
+    context 'with not a language class' do
+      it "raises #{described_class}::LanguageUnsupported" do
+        lambda { described_class.unsupport('other_language_example') }.should raise_error(Langue::LanguageUnsupported, /other_language_example/)
+      end
+    end
+  end
+end
+
+describe Langue, '.unsupport_all' do
+  it 'removes all languages from the supported languages' do
+    described_class.support(LanguageExample)
+    described_class.support(OtherLanguageExample)
+    described_class.languages.should_not be_empty
+    described_class.unsupport_all
+    described_class.languages.should be_empty
+  end
+end
+
+describe Langue, '.language' do
+  before do
+    described_class.unsupport_all
+    described_class.support(LanguageExample)
+  end
+
+  it 'returns the language class' do
+    language = described_class.language('language_example')
+    language.should == LanguageExample
+  end
+
+  context 'with an unsupported language' do
+    it "raises #{described_class}::LanguageUnsupported" do
+      lambda { described_class.language('other_language_example') }.should raise_error(Langue::LanguageUnsupported)
+    end
+  end
+end
+
+describe Langue, '.[]' do
+  before do
+    described_class.unsupport_all
+    described_class.support(LanguageExample)
+  end
+
+  it 'returns the language class' do
+    language = described_class['language_example']
+    language.should == LanguageExample
+  end
+
+  context 'with an unsupported language' do
+    it "raises #{described_class}::LanguageUnsupported" do
+      lambda { described_class['other_language_example'] }.should raise_error(Langue::LanguageUnsupported)
+    end
+  end
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: langue
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Takahiro Kondo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: It is the foundation to provide the operations to the natural languages.
+email:
+- kondo@atedesign.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- langue.gemspec
+- lib/langue.rb
+- lib/langue/all.rb
+- lib/langue/exceptions.rb
+- lib/langue/language.rb
+- lib/langue/morpheme.rb
+- lib/langue/morphemes.rb
+- lib/langue/sentence.rb
+- lib/langue/text.rb
+- lib/langue/version.rb
+- lib/langue/word.rb
+- spec/langue/language_spec.rb
+- spec/langue/morpheme_spec.rb
+- spec/langue/morphemes_spec.rb
+- spec/langue/sentence_spec.rb
+- spec/langue/text_spec.rb
+- spec/langue/word_spec.rb
+- spec/langue_spec.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.21
+signing_key: 
+specification_version: 3
+summary: The foundation for the natural languages
+test_files: []
+has_rdoc: