acapela 0.8.1

data/.gitignore

@@ -0,0 +1,7 @@
+config/
+vendor/
+Gemfile.lock
+pkg/
+tmp/
+script/voice_enumerator.out
+script/php_code.txt

data/.rspec

@@ -0,0 +1 @@
+--colour -fd

data/Gemfile

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

data/Rakefile

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+require 'rake'
+require 'bundler'
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'acapela/constants'
+
+RSpec::Core::RakeTask.new(:spec)
+
+namespace :generate do
+  desc "Generates MP3 with test strings for all voices."
+  task :test_voices do
+    exec('ruby -I lib script/test_voices.rb')
+  end
+
+  desc "Generate default voice class based on enumrated values from Acapela"
+  task :default_voices_class do
+    exec('ruby -I lib script/create_voices.rb')
+  end
+
+  desc "Generate default voice class based on PHP example voice list"
+  namespace :default_voices_class do
+    task :php do
+      exec('ruby -I lib script/create_voices.rb php')
+    end
+  end
+end
+
+desc "Clean up generated and downloaded files"
+task :clean do
+  include Acapela::Scripts
+  FileUtils.rm_rf(LOCAL_TEMP_DIR)
+  FileUtils.rm(PHP_VOICE_ARRAY_FILE) rescue nil
+  FileUtils.rm(VOICES_ENUMERATOR_FILE) rescue nil
+end
+
+task :default => :spec

data/acapela.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "acapela/constants"
+
+Gem::Specification.new do |s|
+  s.name        = "acapela"
+  s.version     = Acapela::VERSION
+  s.authors     = ["Birkir A. Barkarson"]
+  s.email       = ["birkirb@stoicviking.net"]
+  s.homepage    = "https://github.com/birkirb/acapela"
+  s.summary     = %q{Generate speech from the Acapela text to voice service.}
+  s.description = %q{Ruby interface to Acapela's API for generating speech from text. More info http://www.acapela-vaas.com/}
+
+  s.rubyforge_project = "acapela"
+
+  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"]
+
+  s.add_runtime_dependency("backports")
+  s.add_development_dependency("rspec", '>= 2.6.0')
+  s.add_development_dependency("mocha", '>= 0.9.0')
+end

data/init.rb

@@ -0,0 +1 @@
+require 'acapela'

data/lib/acapela.rb

@@ -0,0 +1,27 @@
+require 'acapela/error'
+require 'acapela/config'
+require 'acapela/voices/default'
+require 'acapela/voice'
+require 'acapela/constants'
+require 'acapela/response'
+require 'acapela/voice_service'
+
+if RUBY_VERSION < "1.9"
+  require 'backports'
+end
+
+module Acapela
+
+  def self.config
+    @@config ||= Acapela::Config.read rescue nil
+  end
+
+  def self.config=(config)
+    if config.is_a?(Acapela::Config)
+      @@config = config
+    else
+      raise Error.new("Acapela configuration required. Not #{config.class}")
+    end
+  end
+
+end

data/lib/acapela/config.rb

@@ -0,0 +1,38 @@
+require 'yaml'
+require 'uri'
+
+module Acapela
+  class Config
+    attr_reader :application,
+                :version,
+                :environment,
+                :login,
+                :password,
+                :protocol,
+                :target_url
+
+    DEFAULT_PROTOCOL = '2'
+    DEFAULT_VERSION = '1-30'
+    DEFAULT_TARGET_URL = 'http://vaas.acapela-group.com/Services/Synthesizer'
+
+    def initialize(login, application, password, target_url = nil, version = nil, protocol = nil)
+      @login = login
+      @application = application
+      @password = password
+      @protocol = protocol || DEFAULT_PROTOCOL
+      @version = version || DEFAULT_VERSION
+      @target_url = URI.parse(target_url || DEFAULT_TARGET_URL)
+    end
+
+    def self.read(config_file = nil)
+      config_file ||= File.join('config', 'acapela.yml')
+      begin
+        yaml = YAML.load_file(config_file)
+        self.new(yaml['login'], yaml['application'], yaml['password'], yaml['target_url'] , yaml['version'], yaml['protocol'])
+      rescue => err
+        raise Error.new("Failed to read configuration file", err)
+      end
+    end
+
+  end
+end

data/lib/acapela/constants.rb

@@ -0,0 +1,31 @@
+require 'uri'
+
+module Acapela
+
+  VERSION = "0.8.1"
+
+  class Voice
+    QUALITY_LOW = '8k'
+    QUALITY_HIGH = '22k'
+    GENDER_FEMALE = :female
+    GENDER_MALE = :male
+  end
+
+  module Scripts
+    LOCAL_TEMP_DIR = 'tmp'
+    TEST_VOICES_DIR = File.join(LOCAL_TEMP_DIR, 'voices')
+
+
+    PHP_VOICE_ARRAY_URL = URI.parse("http://vaas.acapela-group.com/webservices/1-34-01/publish/export/EVAL_VAAS/voices_lists/php_code.txt")
+    PHP_VOICE_ARRAY_FILE = File.join('script', 'php_code.txt')
+    PHP_ARRAY_REGEXP = /array\((.*)?\),?$/
+
+    VOICES_ENUMERATOR_URL = URI.parse("http://vaas.acapela-group.com/Services/Enumerator")
+    VOICES_ENUMERATOR_FILE = File.join('script', 'voice_enumerator.out')
+    # Enmuerator Example: leila22k=ar_SA/Arabic (Saudi Arabia)/Leila/HQ/F/PCM/22050
+    VOICE_ENUMERATOR_REGEXP = /(.*)?=(\w\w_\w\w)\/(.*)?\/(\w+)\/(\w+)\/(\w+)\/(\w+)\//
+
+    DEFAULT_VOICES_RUBY_FILE = File.join('lib', 'acapela', 'voices', 'default.rb')
+  end
+
+end

data/lib/acapela/error.rb

@@ -0,0 +1,33 @@
+module Acapela
+
+  class Error < StandardError
+    attr_accessor :original_error
+
+    def initialize(message, original_error = nil)
+      super(message)
+      @original_error = original_error
+    end
+
+    def to_s
+      if @original_error.nil?
+        super
+      else
+        "#{super}\nCause: #{@original_error.to_s}"
+      end
+    end
+  end
+
+  class ServiceError < Error
+    attr_accessor :code
+
+    def initialize(message, code = '')
+      super(message)
+      @code = code
+    end
+
+    def to_s
+      "Code: #{code}, Message: #{super}"
+    end
+  end
+
+end

data/lib/acapela/mocks.rb

@@ -0,0 +1,5 @@
+require 'acapela/mocks/constants'
+require 'acapela/mocks/voice_service'
+require 'acapela/mocks/response'
+
+Acapela::Response.mock_on

data/lib/acapela/mocks/constants.rb

@@ -0,0 +1,11 @@
+module Acapela
+  module Mocks
+
+    RESPONSE_TEST_FILE = File.join(File.dirname(__FILE__), 'test_file.mp3')
+
+    EXAMPLE_ACAPELA_RESPONSE_ACCESS_DENIED = "res=NOK&err_code=ACCESS_DENIED_ERROR&err_msg=Invalid%20identifiers&w=&create_echo="
+    EXAMPLE_ACAPELA_RESPONSE_INVALID_PARAM = "res=NOK&err_code=INVALID_PARAM_ERROR&err_msg=This%20voice%20is%20not%20available&w=&create_echo="
+    EXAMPLE_ACAPELA_RESPONSE_OK = "w=&snd_time=1407.94&get_count=0&snd_id=210375264_cacefb1f8f862&asw_pos_init_offset=0&asw_pos_text_offset=0&snd_url=http://vaas.acapela-group.com/MESSAGES/009086065076095086065065083/EVAL_ACCOUNT/sounds/210375264_cacefb1f8f862.mp3&snd_size=9098&res=OK&create_echo="
+
+  end
+end

data/lib/acapela/mocks/response.rb

@@ -0,0 +1,29 @@
+module Acapela
+  class Response
+
+    def self.mock_on
+      self.class_eval(<<-EVAL, __FILE__, __LINE__)
+       def fetch_file_from_url
+         fetch_file_from_url_with_mock
+       end
+      EVAL
+    end
+
+    def self.mock_off
+      self.class_eval(<<-EVAL, __FILE__, __LINE__)
+       def fetch_file_from_url
+         fetch_file_from_url_without_mock
+       end
+      EVAL
+    end
+
+    private
+
+    alias :fetch_file_from_url_without_mock :fetch_file_from_url
+
+    def fetch_file_from_url_with_mock
+      File.read(Acapela::Mocks::RESPONSE_TEST_FILE)
+    end
+
+  end
+end

data/lib/acapela/mocks/voice_service.rb

@@ -0,0 +1,36 @@
+module Acapela
+  class VoiceService
+    include Acapela::Mocks
+
+    @@expected_response = EXAMPLE_ACAPELA_RESPONSE_OK
+    @@last_posted_params = nil
+
+    def self.expected_response
+      @@expected_response
+    end
+
+    def self.last_posted_params
+      @@last_posted_params
+    end
+
+    def self.expect_ok_response
+      @@expected_response = EXAMPLE_ACAPELA_RESPONSE_OK
+    end
+
+    def self.expect_invalid_param_response
+      @@expected_response = EXAMPLE_ACAPELA_RESPONSE_INVALID_PARAM
+    end
+
+    def self.expect_access_denied_response
+      @@expected_response = EXAMPLE_ACAPELA_RESPONSE_ACCESS_DENIED
+    end
+
+    private
+
+    def post(params)
+      @@last_posted_params = params
+      self.class.expected_response
+    end
+
+  end
+end

data/lib/acapela/response.rb

@@ -0,0 +1,64 @@
+require 'cgi'
+require 'net/http'
+require 'tempfile'
+
+module Acapela
+  class Response
+
+    attr_reader :id,
+                :time,
+                :size,
+                :url
+
+    RESPONSE_STATE = 'res'
+    RESPONSE_STATE_REGEXP = /#{RESPONSE_STATE}=/
+    RESPONSE_SOUND_URL = 'snd_url'
+    RESPONSE_STATE_OK = 'OK'
+    RESPONSE_ERROR_MESSAGE = 'err_msg'
+    RESPONSE_ERROR_CODE = 'err_code'
+
+    ERROR_UNEXPECTED_RESPONSE = ServiceError.new("Unexpected response.")
+    ERROR_MISSING_SOUND_URL = ServiceError.new("Parameters are missing sound url.")
+
+    def initialize(response)
+      if RESPONSE_STATE_REGEXP.match(response)
+        params = CGI::parse(response)
+      else
+        raise ERROR_UNEXPECTED_RESPONSE
+      end
+
+      if RESPONSE_STATE_OK == params[RESPONSE_STATE].first
+        if url = params[RESPONSE_SOUND_URL]
+          @url = URI.parse(url.first)
+          @id = params['snd_id'].first
+          @time = params['snd_time'].first.to_f
+          @size = params['snd_size'].first.to_i
+        else
+          raise ERROR_MISSING_SOUND_URL
+        end
+      else
+        raise ServiceError.new(params[RESPONSE_ERROR_MESSAGE].first, params[RESPONSE_ERROR_CODE].first)
+      end
+    end
+
+    def download_to_tempfile
+      content = fetch_file_from_url
+      file = Tempfile.new(self.id)
+      file.write(content)
+      file.flush
+      file # Leaving open. Will be closed once object is finalized.
+    end
+
+    private
+
+    def fetch_file_from_url
+      response = Net::HTTP.get_response(self.url)
+      if 200 == response.code.to_i
+        response.body
+      else
+        raise Error.new("Download failed with status: #{response.code}.")
+      end
+    end
+
+  end
+end

data/lib/acapela/voice.rb

@@ -0,0 +1,121 @@
+require 'set'
+
+module Acapela
+  class Voice
+    attr_reader :languages, :speaker, :gender, :quality
+
+    def initialize(speaker, gender, *languages)
+      @speaker = speaker
+      @gender = gender
+      @quality = QUALITY_HIGH
+
+      @languages = Set.new
+      languages.each { |lang| @languages.add(lang) }
+    end
+
+    def id
+      "#{speaker.downcase}#{quality}"
+    end
+
+    def language
+      languages.first
+    end
+
+    def low_quality!
+      @quality = QUALITY_LOW
+    end
+
+    def high_quality!
+      @quality = QUALITY_HIGH
+    end
+
+    def self.override_map(override_voice_map = {})
+      current_map = self.map
+      override_voice_map.each do |language, voices|
+        language_sym = language.to_sym
+        if voices.nil?
+          # Remove voice directive.
+          current_map.delete(language_sym)
+        elsif voices.is_a?(String) || voices.is_a?(Symbol)
+          # Map voice directive.
+          current_map[language_sym] = self.map[voices]
+        elsif voices.is_a?(Hash)
+          # Replace/Override
+          if entry = self.map[language_sym]
+            new_entry = entry.dup
+          else
+            new_entry = Hash.new
+          end
+
+          voices.each do |gender, speakers|
+            if gender.is_a?(Symbol) && speakers.is_a?(Array)
+              new_entry[gender] = speakers
+            end
+          end
+          current_map[language_sym] = new_entry
+        end
+      end
+      @@map = current_map
+    end
+
+    def self.map
+      reset_map unless defined?(@@map)
+      @@map
+    end
+
+    def self.reset_map
+      @@map = Voices::PER_LANGUAGE.dup
+    end
+
+    def self.extract_from_options(options = {})
+      if speaker = options[:speaker]
+        named_voice(speaker)
+      else
+        language = options[:language] || :en
+        gender = options[:gender]
+        speakers_for_language = self.map[language]
+
+        speakers = case gender
+        when GENDER_FEMALE
+          speakers_for_language[GENDER_FEMALE]
+        when GENDER_MALE
+          speakers_for_language[GENDER_MALE]
+        else
+          speakers_for_language[GENDER_FEMALE] +
+            speakers_for_language[GENDER_MALE]
+        end
+
+        if speakers.empty?
+          nil
+        else
+          named_voice(speakers.sample)
+        end
+      end
+    end
+
+    def self.named_voice(speaker)
+      unless defined?(@@voices)
+        @@voices = Hash.new
+        self.map.each do |language, voices|
+          [GENDER_MALE, GENDER_FEMALE].each do |gender|
+            voices[gender].each do |name|
+              downcase_name = name.downcase.to_sym
+              if @@voices[downcase_name].nil?
+                @@voices[downcase_name] = Voice.new(name, gender, language.to_s)
+              else
+                @@voices[downcase_name].languages.add(language.to_s)
+              end
+            end
+          end
+        end
+      end
+
+      if info = @@voices[speaker.to_s.downcase.to_sym]
+        info
+      else
+        raise Error.new("Voice does not exist.")
+      end
+    end
+
+  end
+end

data/lib/acapela/voice_service.rb

@@ -0,0 +1,84 @@
+require 'net/http'
+
+module Acapela
+  class VoiceService
+
+    CLIENT_ENVIRONMENT = "RUBY_#{RUBY_VERSION}"
+
+    ERROR_MISSING_CONFIG = Error.new("VoiceService requires configuration.")
+
+    attr_reader :config
+
+    def initialize(config = Acapela.config)
+      if config.is_a?(Acapela::Config)
+        @config = config
+      else
+        raise ERROR_MISSING_CONFIG
+      end
+    end
+
+    def generate_sound(text, options = {})
+      voice = Voice.extract_from_options(options)
+
+      case options[:quality]
+      when :low
+        voice.low_quality!
+      when :high
+        voice.high_quality!
+      end
+
+      generate_with_voice(text, voice)
+    end
+
+    def generate_with_voice(text, voice)
+      params = {
+        :prot_vers => @config.protocol,
+        :cl_env => CLIENT_ENVIRONMENT,
+        :cl_vers => @config.version,
+        :cl_login => @config.login,
+        :cl_app => @config.application,
+        :cl_pwd => @config.password,
+        :req_type => 'NEW',
+       #:req_snd_id => nil,
+        :req_voice => voice.id,
+        :req_text => text,
+       #:req_vol => nil, # Volume: min = 50, default = 32768, max = 65535
+       #:req_spd => nil, # Speed: min = 60, default = 180, max = 360
+       #:req_vct => nil, # Shaping: min = 50, default = 100, max = 150
+       # Equalizer:  min = -100, default = 0, max = 100
+       #:req_eq1 => nil, # Band 275Hz
+       #:req_eq2 => nil, # Band: 2.2kHz
+       #:req_eq3 => nil, # Band: 5kHz
+       #:req_eq4 => nil, # Band: 8.3kHz
+       #:req_snd_type => 'MP3', # Sound file type: MP3, WAV, RAW
+       #:req_snd_ext => '.mp3', # Sound file extentions: .mp3 .wav .raw
+       #:req_snd_kbps => 'CBR_48', # Variable bit rate VBR_5 to VRB_9 (5 = max quality, 9 min) or Constant Bit Rate CBR_8,16,32,48
+       #:req_alt_snd_type => 'MP3', # Alternative Sound file type: MP3, WAV, RAW
+       #:req_alt_snd_ext => '.mp3', # Alternative Sound file extentions: .mp3 .wav .raw
+       #:req_wp => nil,  # 'ON' to receive word file URL
+       #:req_bp => nil, # 'ON' to receive bookmark file URL
+       #:req_mp => nil,  # 'ON' to receive mouth file URL
+       #:req_comment => '', Information to store about the operation.
+       #:req_start_time => nil, # The start time of the request will be used to calculate the deadline for request treatment
+       #:req_timeout => nil, # The time allocated to request treatment in seconds.
+       #:req_asw_type => 'SOUND', # Type of response:
+                                  #   "INFO", key/value params.
+                                  #   "SOUND", sound bytes once genearted.
+                                  #   "STREAM", bytes as they are generated.
+       #:req_asw_as_alt_snd => 'no', # Receive alternative file as response.
+       #:req_err_as_id3 => 'no', # Reveive errors encapsulated in ID3 tag of MP3.
+       #:req_echo => '',  # Receive some creation request fields in response.
+       #:req_asw_redirect_url => nil, # Redirect response to a different URL.
+      }
+
+      Response.new(post(params))
+    end
+
+    private
+
+    def post(params)
+      body = Net::HTTP.post_form(@config.target_url, params).body
+    end
+
+  end
+end

data/lib/acapela/voices/default.rb

@@ -0,0 +1,40 @@
+module Acapela
+  module Voices
+    PER_LANGUAGE = {
+      :ar      =>  {:female=>["Leila", "Salma"], :male=>["Mehdi", "Nizar"]},
+      :ca      =>  {:female=>["Laia"], :male=>[]},
+      :cs      =>  {:female=>["Eliska"], :male=>[]},
+      :da      =>  {:female=>["Mette"], :male=>["Rasmus"]},
+      :de      =>  {:female=>["Julia", "Sarah"], :male=>["Andreas", "Klaus"]},
+      :el      =>  {:female=>[], :male=>["Dimitris"]},
+      :en      =>  {:female=>["Deepa", "Lucy", "QueenElizabeth", "Rachel", "Heather", "Laura", "Nelly", "Tracy"], :male=>["Graham", "Nizareng", "Peter", "Kenny", "Micah", "Ryan", "Saul"]},
+      :en_GB   =>  {:female=>["Lucy", "QueenElizabeth", "Rachel"], :male=>["Graham", "Nizareng", "Peter"]},
+      :en_IN   =>  {:female=>["Deepa"], :male=>[]},
+      :en_US   =>  {:female=>["Heather", "Laura", "Nelly", "Tracy"], :male=>["Kenny", "Micah", "Ryan", "Saul"]},
+      :es      =>  {:female=>["Ines", "Maria", "Rosa"], :male=>["Antonio"]},
+      :es_ES   =>  {:female=>["Ines", "Maria"], :male=>["Antonio"]},
+      :es_US   =>  {:female=>["Rosa"], :male=>[]},
+      :fi      =>  {:female=>["Sanna"], :male=>[]},
+      :fr      =>  {:female=>["Justine", "Louise", "Alice", "Claire", "Julie", "Margaux"], :male=>["Antoine", "Bruno"]},
+      :fr_BE   =>  {:female=>["Justine"], :male=>[]},
+      :fr_CA   =>  {:female=>["Louise"], :male=>[]},
+      :fr_FR   =>  {:female=>["Alice", "Claire", "Julie", "Margaux"], :male=>["Antoine", "Bruno"]},
+      :gb      =>  {:female=>[], :male=>["Kal"]},
+      :it      =>  {:female=>["Chiara", "Fabiana", "chiara", "fabiana"], :male=>["Vittorio", "vittorio"]},
+      :nl      =>  {:female=>["Sofie", "Zoe", "Femke", "Jasmijn"], :male=>["Jeroen", "Daan", "Max"]},
+      :nl_BE   =>  {:female=>["Sofie", "Zoe"], :male=>["Jeroen"]},
+      :nl_NL   =>  {:female=>["Femke", "Jasmijn"], :male=>["Daan", "Max"]},
+      :no      =>  {:female=>["Bente", "Kari"], :male=>["Olav"]},
+      :pl      =>  {:female=>["Ania"], :male=>[]},
+      :pt      =>  {:female=>["Marcia", "Celia"], :male=>[]},
+      :pt_BR   =>  {:female=>["Marcia"], :male=>[]},
+      :pt_PT   =>  {:female=>["Celia"], :male=>[]},
+      :ru      =>  {:female=>["Alyona"], :male=>[]},
+      :sc      =>  {:female=>["Mia"], :male=>[]},
+      :sv      =>  {:female=>["Elin", "Emma"], :male=>["Emil", "Erik", "Samuel"]},
+      :sv_FI   =>  {:female=>[], :male=>["Samuel"]},
+      :sv_SE   =>  {:female=>["Elin", "Emma"], :male=>["Emil", "Erik"]},
+      :tr      =>  {:female=>["Ipek"], :male=>[]}
+    }
+  end
+end

data/script/create_voices.rb

@@ -0,0 +1,137 @@
+require 'net/http'
+require 'set'
+require 'fileutils'
+require 'acapela/constants'
+
+include Acapela::Scripts
+
+def save_uri_to_file_if_missing(uri, filename)
+  if !File.exists?(filename)
+    response = Net::HTTP.get_response(uri)
+
+    if 200 == response.code.to_i
+      voice_hash = Hash.new
+      File.open(filename,'w') do |f|
+        f.write(response.body)
+      end
+    else
+      puts "Download failed with: #{response.code}\nBody#{response.body}"
+      exit 1
+    end
+  end
+end
+
+def php_array_to_ruby_array_of_hashes(text)
+  voices = Array.new
+  text.lines do |line|
+    if match = PHP_ARRAY_REGEXP.match(line)
+      line_hash = eval("{#{match[1]}}")
+      voices << line_hash
+    end
+  end
+  voices
+end
+
+def enumerator_text_to_ruby_array_of_hashes(text)
+  voices = Array.new
+  text.lines do |line|
+    if match = VOICE_ENUMERATOR_REGEXP.match(line)
+      voices << {'language_locale' => match[2], 'speaker' => match[4], 'gender' => match[6]}
+    end
+  end
+  voices
+end
+
+def gender_code_to_symbol(gender)
+  case gender
+  when 'F'
+    Acapela::Voice::GENDER_FEMALE
+  when 'M'
+    Acapela::Voice::GENDER_MALE
+  else
+    raise "Unknown gender code: #{gender}"
+  end
+end
+
+def simple_language_code(locale)
+  locale.split('_').first
+end
+
+class Set
+  def inspect
+    self.to_a.inspect
+  end
+end
+
+def voice_array_to_voices_per_language(voices)
+  language_voices = Hash.new { |h,v| h[v] = { :female => Set.new, :male => Set.new } }
+
+  voices.each do |voice_hash|
+    gender = gender_code_to_symbol(voice_hash['gender'])
+    locale = voice_hash['language_locale']
+    simple_locale = simple_language_code(locale)
+
+    language_voices[locale][gender].add(voice_hash['speaker'])
+    language_voices[simple_locale][gender].add(voice_hash['speaker'])
+  end
+
+  # Clean up instance where specific locale is same as generic one.
+  language_voices.delete_if do |key,value|
+    simple_locale = simple_language_code(key)
+    if key != simple_locale && language_voices[simple_locale] == value
+      true
+    else
+      false
+    end
+  end
+
+  language_voices
+end
+
+def construct_class(voices_per_language)
+  text_hashes = voices_per_language.keys.sort.map do |key|
+    "".rjust(6) + ":" + key.to_s.ljust(8) + "=>".ljust(4) + voices_per_language[key].inspect
+  end
+
+  klass_text = <<-CLASS
+module Acapela
+  module Voices
+    PER_LANGUAGE = {
+#{text_hashes.join(",\n")}
+    }
+  end
+end
+CLASS
+  klass_text
+end
+
+def write_klass(klass)
+  klass_dir = File.dirname(DEFAULT_VOICES_RUBY_FILE)
+
+  if !File.exist?(klass_dir)
+    FileUtils.mkdir_p(klass_dir)
+  end
+
+  File.open(DEFAULT_VOICES_RUBY_FILE, 'w') do |f|
+    f.write(klass)
+  end
+end
+
+def main
+  if ARGV[0] == 'php'
+    save_uri_to_file_if_missing(PHP_VOICE_ARRAY_URL, PHP_VOICE_ARRAY_FILE)
+    voices = php_array_to_ruby_array_of_hashes(File.read(PHP_VOICE_ARRAY_FILE))
+  else
+    save_uri_to_file_if_missing(VOICES_ENUMERATOR_URL, VOICES_ENUMERATOR_FILE)
+    voices = enumerator_text_to_ruby_array_of_hashes(File.read(VOICES_ENUMERATOR_FILE))
+  end
+
+  voices_per_language = voice_array_to_voices_per_language(voices)
+  klass = construct_class(voices_per_language)
+  write_klass(klass)
+  puts "Done."
+end
+
+if $0 == __FILE__
+  main
+end

data/script/test_voices.rb

@@ -0,0 +1,77 @@
+# Encoding: UTF-8
+
+trap("SIGINT") do
+  puts "Stopping..."
+  @interrupted = true
+end
+
+SAMPLE_SENTENCES = {
+  :ar      =>  "اسمي {name} وأنا أتكلم يمكن.", # Arabic (Saudi Arabia)
+  :ca      =>  "El meu nom és {name} i que pot parlar.", # Catalan (Spain)
+  :cs      =>  "Mé jméno je {name} a mohu mluvit.", # Czech
+  :da      =>  "Mit navn er {name}, og jeg kan tale.", # Danish
+  :de      =>  "Mein Name ist {name}, und ich kann sprechen.", # German
+  :el      =>  "Το όνομά μου είναι {name}, και μπορώ να μιλήσω.", # Greek
+  :en      =>  "My name is {name} and I can talk.", # English
+  :en_GB   =>  "My name is {name} and I live in Great Britain.", # English (Great Britain)
+  :en_IN   =>  "My name is {name} and I live in India.", # English (India)
+  :en_US   =>  "My name is {name} and I live in the United States.", # English (US)
+  :es      =>  "Mi nombre es {name}, y puede hablar.", # Spanish
+  :es_ES   =>  "Mi nombre es {name} y vivo en España.", # Spanish (Spain)
+  :es_US   =>  "Mi nombre es {name} y yo vivimos en Estados Unidos.", # Spanish (US?)
+  :fi      =>  "Nimeni on {name}, ja voin puhua.", # Finnish
+  :fr      =>  "Mon nom est {name}, et je peux parler.", # French
+  :fr_BE   =>  "Mon nom est {name} et je vis en Belgique.", # French (Belgium)
+  :fr_CA   =>  "Mon nom est {name} et je vis au Canada.", # French (Canada)
+  :fr_FR   =>  "Mon nom est {name} et je vis en France.", # French (French)
+  :gb      =>  "Mitt namn är {name} och jag bor i Gotenburg.", # Gotenburg (Swedish), should be sv_SV_gotenburg ?
+  :it      =>  "Il mio nome è {name}, e posso parlare.", # Italian
+  :ja      =>  "私の名前は{name}です。私は話せます。", # Japanese
+  :nl      =>  "Mijn naam is {name}, en ik spreek kan.", # Dutch
+  :nl_BE   =>  "Mijn naam is {name} en ik woon in België.", # Dutch (Belgium)
+  :nl_NL   =>  "Mijn naam is {name} en ik woon in Nederland.", # Dutch (Netherlands)
+  :no      =>  "Mitt navn er {name}, og jeg kan snakke.", # Norwegian
+  :pl      =>  "Nazywam się {name}, i mogę mówić.", # Polish
+  :pt      =>  "Meu nome é {name}, e eu posso falar.", # Portuguese
+  :pt_BR   =>  "Meu nome é {name} e eu vivo no Brasil.", # Portuguese (Brazil)
+  :pt_PT   =>  "Meu nome é {name} e eu vivo em Portugal.", # Portuguese (Portugal)
+  :ru      =>  "Меня зовут {name}, и я могу сказать.", # Russia
+  :sc      =>  "Mitt namn är {name} och jag bor i Scania.", # Scanian (Sweden), should be sv_SE_scania
+  :sv      =>  "Mitt namn är {name}, och jag kan tala.", # Swedish
+  :sv_FI   =>  "Mitt namn är {name} och jag bor i Finland.", # Swedish (Finland)
+  :sv_SE   =>  "Mitt namn är {name} och jag bor i Sverige.", # Swedish (Sweden)
+  :tr      =>  "Benim adım {name} ve konuşamıyorum.", # Turkish
+  :zh      =>  "我的名字是{name}，我可以說。", # Chinese
+}
+
+require 'acapela'
+include Acapela::Scripts
+
+service = Acapela::VoiceService.new(Acapela.config)
+FileUtils.mkdir_p(TEST_VOICES_DIR)
+
+Acapela::Voices::PER_LANGUAGE.each do |language, voice_gender|
+  voice_gender.each do |gender, speakers|
+    speakers.each do |speaker|
+      begin
+        if text = SAMPLE_SENTENCES[language.to_sym]
+          text = text.gsub('{name}', speaker)
+          destination_file = File.join(TEST_VOICES_DIR, "#{language}_#{speaker}.mp3")
+          if !File.exists?(destination_file)
+            response = service.generate_sound(text, :speaker => speaker)
+            mp3_file = response.download_to_tempfile
+            FileUtils.cp(mp3_file.path, destination_file)
+            mp3_file.close!
+            puts "Generated: #{text}"
+          end
+        else
+          puts "No text for: #{speaker} in #{language}"
+        end
+      rescue => err
+        puts "FAILED WITH: #{language}, #{gender}, #{speakers.inspect}, #{speaker}\nReason: #{err.message}"
+      end
+
+      exit 0 if @interrupted
+    end
+  end
+end

data/spec/acapela/config_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Acapela::Config, 'When created' do
+
+  default_config = YAML.load_file('config/acapela.yml')
+  default_config['login'].should_not == nil
+  default_config['application'].should_not == nil
+  default_config['password'].should_not == nil
+
+  context 'with a given login, application and password' do
+    it 'should report those and other default values' do
+      config = Acapela::Config.new(default_config['login'], default_config['application'], default_config['password'])
+      config.version.should == Acapela::Config::DEFAULT_VERSION
+      config.protocol.should == Acapela::Config::DEFAULT_PROTOCOL
+      config.target_url.should == URI.parse(Acapela::Config::DEFAULT_TARGET_URL)
+      config.environment.should be_nil
+
+      config.login.should == default_config['login']
+      config.application.should == default_config['application']
+    end
+  end
+
+  context 'from a config file' do
+    it 'should default to the local config/acapela.yml' do
+      config = Acapela::Config.read
+      config.login.should == default_config['login']
+      config.application.should == default_config['application']
+    end
+
+    it 'should accept an arbitary config file argument' do
+      config = Acapela::Config.read(test_config)
+      config.login.should_not be_nil
+      config.application.should_not be_nil
+
+      config.login.should_not == default_config['login']
+      config.application.should_not == default_config['application']
+    end
+  end
+
+end

data/spec/acapela/response_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+require 'cgi'
+
+describe Acapela::Response do
+
+  after(:each) do
+    Acapela::Response.mock_on
+  end
+
+  it 'should throw an error when created with bogus parameters' do
+    expect do
+      Acapela::Response.new('stuff=yeah')
+    end.to raise_error(Acapela::Error, Acapela::Response::ERROR_UNEXPECTED_RESPONSE.message)
+  end
+
+  it 'should report sound related stats' do
+    response = Acapela::Response.new(Acapela::Mocks::EXAMPLE_ACAPELA_RESPONSE_OK)
+    response.url.should be_kind_of(URI)
+    response.time.should be_kind_of(Float)
+    response.size.should be_kind_of(Integer)
+    response.id.should be_kind_of(String)
+    response.time.should == 1407.94
+    response.size.should == 9098
+    response.id.should == '210375264_cacefb1f8f862'
+  end
+
+  it 'should download and return a tempfile with the object from the response url' do
+    response = Acapela::Response.new(Acapela::Mocks::EXAMPLE_ACAPELA_RESPONSE_OK)
+
+    file = response.download_to_tempfile
+    file.should be_kind_of(Tempfile)
+    file.rewind
+    contents = file.read
+    file.close
+    contents.should == File.read(Acapela::Mocks::RESPONSE_TEST_FILE)
+  end
+
+  it 'should raise an error when file download fails with non 200 response' do
+    Acapela::Response.mock_off # Returns the test file contents.
+    response = Acapela::Response.new(Acapela::Mocks::EXAMPLE_ACAPELA_RESPONSE_OK)
+    Net::HTTP.expects(:get_response).returns(Net::HTTPNotFound.new("Body?", 404, "Something went wrong."))
+    expect do
+      response.download_to_tempfile
+     end.to raise_error(Acapela::Error)
+  end
+
+end

data/spec/acapela/test_config.yml

@@ -0,0 +1,3 @@
+login: 'TEST'
+application: 'TEST_APP'
+password: 'TEST_PWD'

data/spec/acapela/voice_service_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe Acapela::VoiceService do
+
+  text_string = 'This is a test'
+  mock_service = true
+  if mock_service
+    require 'acapela/mocks/voice_service'
+
+    after(:each) do
+      Acapela::VoiceService.expect_ok_response
+    end
+  end
+
+  context 'When create without parameters' do
+    service = Acapela::VoiceService.new
+
+    it 'should use the default config' do
+      service.config.should be_kind_of(Acapela::Config)
+      service.config.should == Acapela.config
+    end
+
+    it 'should allow generation of MP3 sound' do
+      sound_url = service.generate_sound(text_string, :language => :en)
+      sound_url.should be_kind_of(Acapela::Response)
+    end
+  end
+
+  it 'should throw an error when created with nil config' do
+    expect do
+      service = Acapela::VoiceService.new(nil)
+    end.to raise_error(Acapela::Error, Acapela::VoiceService::ERROR_MISSING_CONFIG.message)
+  end
+
+  context 'When created with config with invalid login/password' do
+    service = Acapela::VoiceService.new(Acapela::Config.read(test_config))
+
+    it 'should raise the reported access error' do
+       Acapela::VoiceService.expect_access_denied_response if mock_service
+       expect do
+         service.generate_sound(text_string, :language => :en)
+       end.to raise_error(Acapela::ServiceError, "Code: ACCESS_DENIED_ERROR, Message: Invalid identifiers")
+    end
+  end
+
+  context 'When generating sound' do
+    it 'should allow low quality setting' do
+      service = Acapela::VoiceService.new
+      if mock_service
+        service.generate_sound(text_string, :speaker => 'tracy', :quality => :low)
+        Acapela::VoiceService.last_posted_params[:req_voice].should == 'tracy8k'
+      else
+        pending("Without mock, the returned file quality needs to be confirmed")
+      end
+    end
+
+    it 'should allow custom voice setting' do
+      service = Acapela::VoiceService.new
+      if mock_service
+        voice = Acapela::Voice.new('johnny', :male, 'en')
+        service.generate_with_voice(text_string, voice)
+        Acapela::VoiceService.last_posted_params[:req_voice].should == 'johnny22k'
+      else
+        pending("Without mock, the returned file quality needs to be confirmed")
+      end
+    end
+  end
+
+end

data/spec/acapela/voice_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+describe Acapela::Voice do
+
+  context 'When created' do
+    speaker_name = 'tom'
+    test_voice = Acapela::Voice.new(speaker_name, Acapela::Voice::GENDER_FEMALE)
+
+    it 'with name and gender should report default values' do
+      test_voice.speaker.should == speaker_name
+      test_voice.gender.should == Acapela::Voice::GENDER_FEMALE
+      test_voice.quality.should == Acapela::Voice::QUALITY_HIGH
+      test_voice.languages.should be_kind_of(Set)
+      test_voice.languages.should be_empty
+      test_voice.language.should be_nil
+      test_voice.id.should == "#{speaker_name}#{test_voice.quality}"
+    end
+
+    it 'should allow flipping quality setting' do
+      test_voice.low_quality!
+      test_voice.quality.should == Acapela::Voice::QUALITY_LOW
+      test_voice.high_quality!
+      test_voice.quality.should == Acapela::Voice::QUALITY_HIGH
+    end
+  end
+
+  context 'With a set of defined voices' do
+    it 'should throw an error if the voice does not exist' do
+      expect do
+        Acapela::Voice.named_voice('Birkir')
+      end.to raise_error(Acapela::Error, "Voice does not exist.")
+    end
+
+    it 'should return the active voice map' do
+      Acapela::Voice.map.should == Acapela::Voices::PER_LANGUAGE
+    end
+
+    context 'should find a voice' do
+      it 'given an existing speaker name' do
+        voice = Acapela::Voice.named_voice('Tracy')
+        voice.speaker.should == 'Tracy'
+        voice.language.should == 'en'
+        voice.gender.should == Acapela::Voice::GENDER_FEMALE
+        voice.languages.to_a.should == ['en']
+        voice.id.should == 'tracy22k'
+      end
+
+      it 'given an existing speaker name in lower case' do
+        voice = Acapela::Voice.named_voice('bruno')
+        voice.speaker.should == 'Bruno'
+        voice.gender.should == Acapela::Voice::GENDER_MALE
+        voice.language.should == 'fr'
+      end
+
+      it 'given an existing speaker name as a symbol' do
+        voice = Acapela::Voice.named_voice(:rosa)
+        voice.speaker.should == 'Rosa'
+        voice.gender.should == Acapela::Voice::GENDER_FEMALE
+        voice.language.should == 'es'
+      end
+    end
+
+    context 'should extract a voice when given an option that' do
+      it 'specifies nothing, defaulting to English' do
+        voice = Acapela::Voice.extract_from_options
+        ['Tracy', 'Heather', 'Kenny'].should include(voice.speaker)
+      end
+
+      it 'specifies a speaker' do
+        voice = Acapela::Voice.extract_from_options(:speaker => 'antoine')
+        voice.speaker.should == 'Antoine'
+        voice.gender.should == Acapela::Voice::GENDER_MALE
+        voice.language.should == 'fr'
+      end
+
+      it 'specifies a language' do
+        voice = Acapela::Voice.extract_from_options(:language => :es)
+        voice.speaker.should == 'Rosa'
+      end
+
+      it 'specifies a language and no gender' do
+        voice = Acapela::Voice.extract_from_options(:language => :fr)
+        voice.should_not be_nil
+        ['Antoine', 'Bruno'].should include(voice.speaker)
+      end
+
+      it 'specifies a language and gender' do
+        voice = Acapela::Voice.extract_from_options(:language => :es, :gender => Acapela::Voice::GENDER_FEMALE)
+        voice.speaker.should == 'Rosa'
+
+        voice = Acapela::Voice.extract_from_options(:language => :es, :gender => Acapela::Voice::GENDER_MALE)
+        voice.should be_nil
+      end
+    end
+  end
+
+  context 'Allows for voices to be overriden or changed' do
+    after(:each) do
+      Acapela::Voice.reset_map
+    end
+
+    it 'should allow removing specific entries' do
+      Acapela::Voice.map[:en][:male].first.should == 'Kenny'
+      Acapela::Voice.override_map(:en => nil)
+      Acapela::Voice.map[:en].should be_nil
+    end
+
+    it 'should allow mapping one entry to another' do
+      Acapela::Voice.map[:en][:male].first.should == 'Kenny'
+      Acapela::Voice.override_map(:en => :fr)
+      Acapela::Voice.map[:en][:male].first.should == 'Antoine'
+    end
+
+    it 'should allow replacing an entry' do
+      Acapela::Voice.map[:en][:male].first.should == 'Kenny'
+      Acapela::Voice.override_map(:en => {:male => ['Johnny']})
+      Acapela::Voice.map[:en][:male].should == ['Johnny']
+      Acapela::Voice.map[:en][:female].first.should == 'Tracy'
+    end
+
+    it 'should allow adding an entry' do
+      Acapela::Voice.map[:is].should be_nil
+      Acapela::Voice.override_map(:is => {:male => ['Birkir'], :female => ['Harpa']})
+      Acapela::Voice.map[:is][:male].first.should == 'Birkir'
+      Acapela::Voice.map[:is][:female].first.should == 'Harpa'
+    end
+  end
+end

data/spec/acapela_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Acapela do
+  it 'should reference a config file' do
+    config = Acapela.config
+
+    config.should_not be_nil
+    config.should be_a_kind_of(Acapela::Config)
+  end
+
+  it 'should allow setting of the config file' do
+    default_config = Acapela.config
+
+    begin
+      test_config = Acapela::Config.read(test_config)
+
+      Acapela.config = test_config
+      Acapela.config.should == test_config
+    ensure
+      Acapela.config = default_config
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,45 @@
+CONFIG_DIR = 'config'
+CONFIG_FILE = File.join(CONFIG_DIR, 'acapela.yml')
+DEFAULT_CONFIG_FILE = <<-YAML
+login: 'EVAL_VAAS'
+application: 'MY_APPLICATION'
+password: 'MY_PASSWORD'
+YAML
+
+def create_missing_config_file
+  unless File.exists?(CONFIG_FILE)
+    Dir.mkdir(CONFIG_DIR)
+    File.open(CONFIG_FILE, 'w') do |f|
+      f.write(DEFAULT_CONFIG_FILE)
+    end
+  end
+end
+
+def test_config
+  File.join('spec', 'acapela', 'test_config.yml')
+end
+
+create_missing_config_file
+
+require File.join(File.dirname(__FILE__), '..', 'init')
+require 'bundler'
+Bundler.require(:development)
+require 'acapela/mocks'
+
+def silence_warnings
+  begin
+    old_verbose, $VERBOSE = $VERBOSE, nil
+    yield
+  ensure
+    $VERBOSE = old_verbose
+  end
+end
+
+# Some test voices.
+silence_warnings do
+  Acapela::Voices::PER_LANGUAGE = {
+    :en      =>  {:female=>["Tracy", "Heather"], :male=>["Kenny"]},
+    :es      =>  {:female=>["Rosa"], :male=>[]},
+    :fr      =>  {:female=>[], :male=>["Antoine", "Bruno"]},
+  }
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: acapela
+version: !ruby/object:Gem::Version
+  version: 0.8.1
+  prerelease: 
+platform: ruby
+authors:
+- Birkir A. Barkarson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: backports
+  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: 2.6.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.6.0
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+description: Ruby interface to Acapela's API for generating speech from text. More
+  info http://www.acapela-vaas.com/
+email:
+- birkirb@stoicviking.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- Rakefile
+- acapela.gemspec
+- init.rb
+- lib/acapela.rb
+- lib/acapela/config.rb
+- lib/acapela/constants.rb
+- lib/acapela/error.rb
+- lib/acapela/mocks.rb
+- lib/acapela/mocks/constants.rb
+- lib/acapela/mocks/response.rb
+- lib/acapela/mocks/test_file.mp3
+- lib/acapela/mocks/voice_service.rb
+- lib/acapela/response.rb
+- lib/acapela/voice.rb
+- lib/acapela/voice_service.rb
+- lib/acapela/voices/default.rb
+- script/create_voices.rb
+- script/test_voices.rb
+- spec/acapela/config_spec.rb
+- spec/acapela/response_spec.rb
+- spec/acapela/test_config.yml
+- spec/acapela/voice_service_spec.rb
+- spec/acapela/voice_spec.rb
+- spec/acapela_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/birkirb/acapela
+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: acapela
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Generate speech from the Acapela text to voice service.
+test_files: []
+has_rdoc: