pocketsphinx-ruby 0.0.3 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3bf38b30cbc9fd5c2375d2c330238d1ad429e44c
-  data.tar.gz: 82aecda7d2c95378f15f47cc897b13419b83ce00
+  metadata.gz: d3479a20de1bf075e2a4d2efcf8721c05a650751
+  data.tar.gz: a3ea68aaf9e0dc60149c2992dd8316233d8568f3
 SHA512:
-  metadata.gz: 2bb177461a17173815f299d3b17807014b80a22c3fae818569a4d29355e33dd506d3e1d4d195f8fa84ee09073014212fadd17a00e3f088a82d4278ccceea936a
-  data.tar.gz: 1ba9d9b74c999a05091e870b0fe2aee6c45df623b4d84a7364268eab1e4cf4e41dcf11b7206e90f5e3afd1d9ee292e503f8b4a6712b859e151e611944fe867a4
+  metadata.gz: e732d04275721ed223776c7d90b97894e8a778e73e334a036561715efbf868b65e8b20809730013fcaf020f21ab5de2fa646af6b7bc7aeb2f467345b6492f33e
+  data.tar.gz: a6670826d281b272ea29d4d609805328d2da8af4753d66349e78f222c5c99eaf05a7dde19faad8ac070b57e03aacab20396c5686c8b7365e4d586591bc958add

data/README.md

@@ -56,7 +56,7 @@ Or install it yourself as:
 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:
 
 ```ruby
-require 'pocketsphinx-ruby'
+require 'pocketsphinx-ruby' # Omitted in subsequent examples
 
 Pocketsphinx::LiveSpeechRecognizer.new.recognize do |speech|
   puts speech
@@ -106,7 +106,7 @@ The `Microphone` class uses Pocketsphinx's libsphinxad to record audio for speec
 For example, to record and save a 5 second raw audio file:
 
 ```ruby
-microphone = Microphone.new
+microphone = Pocketsphinx::Microphone.new
 
 File.open("test.raw", "wb") do |file|
   microphone.record do
@@ -130,7 +130,7 @@ To open this audio file take a look at [this wiki page](https://github.com/watso
 The `Decoder` class uses Pocketsphinx's libpocketsphinx to decode audio data into text. For example to decode a single utterance:
 
 ```ruby
-decoder = Decoder.new(Configuration.default)
+decoder = Pocketsphinx::Decoder.new(Pocketsphinx::Configuration.default)
 decoder.decode 'spec/assets/audio/goforward.raw'
 
 puts decoder.hypothesis # => "go forward ten years"
@@ -142,16 +142,54 @@ puts decoder.hypothesis # => "go forward ten years"
 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)
+configuration = Pocketsphinx::Configuration::KeywordSpotting.new('Okay computer')
+recognizer = Pocketsphinx::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.
+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:
+
+```ruby
+Pocketsphinx::Configuration::KeywordSpotting.new('keyword', 2).changes
+# => [
+#   { :name => "keyphrase", :type => :string, :default => nil, :required => false, :value => "keyword", :info => "Keyphrase to spot" },
+#   { :name => "kws_threshold", :type => :float, :default => 1.0, :required => false, :value => 2.0, :info => "Threshold for p(hyp)/p(alternatives) ratio" },
+#   { :name => "lm", :type => :string, :default => "/usr/local/Cellar/cmu-pocketsphinx/HEAD/share/pocketsphinx/model/lm/en_US/hub4.5000.DMP", :required => false, :value => nil, :info => "Word trigram language model input file" }
+# ]
+```
+
+
+### Grammars
+
+Another way of configuring Pocketsphinx is with a grammar, which is normally used to describe very simple types of languages for command and control. Restricting the set of possible utterances in this way can greatly improve recognition accuracy for these types of application.
+
+Load a [JSGF](http://www.w3.org/TR/jsgf/) grammar from a file:
+
+```ruby
+configuration = Pocketsphinx::Configuration::Grammar.new('sentences.gram')
+```
+
+Or build one dynamically with this simple DSL (currently only supports sentence lists):
+
+```ruby
+configuration = Pocketsphinx::Configuration::Grammar.new do
+  sentence "Go forward ten meters"
+  sentence "Go backward ten meters"
+end
+```
+
+
+## Troubleshooting
+
+This gem has been tested with a manual Pocketsphinx installation on Ubuntu 14.04 and a Homebrew Pocketsphinx installation on OSX 10.9.4 Mavericks. Take a look at the following common problems before opening an issue.
+
+**`attach_function': Function 'ps_default_search_args' not found in [libpocketsphinx.so] (FFI::NotFoundError)**
+
+An error like this probably means that you have an old version of the Pocketsphinx libraries installed. If necessary, replace them with a recent development version which supports the features available in this gem.
 
 
 ## Contributing
 
-1. Fork it ( https://github.com/[my-github-username]/pocketsphinx-ruby/fork )
+1. Fork it ( https://github.com/watsonbox/pocketsphinx-ruby/fork )
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)

data/lib/pocketsphinx.rb

@@ -6,12 +6,18 @@ require "pocketsphinx/version"
 require "pocketsphinx/api/sphinxbase"
 require "pocketsphinx/api/sphinxad"
 require "pocketsphinx/api/pocketsphinx"
+require "pocketsphinx/api/call_helpers"
+
+# Grammar
+require "pocketsphinx/grammar/jsgf"
+require "pocketsphinx/grammar/jsgf_builder"
 
 # Configuration
-require 'pocketsphinx/configuration/setting_definition'
+require "pocketsphinx/configuration/setting_definition"
 require "pocketsphinx/configuration/base"
 require "pocketsphinx/configuration/default"
 require "pocketsphinx/configuration/keyword_spotting"
+require "pocketsphinx/configuration/grammar"
 
 require "pocketsphinx/audio_file"
 require "pocketsphinx/microphone"

data/lib/pocketsphinx/api/call_helpers.rb

@@ -0,0 +1,16 @@
+module Pocketsphinx
+  module API
+    Error = Class.new(StandardError)
+
+    module CallHelpers
+      def api_call(method, *args)
+        calling_method = caller[0][/`.*'/][1..-2]
+        ps_api.send(method, *args).tap do |result|
+          if result < 0
+            raise Error, "#{self.class.to_s.split('::').last}##{calling_method} failed with error code #{result}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pocketsphinx/api/pocketsphinx.rb

@@ -17,6 +17,10 @@ module Pocketsphinx
       attach_function :ps_end_utt, [:decoder], :int
       attach_function :ps_get_in_speech, [:decoder], :uint8
       attach_function :ps_get_hyp, [:decoder, :pointer, :pointer], :string
+      attach_function :ps_set_jsgf_string, [:decoder, :string, :string], :int
+      attach_function :ps_unset_search, [:decoder, :string], :int
+      attach_function :ps_get_search, [:decoder], :string
+      attach_function :ps_set_search, [:decoder, :string], :int
     end
   end
 end

data/lib/pocketsphinx/configuration/default.rb

@@ -7,6 +7,16 @@ module Pocketsphinx
         # 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)
+
+        # Treat ps_default_search_args settings as defaults
+        changes.each do |details|
+          setting_definitions[details[:name]].deflt = details[:value]
+        end
+      end
+
+      # Show details for settings which don't match Pocketsphinx defaults
+      def changes
+        details.reject { |d| d[:default] == d[:value] }
       end
     end
 

data/lib/pocketsphinx/configuration/grammar.rb

@@ -0,0 +1,21 @@
+module Pocketsphinx
+  module Configuration
+    class Grammar < Default
+      attr_accessor :grammar
+
+      def initialize(*args, &block)#(grammar_path = nil)
+        super()
+
+        @grammar = ::Grammar::Jsgf.new(*args, &block)
+      end
+
+      # Since JSGF strings are not supported in Pocketsphinx configuration (only files),
+      # we use the post_init_decoder hook to configure the JSGF
+      def post_init_decoder(decoder)
+        decoder.unset_search
+        decoder.set_jsgf_string(grammar.raw)
+        decoder.set_search
+      end
+    end
+  end
+end

data/lib/pocketsphinx/decoder.rb

@@ -1,6 +1,6 @@
 module Pocketsphinx
   class Decoder < Struct.new(:configuration)
-    Error = Class.new(StandardError)
+    include API::CallHelpers
 
     attr_writer :ps_api
 
@@ -13,10 +13,7 @@ module Pocketsphinx
     #   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
+      reinit_decoder
     end
 
     # Decode a raw audio stream as a single utterance, opening a file if path given
@@ -64,9 +61,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|
-        raise Error, "Decoder#process_raw failed with error code #{result}" if result < 0
-      end
+      api_call :ps_process_raw, ps_decoder, buffer, size, no_search ? 1 : 0, full_utt ? 1 : 0
     end
 
     # Start utterance processing.
@@ -77,16 +72,12 @@ 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|
-        raise Error, "Decoder#start_utterance failed with error code #{result}" if result < 0
-      end
+      api_call :ps_start_utt, ps_decoder, name
     end
 
     # End utterance processing
     def end_utterance
-      ps_api.ps_end_utt(ps_decoder).tap do |result|
-        raise Error, "Decoder#end_utterance failed with error code #{result}" if result < 0
-      end
+      api_call :ps_end_utt, ps_decoder
     end
 
     # Checks if the last feed audio buffer contained speech
@@ -102,12 +93,64 @@ module Pocketsphinx
       ps_api.ps_get_hyp(ps_decoder, nil, nil)
     end
 
+    # Adds new search using JSGF model.
+    #
+    # Convenience method to parse JSGF model from string and create a search.
+    #
+    # @param [String] jsgf_string The JSGF grammar
+    # @param [String] name The search name
+    def set_jsgf_string(jsgf_string, name = 'default')
+      api_call :ps_set_jsgf_string, ps_decoder, name, jsgf_string
+    end
+
+    # Returns name of curent search in decoder
+    def get_search
+      ps_api.ps_get_search(ps_decoder)
+    end
+
+    # Actives search with the provided name.
+    #
+    # Activates search with the provided name. The search must be added before
+    # using either ps_set_fsg(), ps_set_lm() or ps_set_kws().
+    def set_search(name = 'default')
+      api_call :ps_set_search, ps_decoder, name
+    end
+
+    # Unsets the search and releases related resources.
+    #
+    # Unsets the search previously added with
+    # using either ps_set_fsg(), ps_set_lm() or ps_set_kws().
+    def unset_search(name = 'default')
+      api_call :ps_unset_search, ps_decoder, name
+    end
+
     def ps_api
       @ps_api || API::Pocketsphinx
     end
 
     def ps_decoder
-      @ps_decoder ||= ps_api.ps_init(configuration.ps_config)
+      init_decoder if @ps_decoder.nil?
+      @ps_decoder
+    end
+
+    private
+
+    def init_decoder
+      @ps_decoder = ps_api.ps_init(configuration.ps_config)
+      post_init_decoder
+    end
+
+    def reinit_decoder
+      ps_api.ps_reinit(ps_decoder, configuration.ps_config).tap do |result|
+        raise API::Error, "Decoder#reconfigure failed with error code #{result}" if result < 0
+        post_init_decoder
+      end
+    end
+
+    def post_init_decoder
+      if configuration.respond_to?(:post_init_decoder)
+        configuration.post_init_decoder(self)
+      end
     end
   end
 end

data/lib/pocketsphinx/grammar/jsgf.rb

@@ -0,0 +1,37 @@
+module Pocketsphinx
+  module Grammar
+    class Jsgf
+      attr_reader :raw
+
+      def initialize(path = nil, &block)
+        if path.nil? && !block_given?
+          raise "Either a path or block is required to create a JSGF grammar"
+        end
+
+        if block_given?
+          @raw = grammar_from_block(&block)
+        else
+          @raw = grammar_from_file(path)
+          check_grammar
+        end
+      end
+
+      def grammar_from_file(path)
+        File.read path
+      end
+
+      def grammar_from_block(&block)
+        builder = JsgfBuilder.new
+        builder.instance_eval(&block)
+        builder.jsgf
+      end
+
+      private
+
+      def check_grammar
+        # Simple header check for now
+        raise 'Invalid JSGF grammar' unless raw.lines.first.strip == "#JSGF V1.0;"
+      end
+    end
+  end
+end

data/lib/pocketsphinx/grammar/jsgf_builder.rb

@@ -0,0 +1,27 @@
+module Pocketsphinx
+  module Grammar
+    class JsgfBuilder
+      def initialize
+        @sentences = []
+      end
+
+      def sentence(sentence)
+        @sentences << sentence
+      end
+
+      def jsgf
+        header + sentences_rule
+      end
+
+      private
+
+      def header
+        "#JSGF V1.0;\n\ngrammar default;\n\n"
+      end
+
+      def sentences_rule
+        "public <sentence> = #{@sentences.map(&:downcase).join(' | ')};"
+      end
+    end
+  end
+end

data/lib/pocketsphinx/microphone.rb

@@ -3,7 +3,7 @@ module Pocketsphinx
   #
   # Implements Recordable interface (#record and #read_audio)
   class Microphone
-    Error = Class.new(StandardError)
+    include API::CallHelpers
 
     attr_reader :ps_audio_device
     attr_writer :ps_api
@@ -36,15 +36,11 @@ module Pocketsphinx
     end
 
     def start_recording
-      ps_api.ad_start_rec(@ps_audio_device).tap do |result|
-        raise Error, "Microphone#start_recording failed with error code #{result}" if result < 0
-      end
+      api_call :ad_start_rec, @ps_audio_device
     end
 
     def stop_recording
-      ps_api.ad_stop_rec(@ps_audio_device).tap do |result|
-        raise Error, "Microphone#stop_recording failed with error code #{result}" if result < 0
-      end
+      api_call :ad_stop_rec, @ps_audio_device
     end
 
     # Read next block of audio samples while recording; read upto max samples into buf.
@@ -69,9 +65,7 @@ module Pocketsphinx
     end
 
     def close_device
-      ps_api.ad_close(@ps_audio_device).tap do |result|
-        raise Error, "Microphone#close_device failed with error code #{result}" if result < 0
-      end
+      api_call :ad_close, @ps_audio_device
     end
 
     def ps_api

data/lib/pocketsphinx/version.rb

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

data/spec/assets/grammars/goforward.gram

@@ -0,0 +1,15 @@
+#JSGF V1.0;
+
+/**
+ * JSGF Grammar for Turtle example
+ */
+
+grammar goforward;
+
+public <move> = go forward ten meters;
+
+public <move2> = go <direction> <distance> [meter | meters];
+
+<direction> = forward | backward;
+
+<distance> = one | two | three | four | five | six | seven | eight | nine | ten;

data/spec/assets/grammars/invalid.gram

@@ -0,0 +1 @@
+This isn't a valid grammar

data/spec/assets/grammars/sentences.gram

@@ -0,0 +1,5 @@
+#JSGF V1.0;
+
+grammar default;
+
+public <sentence> = go forward ten meters | go backward ten meters;

data/spec/configuration_spec.rb

@@ -90,12 +90,16 @@ describe Configuration do
   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 'modifies the default configuration keyphrase and language model' do
+      changes = subject.changes
+
+      expect(changes.count).to be(2)
+
+      expect(changes[0][:name]).to eq('keyphrase')
+      expect(changes[0][:value]).to eq('okay computer')
 
-    it 'uses no language model' do
-      expect(subject['lm']).to be_nil
+      expect(changes[1][:name]).to eq('lm')
+      expect(changes[1][:value]).to be_nil
     end
 
     it 'exposes the keyphrase setting as #keyword' do

data/spec/decoder_spec.rb

@@ -12,12 +12,18 @@ describe Decoder do
   end
 
   describe '#reconfigure' do
-    it 'calls libpocketsphinx' do
+    it 'calls libpocketsphinx and the configuration post initialize hook' do
       expect(ps_api)
         .to receive(:ps_reinit)
         .with(subject.ps_decoder, configuration.ps_config)
         .and_return(0)
 
+      configuration.define_singleton_method(:post_init_decoder) { |decoder| }
+
+      expect(configuration)
+        .to receive(:post_init_decoder)
+        .with(subject)
+
       subject.reconfigure
     end
 
@@ -133,4 +139,74 @@ describe Decoder do
       expect(subject.hypothesis).to eq("Hypothesis")
     end
   end
+
+  describe '#set_jsgf_string' do
+    it 'calls libpocketsphinx' do
+      expect(ps_api)
+        .to receive(:ps_set_jsgf_string)
+        .with(subject.ps_decoder, 'default', 'JSGF')
+        .and_return(0)
+
+      subject.set_jsgf_string('JSGF')
+    end
+
+    it 'raises an exception on error' do
+      expect(ps_api)
+        .to receive(:ps_set_jsgf_string)
+        .and_return(-1)
+
+      expect { subject.set_jsgf_string('JSGF') }
+        .to raise_exception "Decoder#set_jsgf_string failed with error code -1"
+    end
+  end
+
+  describe '#set_search' do
+    it 'calls libpocketsphinx' do
+      expect(ps_api)
+        .to receive(:ps_set_search)
+        .with(subject.ps_decoder, 'search')
+        .and_return(0)
+
+      subject.set_search('search')
+    end
+
+    it 'raises an exception on error' do
+      expect(ps_api)
+        .to receive(:ps_set_search)
+        .and_return(-1)
+
+      expect { subject.set_search('search') }
+        .to raise_exception "Decoder#set_search failed with error code -1"
+    end
+  end
+
+  describe '#unset_search' do
+    it 'calls libpocketsphinx' do
+      expect(ps_api)
+        .to receive(:ps_unset_search)
+        .with(subject.ps_decoder, 'search')
+        .and_return(0)
+
+      subject.unset_search('search')
+    end
+
+    it 'raises an exception on error' do
+      expect(ps_api)
+        .to receive(:ps_unset_search)
+        .and_return(-1)
+
+      expect { subject.unset_search('search') }
+        .to raise_exception "Decoder#unset_search failed with error code -1"
+    end
+  end
+
+  describe '#get_search' do
+    it 'calls libpocketsphinx' do
+      expect(ps_api)
+        .to receive(:ps_get_search)
+        .and_return(:search)
+
+      expect(subject.get_search).to eq(:search)
+    end
+  end
 end

data/spec/grammar_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Grammar::Jsgf do
+  it "raises an exception when neither a file or block are given" do
+    expect { Grammar::Jsgf.new }.to raise_exception "Either a path or block is required to create a JSGF grammar"
+  end
+
+  context "reading a grammar from a file" do
+    let(:grammar_path) { grammar :goforward }
+    subject { Grammar::Jsgf.new(grammar_path) }
+
+    it "reads a grammar from a file" do
+      expect(subject.raw.lines.count).to eq(15)
+    end
+
+    context "the grammar file is invalid" do
+      let(:grammar_path) { grammar :invalid }
+
+      it "raises an exception" do
+        expect { subject }.to raise_exception "Invalid JSGF grammar"
+      end
+    end
+  end
+
+  context "building a grammer from a block" do
+    subject do
+      Grammar::Jsgf.new do
+        sentence "Go forward ten meters"
+        sentence "Go backward ten meters"
+      end
+    end
+
+    it "builds a grammar from a block" do
+      expect(subject.raw).to eq(File.read grammar(:sentences))
+    end
+  end
+
+  private
+
+  def grammar(name)
+    "spec/assets/grammars/#{name}.gram"
+  end
+end

data/spec/integration/default_recognition_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe 'speech recognition with default configuration' do
+  subject do
+    AudioFileSpeechRecognizer.new.tap do |speech_recognizer|
+      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('spec/assets/audio/goforward.raw', 4096, &b) }.
+        to yield_with_args("go forward ten years")
+    end
+  end
+end

data/spec/integration/{speech_recognizer_spec.rb → grammar_recognition_spec.rb}

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe SpeechRecognizer do
+describe 'speech recognition with a grammar' do
   let(:recordable) { AudioFile.new('spec/assets/audio/goforward.raw') }
 
   subject do
@@ -12,12 +12,13 @@ describe SpeechRecognizer do
 
   # Share decoder across all examples for speed
   before :all do
-    @decoder = Decoder.new(Configuration.default)
+    @configuration = Configuration::Grammar.new('spec/assets/grammars/goforward.gram')
+    @decoder = Decoder.new(@configuration)
   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")
+      expect { |b| subject.recognize(4096, &b) }.to yield_with_args("go forward ten meters")
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pocketsphinx-ruby
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.0
 platform: ruby
 authors:
 - Howard Wilson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-21 00:00:00.000000000 Z
+date: 2014-10-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -100,6 +100,7 @@ files:
 - examples/record_audio_file.rb
 - lib/pocketsphinx-ruby.rb
 - lib/pocketsphinx.rb
+- lib/pocketsphinx/api/call_helpers.rb
 - lib/pocketsphinx/api/pocketsphinx.rb
 - lib/pocketsphinx/api/sphinxad.rb
 - lib/pocketsphinx/api/sphinxbase.rb
@@ -107,19 +108,27 @@ files:
 - lib/pocketsphinx/audio_file_speech_recognizer.rb
 - lib/pocketsphinx/configuration/base.rb
 - lib/pocketsphinx/configuration/default.rb
+- lib/pocketsphinx/configuration/grammar.rb
 - lib/pocketsphinx/configuration/keyword_spotting.rb
 - lib/pocketsphinx/configuration/setting_definition.rb
 - lib/pocketsphinx/decoder.rb
+- lib/pocketsphinx/grammar/jsgf.rb
+- lib/pocketsphinx/grammar/jsgf_builder.rb
 - lib/pocketsphinx/live_speech_recognizer.rb
 - lib/pocketsphinx/microphone.rb
 - lib/pocketsphinx/speech_recognizer.rb
 - lib/pocketsphinx/version.rb
 - pocketsphinx-ruby.gemspec
 - spec/assets/audio/goforward.raw
+- spec/assets/grammars/goforward.gram
+- spec/assets/grammars/invalid.gram
+- spec/assets/grammars/sentences.gram
 - spec/configuration_spec.rb
 - spec/decoder_spec.rb
+- spec/grammar_spec.rb
 - spec/integration/decoder_spec.rb
-- spec/integration/speech_recognizer_spec.rb
+- spec/integration/default_recognition_spec.rb
+- spec/integration/grammar_recognition_spec.rb
 - spec/microphone_spec.rb
 - spec/spec_helper.rb
 - spec/speech_recognizer_spec.rb
@@ -149,10 +158,15 @@ specification_version: 4
 summary: Ruby FFI pocketsphinx bindings
 test_files:
 - spec/assets/audio/goforward.raw
+- spec/assets/grammars/goforward.gram
+- spec/assets/grammars/invalid.gram
+- spec/assets/grammars/sentences.gram
 - spec/configuration_spec.rb
 - spec/decoder_spec.rb
+- spec/grammar_spec.rb
 - spec/integration/decoder_spec.rb
-- spec/integration/speech_recognizer_spec.rb
+- spec/integration/default_recognition_spec.rb
+- spec/integration/grammar_recognition_spec.rb
 - spec/microphone_spec.rb
 - spec/spec_helper.rb
 - spec/speech_recognizer_spec.rb