pocketsphinx-ruby 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 440699d34e0585b3670bd4bfa91e6e9a87b2331f
-  data.tar.gz: 8a697fa2d7e491e4eccfb47fe678a6acfcf695a7
+  metadata.gz: 3bf38b30cbc9fd5c2375d2c330238d1ad429e44c
+  data.tar.gz: 82aecda7d2c95378f15f47cc897b13419b83ce00
 SHA512:
-  metadata.gz: 7d913ab82f397056b9b90bb5f7d4fb6609a618a367a361c3936afd4e850caf908614bb16a174cae26160241cc8424eb7abae4404595b1d27e6a90bc0e431f2cf
-  data.tar.gz: ab6b8b36f3b9ef07f0086cca1e28b49b146116b15a3acf7e06f0fc80d50fc133a2653e05f437344c2f8532284c4e8fa8205151bca3de379f4a4f354048accdf5
+  metadata.gz: 2bb177461a17173815f299d3b17807014b80a22c3fae818569a4d29355e33dd506d3e1d4d195f8fa84ee09073014212fadd17a00e3f088a82d4278ccceea936a
+  data.tar.gz: 1ba9d9b74c999a05091e870b0fe2aee6c45df623b4d84a7364268eab1e4cf4e41dcf11b7206e90f5e3afd1d9ee292e503f8b4a6712b859e151e611944fe867a4

data/README.md

@@ -3,6 +3,7 @@
 [![Build Status](http://img.shields.io/travis/watsonbox/pocketsphinx-ruby.svg?style=flat)](https://travis-ci.org/watsonbox/pocketsphinx-ruby)
 [![Code Climate](http://img.shields.io/codeclimate/github/watsonbox/pocketsphinx-ruby/badges/gpa.svg?style=flat)](https://codeclimate.com/github/watsonbox/pocketsphinx-ruby)
 [![Coverage Status](https://img.shields.io/coveralls/watsonbox/pocketsphinx-ruby.svg?style=flat)](https://coveralls.io/r/watsonbox/pocketsphinx-ruby)
+[![Yard Docs](http://img.shields.io/badge/yard-docs-blue.svg?style=flat)](http://www.rubydoc.info/gems/pocketsphinx-ruby/frames)
 
 This gem provides Ruby [FFI](https://github.com/ffi/ffi) bindings for [Pocketsphinx](https://github.com/cmusphinx/pocketsphinx), a lightweight speech recognition engine, specifically tuned for handheld and mobile devices, though it works equally well on the desktop. Pocketsphinx is part of the [CMU Sphinx](http://cmusphinx.sourceforge.net/) Open Source Toolkit For Speech Recognition.
 
@@ -50,7 +51,7 @@ Or install it yourself as:
     $ gem install pocketsphinx-ruby
 
 
-## Basic Usage
+## Usage
 
 The `LiveSpeechRecognizer` is modeled on the same class in [Sphinx4](http://cmusphinx.sourceforge.net/wiki/tutorialsphinx4). It uses the `Microphone` and `Decoder` classes internally to provide a simple, high-level recognition interface:
 
@@ -75,7 +76,7 @@ end
 These two classes split speech into utterances by detecting silence between them. By default this uses Pocketsphinx's internal Voice Activity Detection (VAD) which can be configured by adjusting the `vad_postspeech`, `vad_prespeech`, and `vad_threshold` configuration settings.
 
 
-## Configuration
+### Configuration
 
 All of Pocketsphinx's decoding settings are managed by the `Configuration` class, which can be passed into the high-level speech recognizers:
 
@@ -98,7 +99,7 @@ Pocketsphinx::LiveSpeechRecognizer.new(configuration)
 You can find the output of `configuration.details` [here](https://github.com/watsonbox/pocketsphinx-ruby/wiki/Default-Pocketsphinx-Configuration) for more information on the various different settings.
 
 
-## Microphone
+### Microphone
 
 The `Microphone` class uses Pocketsphinx's libsphinxad to record audio for speech recognition. For desktop applications this should normally be 16bit/16kHz raw PCM audio, so these are the default settings. The exact audio backend depends on [what was selected](https://github.com/cmusphinx/sphinxbase/blob/master/configure.in#L138) when libsphinxad was built. On OSX, OpenAL is [now supported](https://github.com/cmusphinx/sphinxbase/commit/5cc55c4721273681200e1f754ff0798ac073b950) and should work just fine.
 
@@ -124,7 +125,7 @@ end
 To open this audio file take a look at [this wiki page](https://github.com/watsonbox/pocketsphinx-ruby/wiki/Importing-raw-PCM-audio-with-Audacity).
 
 
-## Decoder
+### Decoder
 
 The `Decoder` class uses Pocketsphinx's libpocketsphinx to decode audio data into text. For example to decode a single utterance:
 
@@ -136,6 +137,18 @@ puts decoder.hypothesis # => "go forward ten years"
 ```
 
 
+### Keyword Spotting
+
+Keyword spotting is another feature that is not in the current stable (0.8) releases of Pocketsphinx, having been [merged into trunk](https://github.com/cmusphinx/pocketsphinx/commit/f562f9356cc7f1ade4941ebdde0c377642a023e3) early in 2014. In can be useful for detecting an activation keyword in a command and control application, while ignoring all other speech. Set up a recognizer as follows:
+
+```ruby
+configuration = Configuration::KeywordSpotting.new('Okay computer')
+recognizer = LiveSpeechRecognizer.new(configuration)
+```
+
+The `KeywordSpotting` configuration accepts a second argument for adjusting the sensitivity of the keyword detection. Note that this is just a wrapper which sets the `keyphrase` and `kws_threshold` settings on the default configuration.
+
+
 ## Contributing
 
 1. Fork it ( https://github.com/[my-github-username]/pocketsphinx-ruby/fork )

data/examples/keyword_spotter.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "pocketsphinx-ruby"
+
+include Pocketsphinx
+
+configuration = Configuration::KeywordSpotting.new('hello computer')
+recognizer = LiveSpeechRecognizer.new(configuration)
+
+recognizer.recognize do |speech|
+  if configuration.keyword == 'hello computer'
+    configuration.keyword = 'goodbye computer'
+  else
+    configuration.keyword = 'hello computer'
+  end
+
+  recognizer.reconfigure
+
+  puts "You said '#{speech}'. Keyword is now '#{configuration.keyword}'"
+end

data/lib/pocketsphinx.rb

@@ -1,11 +1,18 @@
 require 'ffi'
 
 require "pocketsphinx/version"
+
+# Pocketsphinx FFI API
 require "pocketsphinx/api/sphinxbase"
 require "pocketsphinx/api/sphinxad"
 require "pocketsphinx/api/pocketsphinx"
 
-require "pocketsphinx/configuration"
+# Configuration
+require 'pocketsphinx/configuration/setting_definition'
+require "pocketsphinx/configuration/base"
+require "pocketsphinx/configuration/default"
+require "pocketsphinx/configuration/keyword_spotting"
+
 require "pocketsphinx/audio_file"
 require "pocketsphinx/microphone"
 require "pocketsphinx/decoder"

data/lib/pocketsphinx/api/pocketsphinx.rb

@@ -8,6 +8,7 @@ module Pocketsphinx
       typedef :pointer, :configuration
 
       attach_function :ps_init, [:configuration], :decoder
+      attach_function :ps_reinit, [:decoder, :configuration], :int
       attach_function :ps_default_search_args, [:pointer], :void
       attach_function :ps_args, [], :pointer
       attach_function :ps_decode_raw, [:decoder, :pointer, :string, :long], :int

data/lib/pocketsphinx/configuration/base.rb

@@ -0,0 +1,95 @@
+module Pocketsphinx
+  module Configuration
+    class Base
+      attr_reader :ps_config
+      attr_reader :setting_definitions
+
+      def initialize
+        @ps_arg_defs = API::Pocketsphinx.ps_args
+        @setting_definitions = SettingDefinition.from_arg_defs(@ps_arg_defs)
+
+        # Sets default settings based on definitions
+        @ps_config = API::Sphinxbase.cmd_ln_parse_r(nil, @ps_arg_defs, 0, nil, 1)
+      end
+
+      def setting_names
+        setting_definitions.keys.sort
+      end
+
+      # Get details for one or all configuration settings
+      #
+      # @param [String] name Name of setting to get details for. Gets details for all settings if nil.
+      def details(name = nil)
+        details = [name || setting_names].flatten.map do |name|
+          definition = find_definition(name)
+
+          {
+            name: name,
+            type: definition.type,
+            default: definition.default,
+            required: definition.required?,
+            value: self[name],
+            info: definition.doc
+          }
+        end
+
+        name ? details.first : details
+      end
+
+      # Get a configuration setting
+      def [](name)
+        case find_definition(name).type
+        when :integer
+          API::Sphinxbase.cmd_ln_int_r(ps_config, "-#{name}")
+        when :float
+          API::Sphinxbase.cmd_ln_float_r(ps_config, "-#{name}")
+        when :string
+          API::Sphinxbase.cmd_ln_str_r(ps_config, "-#{name}")
+        when :boolean
+          API::Sphinxbase.cmd_ln_int_r(ps_config, "-#{name}") != 0
+        when :string_list
+          raise NotImplementedException
+        end
+      end
+
+      # Set a configuration setting with type checking
+      def []=(name, value)
+        check_type(name, type = find_definition(name).type, value)
+
+        case type
+        when :integer
+          API::Sphinxbase.cmd_ln_set_int_r(ps_config, "-#{name}", value.to_i)
+        when :float
+          API::Sphinxbase.cmd_ln_set_float_r(ps_config, "-#{name}", value.to_f)
+        when :string
+          API::Sphinxbase.cmd_ln_set_str_r(ps_config, "-#{name}", (value.to_s if value))
+        when :boolean
+          API::Sphinxbase.cmd_ln_set_int_r(ps_config, "-#{name}", value ? 1 : 0)
+        when :string_list
+          raise NotImplementedException
+        end
+      end
+
+      private
+
+      def find_definition(name)
+        setting_definitions[name] or raise "Configuration setting '#{name}' does not exist"
+      end
+
+      def check_type(name, expected_type, value)
+        conversion_method = case expected_type
+          when :integer then :to_i
+          when :float then :to_f
+        end
+
+        if conversion_method && !value.respond_to?(conversion_method)
+          raise "Configuration setting '#{name}' must be of type #{expected_type.to_s.capitalize}"
+        end
+
+        if value.nil? && expected_type != :string
+          raise "Only string settings can be set to nil"
+        end
+      end
+    end
+  end
+end

data/lib/pocketsphinx/configuration/default.rb

@@ -0,0 +1,17 @@
+module Pocketsphinx
+  module Configuration
+    class Default < Base
+      def initialize
+        super
+
+        # Sets default grammar and language model if they are not set explicitly and
+        # are present in the default search path.
+        API::Pocketsphinx.ps_default_search_args(@ps_config)
+      end
+    end
+
+    def self.default
+      Default.new
+    end
+  end
+end

data/lib/pocketsphinx/configuration/keyword_spotting.rb

@@ -0,0 +1,37 @@
+module Pocketsphinx
+  module Configuration
+    class KeywordSpotting < Default
+      attr_reader :kws_threshold
+
+      def initialize(keyword, threshold = nil)
+        super()
+
+        self['lm'] = nil
+        self.keyword = keyword
+        self.kws_threshold = threshold if threshold
+      end
+
+      def keyword
+        self['keyphrase']
+      end
+
+      def keyword=(value)
+        self['keyphrase'] = sanitize_keyword value
+      end
+
+      def kws_threshold
+        self['kws_threshold']
+      end
+
+      def kws_threshold=(value)
+        self['kws_threshold'] = value
+      end
+
+      private
+
+      def sanitize_keyword(keyword)
+        keyword.downcase
+      end
+    end
+  end
+end

data/lib/pocketsphinx/configuration/setting_definition.rb

@@ -1,5 +1,5 @@
 module Pocketsphinx
-  class Configuration
+  module Configuration
     class SettingDefinition < Struct.new(:name, :type_code, :deflt, :doc)
       TYPES = [:integer, :float, :string, :boolean, :string_list]
 

data/lib/pocketsphinx/decoder.rb

@@ -1,13 +1,22 @@
 module Pocketsphinx
-  class Decoder
+  class Decoder < Struct.new(:configuration)
     Error = Class.new(StandardError)
 
-    attr_reader :ps_decoder
     attr_writer :ps_api
 
-    def initialize(configuration)
-      @configuration = configuration
-      @ps_decoder = ps_api.ps_init(configuration.ps_config)
+    # Reinitialize the decoder with updated configuration.
+    #
+    # This function allows you to switch the acoustic model, dictionary, or other configuration
+    # without creating an entirely new decoding object.
+    #
+    # @param [Configuration] configuration An optional new configuration to use.  If this is
+    #   nil, the previous configuration will be reloaded, with any changes applied.
+    def reconfigure(configuration = nil)
+      self.configuration = configuration if configuration
+
+      ps_api.ps_reinit(ps_decoder, self.configuration.ps_config).tap do |result|
+        raise Error, "Decoder#reconfigure failed with error code #{result}" if result < 0
+      end
     end
 
     # Decode a raw audio stream as a single utterance, opening a file if path given
@@ -55,7 +64,7 @@ module Pocketsphinx
     #   worth of data.  This may allow the recognizer to produce more accurate results.
     # @return Number of frames of data searched
     def process_raw(buffer, size, no_search = false, full_utt = false)
-      ps_api.ps_process_raw(@ps_decoder, buffer, size, no_search ? 1 : 0, full_utt ? 1 : 0).tap do |result|
+      ps_api.ps_process_raw(ps_decoder, buffer, size, no_search ? 1 : 0, full_utt ? 1 : 0).tap do |result|
         raise Error, "Decoder#process_raw failed with error code #{result}" if result < 0
       end
     end
@@ -68,21 +77,21 @@ module Pocketsphinx
     #
     # @param [String] name String uniquely identifying this utterance. If nil, one will be created.
     def start_utterance(name = nil)
-      ps_api.ps_start_utt(@ps_decoder, name).tap do |result|
+      ps_api.ps_start_utt(ps_decoder, name).tap do |result|
         raise Error, "Decoder#start_utterance failed with error code #{result}" if result < 0
       end
     end
 
     # End utterance processing
     def end_utterance
-      ps_api.ps_end_utt(@ps_decoder).tap do |result|
+      ps_api.ps_end_utt(ps_decoder).tap do |result|
         raise Error, "Decoder#end_utterance failed with error code #{result}" if result < 0
       end
     end
 
     # Checks if the last feed audio buffer contained speech
     def in_speech?
-      ps_api.ps_get_in_speech(@ps_decoder) != 0
+      ps_api.ps_get_in_speech(ps_decoder) != 0
     end
 
     # Get hypothesis string and path score.
@@ -90,11 +99,15 @@ module Pocketsphinx
     # @return [String] Hypothesis string
     # @todo Expand to return path score and utterance ID
     def hypothesis
-      ps_api.ps_get_hyp(@ps_decoder, nil, nil)
+      ps_api.ps_get_hyp(ps_decoder, nil, nil)
     end
 
     def ps_api
       @ps_api || API::Pocketsphinx
     end
+
+    def ps_decoder
+      @ps_decoder ||= ps_api.ps_init(configuration.ps_config)
+    end
   end
 end

data/lib/pocketsphinx/microphone.rb

@@ -65,7 +65,7 @@ module Pocketsphinx
     #
     # @param [Fixnum] max_samples The maximum samples we tried to read from the audio device
     def read_audio_delay(max_samples = 4096)
-      max_samples / (2 * sample_rate)
+      max_samples.to_f / (2 * sample_rate)
     end
 
     def close_device

data/lib/pocketsphinx/speech_recognizer.rb

@@ -6,6 +6,7 @@ module Pocketsphinx
     # Recordable interface must implement #record and #read_audio
     attr_writer :recordable
     attr_writer :decoder
+    attr_writer :configuration
 
     def initialize(configuration = nil)
       @configuration = configuration
@@ -23,6 +24,19 @@ module Pocketsphinx
       @configuration ||= Configuration.default
     end
 
+    # Reinitialize the decoder with updated configuration.
+    #
+    # See Decoder#reconfigure
+    #
+    # @param [Configuration] configuration An optional new configuration to use.  If this is
+    #   nil, the previous configuration will be reloaded, with any changes applied.
+    def reconfigure(configuration = nil)
+      self.configuration = configuration if configuration
+
+      decoder.reconfigure(configuration)
+      decoder.start_utterance if recognizing?
+    end
+
     # Recognize utterances and yield hypotheses in infinite loop
     #
     # Splits speech into utterances by detecting silence between them.
@@ -32,6 +46,7 @@ module Pocketsphinx
     # @param [Fixnum] max_samples Number of samples to process at a time
     def recognize(max_samples = 4096)
       decoder.start_utterance
+      @recognizing = true
 
       recordable.record do
         FFI::MemoryPointer.new(:int16, max_samples) do |buffer|
@@ -41,13 +56,16 @@ module Pocketsphinx
                 process_audio(buffer, max_samples) or break
               end
 
-              yield get_hypothesis
+              hypothesis = get_hypothesis
+              yield hypothesis if hypothesis
             else
               process_audio(buffer, max_samples) or break
             end
           end
         end
       end
+    ensure
+      @recognizing = false
     end
 
     def in_speech?
@@ -55,6 +73,10 @@ module Pocketsphinx
       decoder.in_speech?
     end
 
+    def recognizing?
+      @recognizing == true
+    end
+
     private
 
     def process_audio(buffer, max_samples)

data/lib/pocketsphinx/version.rb

@@ -1,3 +1,3 @@
 module Pocketsphinx
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/spec/configuration_spec.rb

@@ -4,7 +4,7 @@ describe Configuration do
   subject { Pocketsphinx::Configuration.default }
 
   it "provides a default pocketsphinx configuration" do
-    expect(subject).to be_a(Pocketsphinx::Configuration)
+    expect(subject).to be_a(Pocketsphinx::Configuration::Default)
   end
 
   it "supports integer settings" do
@@ -13,6 +13,8 @@ describe Configuration do
 
     subject['frate'] = 50
     expect(subject['frate']).to eq(50)
+
+    expect { subject['frate'] = nil }.to raise_exception "Only string settings can be set to nil"
   end
 
   it "supports float settings" do
@@ -21,24 +23,31 @@ describe Configuration do
 
     subject['samprate'] = 8000
     expect(subject['samprate']).to eq(8000)
+
+    expect { subject['samprate'] = nil }.to raise_exception "Only string settings can be set to nil"
   end
 
-  it "supports getting strings" do
+  it "supports string settings" do
     expect(subject['warp_type']).to eq('inverse_linear')
 
     subject['warp_type'] = 'different_type'
     expect(subject['warp_type']).to eq('different_type')
+
+    subject['warp_type'] = nil
+    expect(subject['warp_type']).to eq(nil)
   end
 
-  it "supports getting booleans" do
+  it "supports boolean settings" do
     expect(subject['smoothspec']).to eq(false)
 
     subject['smoothspec'] = true
     expect(subject['smoothspec']).to eq(true)
+
+    expect { subject['smoothspec'] = nil }.to raise_exception "Only string settings can be set to nil"
   end
 
   it 'raises exceptions when setting with incorrectly typed values' do
-    expect { subject['frate'] = true }.to raise_exception "Configuration setting 'frate' must be a Fixnum"
+    expect { subject['frate'] = true }.to raise_exception "Configuration setting 'frate' must be of type Integer"
   end
 
   it 'raises exceptions when a setting is unknown' do
@@ -77,4 +86,30 @@ describe Configuration do
       })
     end
   end
+
+  context 'keyword spotting configuration' do
+    subject { Configuration::KeywordSpotting.new('Okay computer') }
+
+    it 'sets the lowercase keyphrase' do
+      expect(subject['keyphrase']).to eq('okay computer')
+    end
+
+    it 'uses no language model' do
+      expect(subject['lm']).to be_nil
+    end
+
+    it 'exposes the keyphrase setting as #keyword' do
+      subject.keyword = 'Hello computer'
+
+      expect(subject.keyword).to eq('hello computer')
+      expect(subject['keyphrase']).to eq('hello computer')
+    end
+
+    it 'exposes the kws_threshold setting as #kws_threshold' do
+      subject.kws_threshold = 24
+
+      expect(subject.kws_threshold).to eq(24)
+      expect(subject['kws_threshold']).to eq(24)
+    end
+  end
 end

data/spec/decoder_spec.rb

@@ -1,27 +1,47 @@
 require 'spec_helper'
 
 describe Decoder do
-  subject { @decoder }
-  let(:ps_api) { @decoder.ps_api = double }
-
-  # Share decoder across all examples for speed
-  before :all do
-    @decoder = Decoder.new(Configuration.default)
+  subject { Decoder.new(configuration) }
+  let(:ps_api) { subject.ps_api }
+  let(:ps_decoder) { double }
+  let(:configuration) { Configuration.default }
+
+  before do
+    subject.ps_api = double
+    allow(ps_api).to receive(:ps_init).and_return(ps_decoder)
   end
 
-  # Full integration test
-  describe '#decode' do
-    it 'correctly decodes the speech in goforward.raw' do
-      subject.decode File.open('spec/assets/audio/goforward.raw', 'rb')
+  describe '#reconfigure' do
+    it 'calls libpocketsphinx' do
+      expect(ps_api)
+        .to receive(:ps_reinit)
+        .with(subject.ps_decoder, configuration.ps_config)
+        .and_return(0)
 
-      # With the default configuration (no specific grammar), pocketsphinx doesn't actually
-      # get this quite right, but nonetheless this is the expected output
-      expect(subject.hypothesis).to eq("go forward ten years")
+      subject.reconfigure
     end
 
-    it 'accepts a file path as well as a stream' do
-      subject.decode 'spec/assets/audio/goforward.raw'
-      expect(subject.hypothesis).to eq("go forward ten years")
+    it 'sets a new configuration if one is passed' do
+      new_config = Struct.new(:ps_config).new(:ps_config)
+
+      expect(ps_api)
+        .to receive(:ps_reinit)
+        .with(subject.ps_decoder, new_config.ps_config)
+        .and_return(0)
+
+      subject.reconfigure(new_config)
+
+      expect(subject.configuration).to be(new_config)
+    end
+
+    it 'raises an exception on error' do
+      expect(ps_api)
+        .to receive(:ps_reinit)
+        .with(subject.ps_decoder, configuration.ps_config)
+        .and_return(-1)
+
+      expect { subject.reconfigure }
+        .to raise_exception "Decoder#reconfigure failed with error code -1"
     end
   end
 

data/spec/integration/decoder_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Decoder do
+  subject { @decoder }
+  let(:configuration) { @configuration }
+
+  # Share decoder across all examples for speed
+  before :all do
+    @configuration = Configuration.default
+    @decoder = Decoder.new(@configuration)
+  end
+
+  describe '#decode' do
+    it 'correctly decodes the speech in goforward.raw' do
+      @decoder.ps_api = nil
+      subject.decode File.open('spec/assets/audio/goforward.raw', 'rb')
+
+      # With the default configuration (no specific grammar), pocketsphinx doesn't actually
+      # get this quite right, but nonetheless this is the expected output
+      expect(subject.hypothesis).to eq("go forward ten years")
+    end
+
+    it 'accepts a file path as well as a stream' do
+      subject.decode 'spec/assets/audio/goforward.raw'
+      expect(subject.hypothesis).to eq("go forward ten years")
+    end
+  end
+end

data/spec/integration/speech_recognizer_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe SpeechRecognizer do
+  let(:recordable) { AudioFile.new('spec/assets/audio/goforward.raw') }
+
+  subject do
+    SpeechRecognizer.new.tap do |speech_recognizer|
+      speech_recognizer.recordable = recordable
+      speech_recognizer.decoder = @decoder
+    end
+  end
+
+  # Share decoder across all examples for speed
+  before :all do
+    @decoder = Decoder.new(Configuration.default)
+  end
+
+  describe '#recognize' do
+    it 'should decode speech in raw audio' do
+      expect { |b| subject.recognize(4096, &b) }.to yield_with_args("go forward ten years")
+    end
+  end
+end

data/spec/microphone_spec.rb

@@ -79,6 +79,12 @@ describe Microphone do
     end
   end
 
+  describe '#read_audio_delay' do
+    it 'should be 0.128 seconds for a max_samples of 4096 and sample rate of 16kHz' do
+      expect(subject.read_audio_delay(4096)).to eq(0.128)
+    end
+  end
+
   describe '#close_device' do
     it 'calls libsphinxad' do
       expect(ps_api)

data/spec/speech_recognizer_spec.rb

@@ -1,23 +1,40 @@
 require 'spec_helper'
 
 describe SpeechRecognizer do
-  let(:recordable) { AudioFile.new('spec/assets/audio/goforward.raw') }
+  let(:configuration) { double }
+  let(:recordable) { double }
+  let(:decoder) { double }
+  subject { SpeechRecognizer.new(configuration) }
 
-  subject do
-    SpeechRecognizer.new.tap do |speech_recognizer|
-      speech_recognizer.recordable = recordable
-      speech_recognizer.decoder = @decoder
-    end
+  before do
+    subject.decoder = decoder
+    subject.recordable = recordable
   end
 
-  # Share decoder across all examples for speed
-  before :all do
-    @decoder = Decoder.new(Configuration.default)
-  end
+  describe '#reconfigure' do
+    before do
+      allow(decoder).to receive(:reconfigure)
+      allow(decoder).to receive(:start_utterance)
+    end
+
+    it 'saves the configuration if one is given' do
+      subject.reconfigure(:new_configuration)
+      expect(subject.configuration).to eq(:new_configuration)
+    end
+
+    it 'reconfigures the decoder' do
+      expect(decoder).to receive(:reconfigure).with(nil).ordered
+      expect(decoder).to receive(:reconfigure).with(:new_configuration).ordered
+
+      subject.reconfigure
+      subject.reconfigure(:new_configuration)
+    end
+
+    it 'restarts an utterance if recognition was interrupted' do
+      expect(subject).to receive(:recognizing?).and_return(true)
+      expect(decoder).to receive(:start_utterance)
 
-  describe '#recognize' do
-    it 'should decode speech in raw audio' do
-      expect { |b| subject.recognize(4096, &b) }.to yield_with_args("go forward ten years")
+      subject.reconfigure
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pocketsphinx-ruby
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Howard Wilson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-20 00:00:00.000000000 Z
+date: 2014-10-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -95,6 +95,7 @@ files:
 - README.md
 - Rakefile
 - examples/decode_audio_file.rb
+- examples/keyword_spotter.rb
 - examples/pocketsphinx_continuous.rb
 - examples/record_audio_file.rb
 - lib/pocketsphinx-ruby.rb
@@ -104,7 +105,9 @@ files:
 - lib/pocketsphinx/api/sphinxbase.rb
 - lib/pocketsphinx/audio_file.rb
 - lib/pocketsphinx/audio_file_speech_recognizer.rb
-- lib/pocketsphinx/configuration.rb
+- lib/pocketsphinx/configuration/base.rb
+- lib/pocketsphinx/configuration/default.rb
+- lib/pocketsphinx/configuration/keyword_spotting.rb
 - lib/pocketsphinx/configuration/setting_definition.rb
 - lib/pocketsphinx/decoder.rb
 - lib/pocketsphinx/live_speech_recognizer.rb
@@ -115,6 +118,8 @@ files:
 - spec/assets/audio/goforward.raw
 - spec/configuration_spec.rb
 - spec/decoder_spec.rb
+- spec/integration/decoder_spec.rb
+- spec/integration/speech_recognizer_spec.rb
 - spec/microphone_spec.rb
 - spec/spec_helper.rb
 - spec/speech_recognizer_spec.rb
@@ -146,6 +151,8 @@ test_files:
 - spec/assets/audio/goforward.raw
 - spec/configuration_spec.rb
 - spec/decoder_spec.rb
+- spec/integration/decoder_spec.rb
+- spec/integration/speech_recognizer_spec.rb
 - spec/microphone_spec.rb
 - spec/spec_helper.rb
 - spec/speech_recognizer_spec.rb

data/lib/pocketsphinx/configuration.rb

@@ -1,90 +0,0 @@
-require 'pocketsphinx/configuration/setting_definition'
-
-module Pocketsphinx
-  class Configuration
-    attr_reader :ps_config
-    attr_reader :setting_definitions
-
-    private_class_method :new
-
-    def initialize(ps_arg_defs)
-      @ps_arg_defs = ps_arg_defs
-      @setting_definitions = SettingDefinition.from_arg_defs(ps_arg_defs)
-
-      # Sets default settings based on definitions
-      @ps_config = API::Sphinxbase.cmd_ln_parse_r(nil, ps_arg_defs, 0, nil, 1)
-
-      # Sets default grammar and language model if they are not set explicitly and
-      # are present in the default search path.
-      API::Pocketsphinx.ps_default_search_args(@ps_config)
-    end
-
-    def self.default
-      new(API::Pocketsphinx.ps_args)
-    end
-
-    def setting_names
-      setting_definitions.keys.sort
-    end
-
-    # Get details for one or all configuration settings
-    #
-    # @param [String] name Name of setting to get details for. Gets details for all settings if nil.
-    def details(name = nil)
-      details = [name || setting_names].flatten.map do |name|
-        definition = find_definition(name)
-
-        {
-          name: name,
-          type: definition.type,
-          default: definition.default,
-          required: definition.required?,
-          value: self[name],
-          info: definition.doc
-        }
-      end
-
-      name ? details.first : details
-    end
-
-    # Get a configuration setting
-    def [](name)
-      case find_definition(name).type
-      when :integer
-        API::Sphinxbase.cmd_ln_int_r(@ps_config, "-#{name}")
-      when :float
-        API::Sphinxbase.cmd_ln_float_r(@ps_config, "-#{name}")
-      when :string
-        API::Sphinxbase.cmd_ln_str_r(@ps_config, "-#{name}")
-      when :boolean
-        API::Sphinxbase.cmd_ln_int_r(@ps_config, "-#{name}") != 0
-      when :string_list
-        raise NotImplementedException
-      end
-    end
-
-    # Set a configuration setting with type checking
-    def []=(name, value)
-      case find_definition(name).type
-      when :integer
-        raise "Configuration setting '#{name}' must be a Fixnum" unless value.respond_to?(:to_i)
-        API::Sphinxbase.cmd_ln_set_int_r(@ps_config, "-#{name}", value.to_i)
-      when :float
-        raise "Configuration setting '#{name}' must be a Float" unless value.respond_to?(:to_i)
-        API::Sphinxbase.cmd_ln_set_float_r(@ps_config, "-#{name}", value.to_f)
-      when :string
-        API::Sphinxbase.cmd_ln_set_str_r(@ps_config, "-#{name}", value.to_s)
-      when :boolean
-        API::Sphinxbase.cmd_ln_set_int_r(@ps_config, "-#{name}", value ? 1 : 0)
-      when :string_list
-        raise NotImplementedException
-      end
-    end
-
-    private
-
-    def find_definition(name)
-      setting_definitions[name] or raise "Configuration setting '#{name}' does not exist"
-    end
-  end
-end