rhopalic 0.0.1.pre

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,2 @@
+source "http://rubygems.org"
+gemspec

data/LICENSE.md

@@ -0,0 +1,7 @@
+Copyright (c) 2013 Nik Haldimann
+
+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,34 @@
+rhopalic
+========
+
+A Ruby library to detect rhopalic phrases in English, i.e., a phrase in which each
+word contains one letter or one syllable more than the previous word.
+
+## Usage
+
+For simple yes or no answers about whether a phrase is rhopalic:
+
+	> require 'rhopalic'
+	=> true
+	> Rhopalic.letter_rhopalic?("I do not know where family doctors acquired illegibly perplexing handwriting.")
+	=> true
+	> Rhopalic.syllable_rhopalic?("Lines thicken approaching termination.")
+	=> true
+
+There is no exact algorithm for counting syllables in English. For more accurate syllable
+counting use the [CMU pronunciation dictionary](http://www.speech.cs.cmu.edu/cgi-bin/cmudict):
+
+    > require 'rhopalic'
+    > require 'rhopalic/dictionary'
+	> dict = Rhopalic::Dictionary.from_file('cmudict.0.7a')
+	=> ...
+	> analysis = Rhopalic::Analysis.new(dict)
+	=> ...
+	> analysis.analyze_phrase("Add extra syllables gradually").syllable_rhopalic?
+	=> true
+
+(This is assuming that you have the dictionary file cmudict.0.7a in your working directory.)
+
+## License
+
+Distributed under an [MIT license](https://github.com/nikhaldi/rhopalic-ruby/blob/master/LICENSE.md).

data/Rakefile

@@ -0,0 +1,13 @@
+require 'bundler'
+require 'rake/testtask'
+
+Bundler::GemHelper.install_tasks
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.test_files = FileList['test/*_test.rb']
+  test.verbose = true
+  test.warning = true
+end
+
+task :default => [:test]

data/lib/rhopalic/analysis.rb

@@ -0,0 +1,79 @@
+require 'lingua'
+
+require 'rhopalic/contractions'
+require 'rhopalic/phrase'
+
+module Rhopalic
+  class Analysis
+
+    def initialize(dictionary=nil)
+      @dictionary = dictionary
+    end
+
+    def analyze_phrase(phrase)
+      words = []
+      indices = []
+      syllable_counts = []
+      in_dictionary = []
+      is_letter_rhopalic = true
+      is_syllable_rhopalic = true
+
+      # TODO this word definition is too simple. Needs to handle:
+      # - numbers
+      phrase.scan(/[[:alpha:]]+/) do
+        match = Regexp.last_match
+        word = match[0]
+        index = match.begin(0)
+
+        # Checking whether the previous and this word form a known contraction
+        # or possessive.
+        if !indices.empty? && (phrase[indices.last + words.last.length] == "'") &&
+            (index == indices.last + words.last.length + 1)
+          contraction = words.last + "'" + word
+          if (syllable_count = CONTRACTIONS[contraction.downcase]) || word.downcase == "s"
+            words[-1] = contraction
+            if syllable_count
+              syllable_counts[-1] = syllable_count
+              in_dictionary[-1] = true
+            end
+
+            is_letter_rhopalic = false unless word_sequence_rhopalic?(words)
+            is_syllable_rhopalic = false unless syllable_sequence_rhopalic?(syllable_counts)
+            return nil unless is_letter_rhopalic || is_syllable_rhopalic
+            next
+          end
+        end
+
+        if @dictionary
+          syllable_count = @dictionary.syllable_count(word)
+          in_dictionary.push(true) unless syllable_count.nil?
+        end
+        if !syllable_count
+          syllable_count = Lingua::EN::Syllable.syllables(word)
+          in_dictionary.push(false)
+        end
+
+        words.push(word)
+        indices.push(match.begin(0))
+        syllable_counts.push(syllable_count)
+
+        is_letter_rhopalic = false unless word_sequence_rhopalic?(words)
+        is_syllable_rhopalic = false unless syllable_sequence_rhopalic?(syllable_counts)
+        return nil unless is_letter_rhopalic || is_syllable_rhopalic
+      end
+
+      return Phrase.new(phrase, is_letter_rhopalic, is_syllable_rhopalic, words, indices,
+          syllable_counts, in_dictionary)
+    end
+
+    private
+
+    def word_sequence_rhopalic?(words)
+      words.size < 2 || words[-2].length + 1 == words[-1].length
+    end
+
+    def syllable_sequence_rhopalic?(syllable_counts)
+      syllable_counts.size < 2 || syllable_counts[-2] + 1 == syllable_counts[-1]
+    end
+  end
+end

data/lib/rhopalic/contractions.rb

@@ -0,0 +1,63 @@
+module Rhopalic
+
+  # Known contractions in English mapped to syllable counts.
+  CONTRACTIONS = {
+    "aren't" => 1,
+    "can't" => 1,
+    "couldn't" => 2,
+    "didn't" => 2,
+    "doesn't" => 2,
+    "don't" => 1,
+    "hadn't" => 2,
+    "hasn't" => 2,
+    "haven't" => 2,
+    "he'd" => 1,
+    "he'll" => 1,
+    "he's" => 1,
+    "i'd" => 1,
+    "i'll" => 1,
+    "i'm" => 1,
+    "i've" => 1,
+    "isn't" => 2,
+    "it'll" => 2,
+    "it's" => 1,
+    "let's" => 1,
+    "mightn't" => 2,
+    "mustn't" => 2,
+    "shan't" => 1,
+    "she'd" => 1,
+    "she'll" => 1,
+    "she's" => 1,
+    "shouldn't" => 2,
+    "that's" => 1,
+    "there'd" => 1,
+    "there'll" => 1,
+    "there's" => 1,
+    "they'd" => 1,
+    "they'll" => 1,
+    "they're" => 1,
+    "they've" => 1,
+    "we'd" => 1,
+    "we're" => 1,
+    "we've" => 1,
+    "weren't" => 2,
+    "what'll" => 2,
+    "what're" => 2,
+    "what's" => 1,
+    "what've" => 2,
+    "where's" => 1,
+    "who'd" => 1,
+    "who'll" => 1,
+    "who're" => 1,
+    "who's" => 1,
+    "who've" => 1,
+    "won't" => 1,
+    "wouldn't" => 2,
+    "y'all" => 1,
+    "you'd" => 1,
+    "you'll" => 1,
+    "you're" => 1,
+    "you've" => 1,
+  }
+
+end

data/lib/rhopalic/dictionary.rb

@@ -0,0 +1,44 @@
+module Rhopalic
+
+  # A dictionary that maps words to of syllables. Can be passed into
+  # Rhopalic::Analysis to improve accuracy of syllable detection. Input
+  # is a pronunciation file in the format of the CMU pronunciation
+  # dictionary. See http://www.speech.cs.cmu.edu/cgi-bin/cmudict for
+  # details. The latest dictionary file from CMU should work out of the
+  # box.
+  class Dictionary
+
+    def self.from_file(filename)
+      dict = nil
+      File.open(filename) do |file|
+        dict = Dictionary.new(file)
+      end
+      dict
+    end
+
+    # Initializes a dictionary from an enumerable source of dictionary
+    # entries, e.g., an open dictionary file.
+    def initialize(input_source)
+      @input_source = input_source
+      make_dictionary
+    end
+
+    def syllable_count(word)
+      @syllable_counts[word.upcase] || nil
+    end
+
+    private
+
+    def make_dictionary
+      @syllable_counts = {}
+      @input_source.each do |line|
+				next if line !~ /^[A-Z]/i
+        line.chomp!
+        (word, *phonemes) = line.split(/ +/)
+        next if word[-1] == ")" # ignore alternative pronunciations
+        @syllable_counts[word.upcase] = phonemes.grep(/^[AEIOU]/i).length
+      end
+    end
+  end
+
+end

data/lib/rhopalic/phrase.rb

@@ -0,0 +1,31 @@
+require 'lingua'
+
+module Rhopalic
+
+  # A rhopalic phrase with all the artifacts from the rhopalic analysis.
+  class Phrase
+
+    attr_reader :phrase, :is_letter_rhopalic, :is_syllable_rhopalic, :words, :indices,
+        :syllable_counts, :in_dictionary
+    alias_method :letter_rhopalic?, :is_letter_rhopalic
+    alias_method :syllable_rhopalic?, :is_syllable_rhopalic
+
+    def initialize(phrase, is_letter_rhopalic, is_syllable_rhopalic, words, indices,
+        syllable_counts, in_dictionary)
+      @phrase = phrase
+      @is_letter_rhopalic = is_letter_rhopalic
+      @is_syllable_rhopalic = is_syllable_rhopalic
+      @words = words
+      @indices = indices
+      @syllable_counts = syllable_counts
+      @in_dictionary = in_dictionary
+    end
+
+    def each_word
+      words.zip(indices, syllable_counts, in_dictionary) do |args|
+        yield args[0], args[1], args[2], args[3]
+      end
+    end
+  end
+
+end

data/lib/rhopalic/rhopalic.rb

@@ -0,0 +1,29 @@
+require 'rhopalic/analysis'
+
+module Rhopalic
+
+  # Returns the analyzed phrase if it's rhopalic, nil otherwise.
+  def self.analyze_phrase(phrase)
+    Analysis.new.analyze_phrase(phrase)
+  end
+
+  # Returns whether the given phrase is letter-rhopalic in English (each
+  # word has one letter more than the preceding one).
+  def self.letter_rhopalic?(phrase)
+    analyzed = analyze_phrase(phrase)
+    !analyzed.nil? && analyzed.letter_rhopalic?
+  end
+
+  # Returns whether the given phrase is syllable-rhopalic in English (each
+  # word has one syllable more than the preceding one).
+  def self.syllable_rhopalic?(phrase)
+    analyzed = analyze_phrase(phrase)
+    !analyzed.nil? && analyzed.syllable_rhopalic?
+  end
+
+  # Returns whether the given phrase is letter-rhopalic or syllable-rhopalic.
+  def self.rhopalic?(phrase)
+    !analyze_phrase(phrase).nil?
+  end
+
+end

data/lib/rhopalic/version.rb

@@ -0,0 +1,3 @@
+module Rhopalic
+  VERSION = '0.0.1.pre'
+end

data/lib/rhopalic.rb

@@ -0,0 +1,2 @@
+require 'rhopalic/rhopalic'
+require 'rhopalic/version'

data/rhopalic.gemspec

@@ -0,0 +1,21 @@
+$:.push File.expand_path("../lib", __FILE__)
+require 'rhopalic/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'rhopalic'
+  s.version     = Rhopalic::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Nik Haldimann']
+  s.email       = ['nhaldimann@gmail.com']
+  s.homepage    = 'https://github.com/nikhaldi/rhopalic-ruby'
+  s.summary     = 'Detects rhopalic phrases'
+  s.description = 'Detects rhopalic phrases'
+
+  s.add_runtime_dependency 'lingua', '~> 0.6.2'
+  s.add_development_dependency 'param_test', '~> 0.0.2'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+end

data/test/analysis_test.rb

@@ -0,0 +1,27 @@
+require 'param_test'
+require 'test/unit'
+
+require 'rhopalic/analysis'
+require 'rhopalic/dictionary'
+
+class Rhopalic::AnalysisTest < ActiveSupport::TestCase
+
+  def setup
+    @dict = Rhopalic::Dictionary.new([
+      "ATTENUATE  AH0 T EH1 N Y UW0 EY2 T",
+      "GRADUALLY  G R AE1 JH UW0 AH0 L IY0",
+      "WHILE  W AY1 L",
+    ])
+    @analysis = Rhopalic::Analysis.new(@dict)
+  end
+
+  param_test "phrase %s has words in dictionary %s", [
+    ["While shadows, lengthening, attenuate", [true, false, false, true]],
+    ["Add extra syllables gradually", [false, false, false, true]],
+  ] do |phrase, expected_in_dictionary|
+    phrase = @analysis.analyze_phrase(phrase)
+    assert_not_nil phrase
+    assert phrase.syllable_rhopalic?
+    assert_equal expected_in_dictionary, phrase.in_dictionary
+  end
+end

data/test/dictionary_test.rb

@@ -0,0 +1,24 @@
+require 'test/unit'
+
+require 'rhopalic/dictionary'
+
+class Rhopalic::DictionaryTest < Test::Unit::TestCase
+
+  def test_constructor
+    source = [
+      ";;; comment",
+      "\"QUOTE  K W OW1 T",
+      "ABATEMENT  AH0 B EY1 T M AH0 N T",
+      "CAFETERIA  K AE2 F AH0 T IH1 R IY0 AH0",
+      "CAFETERIA(1)  K AE2 F AH0 T IH1 R IY0 AH0",
+    ]
+    dict = Rhopalic::Dictionary.new(source)
+    assert_nil dict.syllable_count("foo")
+    assert_equal 3, dict.syllable_count("abatement")
+    assert_equal 3, dict.syllable_count("Abatement")
+    assert_equal 5, dict.syllable_count("cafeteria")
+    assert_nil dict.syllable_count(";;;")
+    assert_nil dict.syllable_count("\"quote")
+    assert_nil dict.syllable_count("cafeteria(1)")
+  end
+end

data/test/phrase_test.rb

@@ -0,0 +1,27 @@
+require 'test/unit'
+
+require 'rhopalic/phrase'
+
+class Rhopalic::PhraseTest < Test::Unit::TestCase
+
+  def test_constructor_inits_accessors
+    phrase = Rhopalic::Phrase.new("one", true, true, ["one"], [0], [1], [false])
+    assert_equal "one", phrase.phrase
+    assert phrase.letter_rhopalic?
+    assert phrase.syllable_rhopalic?
+    assert_equal ["one"], phrase.words
+    assert_equal [0], phrase.indices
+    assert_equal [1], phrase.syllable_counts
+    assert_equal [false], phrase.in_dictionary
+  end
+
+  def test_each_word
+    phrase = Rhopalic::Phrase.new("one four", true, false, ["one", "four"], [0, 4], [1, 1],
+        [false, false])
+    results = []
+    phrase.each_word do |word, index, syllable_count, in_dictionary|
+      results.push([word, index, syllable_count, in_dictionary])
+    end
+    assert_equal [["one", 0, 1, false], ["four", 4, 1, false]], results
+  end
+end

data/test/rhopalic_test.rb

@@ -0,0 +1,63 @@
+# encoding: UTF-8
+
+require 'param_test'
+require 'test/unit'
+
+require 'rhopalic'
+
+class Rhopalic::RhopalicTest < ActiveSupport::TestCase
+
+  param_test "phrase %s is letter-rhopalic", [
+    "a",
+    "a be",
+    "the fine horse",
+    "it's fancy",
+    "IT'S FANCY",
+    "it's'bleak matter",
+    "rose's stencil",
+  ] do |phrase|
+    assert Rhopalic.letter_rhopalic?(phrase)
+    assert Rhopalic.rhopalic?(phrase)
+  end
+
+  param_test "phrase %s is syllable-rhopalic", [
+    "a",
+    "Words along rhopalic pentameters",
+    "Lines thicken approaching termination.",
+    "it's fancy",
+    "IT'S FANCY",
+    "bloom beta",
+    "phil's matter"
+  ] do |phrase|
+    assert Rhopalic.syllable_rhopalic?(phrase)
+    assert Rhopalic.rhopalic?(phrase)
+  end
+
+  param_test "phrase %s is not rhopalic", [
+    "a b",
+    "be do",
+    "a be ce",
+    "a it's fancy",
+  ] do |phrase|
+    assert !Rhopalic.rhopalic?(phrase)
+  end
+
+  param_test "phrase %s with accented characters is rhopalic",
+  ["the café"] do |phrase|
+    assert Rhopalic.rhopalic?(phrase)
+  end
+
+  def test_analyze_phrase_not_rhopalic
+    assert_nil Rhopalic.analyze_phrase("three two")
+  end
+
+  def test_analyze_phrase
+    phrase = Rhopalic.analyze_phrase("two four")
+    assert_equal "two four", phrase.phrase
+    assert phrase.letter_rhopalic?
+    assert !phrase.syllable_rhopalic?
+    assert_equal ["two", "four"], phrase.words
+    assert_equal [0, 4], phrase.indices
+    assert_equal [1, 1], phrase.syllable_counts
+  end
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: rhopalic
+version: !ruby/object:Gem::Version
+  version: 0.0.1.pre
+  prerelease: 6
+platform: ruby
+authors:
+- Nik Haldimann
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: lingua
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.2
+- !ruby/object:Gem::Dependency
+  name: param_test
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.2
+description: Detects rhopalic phrases
+email:
+- nhaldimann@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.md
+- README.md
+- Rakefile
+- lib/rhopalic.rb
+- lib/rhopalic/analysis.rb
+- lib/rhopalic/contractions.rb
+- lib/rhopalic/dictionary.rb
+- lib/rhopalic/phrase.rb
+- lib/rhopalic/rhopalic.rb
+- lib/rhopalic/version.rb
+- rhopalic.gemspec
+- test/analysis_test.rb
+- test/dictionary_test.rb
+- test/phrase_test.rb
+- test/rhopalic_test.rb
+homepage: https://github.com/nikhaldi/rhopalic-ruby
+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: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Detects rhopalic phrases
+test_files:
+- test/analysis_test.rb
+- test/dictionary_test.rb
+- test/phrase_test.rb
+- test/rhopalic_test.rb
+has_rdoc: