alexa_generator 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 650a7b5cb37d30de5a4feb18846c71ce321fa48e
+  data.tar.gz: c9b7b88fcd63212a071b6b770241cddf5bd87365
+SHA512:
+  metadata.gz: 5fa2035fe237d45fe6168855a4c0b2c3034a180d5ea42196b27fb2a69dab9c3171ac8e4a4c8bd3088a2e6214671cb88283a93f20e2a5ecb9d249ec449cc90e99
+  data.tar.gz: d3f16acdef5a3cf0c0c5b8f927aa1b572bad896c7ffa5e5ab6c2551dbb863b47ccafd49e257ea7666b0f78cf4b153bb2810b82c17651b21c077bbb304526f049

data/.gitignore

@@ -0,0 +1,38 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+Gemfile.lock
+.ruby-version
+.ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+# IntelliJ
+*.iml

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Chris Mullins
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,2 @@
+# alexa_generator
+Rubygem to generate voice interface components for Amazon's Alexa API

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler/gem_tasks'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+
+task default: :spec
+task test: :spec

data/alexa_generator.gemspec

@@ -0,0 +1,28 @@
+$:.push File.expand_path('../lib', __FILE__)
+
+require "alexa_generator/version"
+
+Gem::Specification.new do |gem|
+  gem.name    = 'alexa_generator'
+  gem.version = AlexaGenerator::VERSION
+
+  gem.summary = "Generates voice interfaces for Alexa apps based on templates."
+
+  gem.authors  = ['Christopher Mullins']
+  gem.email    = 'chris@sidoh.org'
+  gem.homepage = 'http://github.com/sidoh/alexa_generator'
+
+  gem.add_development_dependency('rspec', [">= 3.0.0"])
+  gem.add_development_dependency('rake')
+
+  ignores  = File.readlines(".gitignore").grep(/\S+/).map(&:chomp)
+  dotfiles = %w[.gitignore]
+
+  all_files_without_ignores = Dir["**/*"].reject { |f|
+    File.directory?(f) || ignores.any? { |i| File.fnmatch(i, f) }
+  }
+
+  gem.files = (all_files_without_ignores + dotfiles).sort
+
+  gem.require_path = "lib" 
+end

data/lib/alexa_generator/intent.rb

@@ -0,0 +1,51 @@
+require 'alexa_generator/slot'
+require 'alexa_generator/sample_utterance_template'
+
+module AlexaGenerator
+  class Intent
+    attr_reader :name, :slots
+
+    class Builder
+      attr_reader :bindings, :utterance_templates
+
+      def initialize(name)
+        @name = name
+        @slots = []
+        @bindings = []
+        @utterance_templates = []
+      end
+
+      def add_slot(name, type, &block)
+        builder = Slot.build(name, type, &block)
+
+        slot_bindings = builder.bindings.map { |x| SlotBinding.new(name, x) }
+        @bindings.concat(slot_bindings)
+
+        @slots.push(builder.create)
+      end
+
+      def add_utterance_template(template)
+        add_utterance_templates(template)
+      end
+
+      def add_utterance_templates(*templates)
+        templates.each { |x| @utterance_templates.push(SampleUtteranceTemplate.new(@name, x)) }
+      end
+
+      def create
+        Intent.new(@name, @slots)
+      end
+    end
+
+    def initialize(name, slots)
+      @name = name
+      @slots = slots
+    end
+
+    def self.build(name, &block)
+      builder = Builder.new(name)
+      block.call(builder)
+      builder
+    end
+  end
+end

data/lib/alexa_generator/intent_schema.rb

@@ -0,0 +1,11 @@
+require 'alexa_generator/intent'
+
+module AlexaGenerator
+  class IntentSchema
+    attr_reader :intents
+
+    def initialize(intents)
+      @intents = intents
+    end
+  end
+end

data/lib/alexa_generator/sample_utterance_template.rb

@@ -0,0 +1,14 @@
+module AlexaGenerator
+  class SampleUtteranceTemplate
+    attr_reader :intent_name, :template
+
+    def initialize(intent_name, template)
+      @intent_name = intent_name
+      @template = template
+    end
+
+    def referenced_slots
+      template.scan( /\{([a-z]+)\}/i ).map(&:first).map(&:to_sym)
+    end
+  end
+end

data/lib/alexa_generator/slot.rb

@@ -0,0 +1,46 @@
+module AlexaGenerator
+  class Slot
+    module SlotType
+      LITERAL = :LITERAL
+      NUMBER = :NUMBER
+      DATE = :DATE
+      TIME = :TIME
+      DURATION = :DURATION
+    end
+
+    class Builder
+      attr_reader :bindings
+
+      def initialize(name, type)
+        @name = name
+        @type = type
+        @bindings = []
+      end
+
+      def add_binding(value)
+        add_bindings(value)
+      end
+
+      def add_bindings(*values)
+        values.map { |v| @bindings.push(v) }
+      end
+
+      def create
+        Slot.new(@name, @type)
+      end
+    end
+
+    attr_reader :name, :type
+
+    def initialize(name, type)
+      @name = name.to_sym
+      @type = type
+    end
+
+    def self.build(name, type, &block)
+      builder = Builder.new(name, type)
+      block.call(builder)
+      builder
+    end
+  end
+end

data/lib/alexa_generator/slot_binding.rb

@@ -0,0 +1,14 @@
+module AlexaGenerator
+  class SlotBinding
+    attr_reader :slot_name, :value
+
+    def initialize(slot_name, value)
+      @slot_name = slot_name
+      @value = value
+    end
+
+    def bind_to_template!(template)
+      template.gsub! "{#{slot_name}}", "{#{value}|#{slot_name}}"
+    end
+  end
+end

data/lib/alexa_generator/version.rb

@@ -0,0 +1,3 @@
+module AlexaGenerator
+  VERSION = '0.1.0'
+end

data/lib/alexa_generator/voice_interface.rb

@@ -0,0 +1,105 @@
+require 'alexa_generator/intent_schema'
+require 'alexa_generator/sample_utterance_template'
+require 'alexa_generator/slot_binding'
+
+require 'set'
+
+module AlexaGenerator
+  class VoiceInterface
+    attr_reader :intents
+
+    class Builder
+      def initialize
+        @intents = []
+        @bindings = []
+        @utterance_templates = []
+      end
+
+      def add_intent(name, &block)
+        builder = Intent.build(name, &block)
+        @bindings.concat(builder.bindings)
+        @utterance_templates.concat(builder.utterance_templates)
+        @intents.push(builder.create)
+      end
+
+      def create
+        VoiceInterface.new(@intents, @utterance_templates, @bindings)
+      end
+    end
+
+    def initialize(intents, utterance_templates, slot_bindings)
+      @intents = Hash[ intents.map {|x| [x.name, x]} ]
+
+      @utterance_templates = utterance_templates.group_by { |x| x.intent_name }
+      @slot_bindings = slot_bindings.group_by { |x| x.slot_name }
+    end
+
+    def intent_schema
+      {
+          intents: @intents.values.map do |intent|
+            {
+                intent: intent.name,
+                slots: intent.slots.map do |slot|
+                  {
+                      name: slot.name,
+                      type: slot.type
+                  }
+                end
+            }
+          end
+      }
+    end
+
+    def sample_utterances(intent_name)
+      templates = @utterance_templates[intent_name] || []
+      utterances = Set.new
+
+      templates.each do |template|
+        # Consider only the slots that are referenced in this template
+        relevant_slots = template.referenced_slots
+
+        # Compute all possible value bindings for the relevant slots
+        slot_values = relevant_slots.
+            # Extract value bindings for each slot
+            map { |slot| @slot_bindings[slot] }
+
+        if slot_values.any?
+          slot_value_combinations = slot_values.first
+
+          if slot_values.count > 1
+            remaining_values = slot_values[1..-1]
+            slot_value_combinations = slot_value_combinations.product(*remaining_values)
+          else
+            slot_value_combinations = slot_value_combinations.map { |x| [x] }
+          end
+
+          slot_value_combinations.each do |value_binding|
+            raw_template = template.template.dup
+
+            # puts value_binding.inspect
+
+            value_binding.each do |binding|
+              # puts "----> #{binding}"
+              binding.bind_to_template!( raw_template )
+            end
+
+            utterances.add( raw_template )
+          end
+        # If there are no slot values, then just stuff the untouched template into utterances.
+        else
+          utterances.add( template.template )
+        end
+      end
+
+      utterances.sort.map do |utterance|
+        "#{intent_name} #{utterance}"
+      end
+    end
+
+    def self.build(&block)
+      builder = Builder.new
+      block.call(builder)
+      builder.create
+    end
+  end
+end

data/lib/alexa_generator.rb

@@ -0,0 +1,2 @@
+require 'alexa_generator/voice_interface'
+require 'alexa_generator/version'

data/spec/alexa_generator/intent_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe AlexaGenerator::Slot do
+  context 'builder' do
+    it 'should return an instance of a builder' do
+      slot = AlexaGenerator::Intent.build(:IntentOne) { |x| }
+
+      expect(slot).to be_an_instance_of(AlexaGenerator::Intent::Builder)
+    end
+
+    it 'should add slot bindings' do
+      intent = AlexaGenerator::Intent.build(:IntentOne) do |intent|
+        intent.add_slot(:SlotOne, AlexaGenerator::Slot::SlotType::LITERAL) do |slot|
+          slot.add_bindings('a', 'b', 'c')
+        end
+      end
+
+      expect(intent.bindings).to be_an_instance_of(Array)
+      expect(intent.bindings.map(&:value)).to eq(['a', 'b', 'c'])
+    end
+
+    it 'should create an intent when create is called' do
+      builder = AlexaGenerator::Intent.build(:IntentOne) do |intent|
+        intent.add_slot(:SlotOne, AlexaGenerator::Slot::SlotType::LITERAL) do |slot|
+          slot.add_bindings('a', 'b', 'c')
+        end
+      end
+
+      intent = builder.create
+
+      expect(intent.name).to eq(:IntentOne)
+
+      expect(intent.slots.count).to eq(1)
+      expect(intent.slots.first.name).to eq(:SlotOne)
+    end
+  end
+end

data/spec/alexa_generator/sample_utterance_template_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe AlexaGenerator::SampleUtteranceTemplate do
+  it 'should parse slots out of templates' do
+    template = AlexaGenerator::SampleUtteranceTemplate.new 'MyIntent', 'Intent, {SlotOne} and {SlotTwo}'
+
+    expect(template.referenced_slots).to eq([:SlotOne, :SlotTwo])
+  end
+
+  it 'should work with no slots' do
+    template = AlexaGenerator::SampleUtteranceTemplate.new 'MyIntent', 'Intent, do that thing'
+
+    expect(template.referenced_slots).to eq([])
+  end
+
+  it 'should not detect bound slots' do
+    template = AlexaGenerator::SampleUtteranceTemplate.new 'MyIntent', 'Intent, do {that|Thing}'
+
+    expect(template.referenced_slots).to eq([])
+  end
+end

data/spec/alexa_generator/slot_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe AlexaGenerator::Slot do
+  context 'builder' do
+    it 'should return an instance of a builder' do
+      slot = AlexaGenerator::Slot.build(:SlotOne, AlexaGenerator::Slot::SlotType::LITERAL) { |x| }
+
+      expect(slot).to be_an_instance_of(AlexaGenerator::Slot::Builder)
+    end
+
+    it 'should add slot bindings' do
+      slot = AlexaGenerator::Slot.build(:SlotOne, AlexaGenerator::Slot::SlotType::LITERAL) do |slot|
+        slot.add_bindings('a', 'b', 'c')
+      end
+
+      expect(slot.bindings).to eq(['a', 'b', 'c'])
+    end
+
+    it 'should create a slot when create is called' do
+      builder = AlexaGenerator::Slot.build(:SlotOne, AlexaGenerator::Slot::SlotType::LITERAL) do |slot|
+        slot.add_bindings('a', 'b', 'c')
+      end
+
+      slot = builder.create
+
+      expect(slot.name).to eq(:SlotOne)
+      expect(slot.type).to eq(AlexaGenerator::Slot::SlotType::LITERAL)
+    end
+  end
+end

data/spec/alexa_generator/voice_interface_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+require 'json'
+
+describe AlexaGenerator::VoiceInterface do
+  context 'builder' do
+    it 'should build a valid voice interface' do
+      iface = AlexaGenerator::VoiceInterface.build do |iface|
+        iface.add_intent(:IntentOne) do |intent|
+         intent.add_slot(:SlotOne, AlexaGenerator::Slot::SlotType::LITERAL) do |slot|
+            slot.add_binding('value1')
+          end
+
+          intent.add_utterance_template('test {SlotOne} test')
+        end
+      end
+
+      expect(iface).to be_an_instance_of(AlexaGenerator::VoiceInterface)
+      expect(iface.intent_schema).to eq(
+                                         {
+                                             intents: [
+                                                 {
+                                                     intent: :IntentOne,
+                                                     slots: [
+                                                         {
+                                                             name: :SlotOne,
+                                                             type: AlexaGenerator::Slot::SlotType::LITERAL
+                                                         }
+                                                     ]
+                                                 }
+                                             ]
+                                         })
+    end
+
+    it 'should produce bound utterances' do
+      iface = AlexaGenerator::VoiceInterface.build do |iface|
+        iface.add_intent(:MyIntent) do |intent|
+          intent.add_slot(:SlotOne, AlexaGenerator::Slot::SlotType::LITERAL) do |slot|
+            slot.add_binding('make me a sandwich')
+            slot.add_binding('fix my motorcycle')
+          end
+
+          intent.add_slot(:SlotTwo, AlexaGenerator::Slot::SlotType::NUMBER) do |slot|
+            slot.add_binding('one')
+            slot.add_binding('two')
+          end
+
+          intent.add_slot(:SlotThree, AlexaGenerator::Slot::SlotType::TIME) do |slot|
+            slot.add_binding('6 a.m.')
+            slot.add_binding('noon')
+          end
+
+          intent.add_utterance_template('Alexa, please {SlotOne} {SlotTwo} at {SlotThree}')
+        end
+      end
+
+      actual = iface.sample_utterances(:MyIntent)
+
+      expect(actual.count).to eq(8)
+      expect(actual).to include('MyIntent Alexa, please {fix my motorcycle|SlotOne} {one|SlotTwo} at {noon|SlotThree}')
+      expect(actual).to include('MyIntent Alexa, please {fix my motorcycle|SlotOne} {two|SlotTwo} at {noon|SlotThree}')
+      expect(actual).to include('MyIntent Alexa, please {make me a sandwich|SlotOne} {one|SlotTwo} at {noon|SlotThree}')
+      expect(actual).to include('MyIntent Alexa, please {make me a sandwich|SlotOne} {two|SlotTwo} at {noon|SlotThree}')
+      expect(actual).to include('MyIntent Alexa, please {fix my motorcycle|SlotOne} {one|SlotTwo} at {6 a.m.|SlotThree}')
+      expect(actual).to include('MyIntent Alexa, please {fix my motorcycle|SlotOne} {two|SlotTwo} at {6 a.m.|SlotThree}')
+      expect(actual).to include('MyIntent Alexa, please {make me a sandwich|SlotOne} {one|SlotTwo} at {6 a.m.|SlotThree}')
+      expect(actual).to include('MyIntent Alexa, please {make me a sandwich|SlotOne} {two|SlotTwo} at {6 a.m.|SlotThree}')
+    end
+  end
+
+  context 'with no templates' do
+    intents = [ AlexaGenerator::Intent.new( :MyIntent, [] ) ]
+    utterance_templates = [
+        AlexaGenerator::SampleUtteranceTemplate.new( :MyIntent, 'Alexa, please do that one thing')
+    ]
+    slot_bindings = []
+
+    it 'should produce utterances' do
+      actual = AlexaGenerator::VoiceInterface.new(intents, utterance_templates, slot_bindings).sample_utterances(:MyIntent)
+      expected = [ "#{utterance_templates.first.intent_name} #{utterance_templates.first.template}" ]
+
+      expect(actual).to eq(expected)
+    end
+  end
+
+  context 'with a single template' do
+    intents = [
+        AlexaGenerator::Intent.new(
+            :MyIntent, [ AlexaGenerator::Slot.new(:SlotOne, AlexaGenerator::Slot::SlotType::LITERAL) ]
+        )
+    ]
+    utterance_templates = [
+        AlexaGenerator::SampleUtteranceTemplate.new( :MyIntent, 'Alexa, please {SlotOne}')
+    ]
+    slot_bindings = [
+        AlexaGenerator::SlotBinding.new( :SlotOne, 'make me a sandwich' ),
+        AlexaGenerator::SlotBinding.new( :SlotOne, 'fix my motorcycle' )
+    ]
+
+    it 'should produce bound utterances' do
+      actual = AlexaGenerator::VoiceInterface.new(intents, utterance_templates, slot_bindings).sample_utterances(:MyIntent)
+
+      expect(actual.count).to eq(slot_bindings.count)
+      expect(actual).to include('MyIntent Alexa, please {make me a sandwich|SlotOne}')
+      expect(actual).to include('MyIntent Alexa, please {fix my motorcycle|SlotOne}')
+    end
+  end
+
+  context 'with multiple templates' do
+    intents = [
+        AlexaGenerator::Intent.new(
+            :MyIntent, [
+                         AlexaGenerator::Slot.new(:SlotOne, AlexaGenerator::Slot::SlotType::LITERAL),
+                         AlexaGenerator::Slot.new(:SlotTwo, AlexaGenerator::Slot::SlotType::NUMBER),
+                         AlexaGenerator::Slot.new(:SlotThree, AlexaGenerator::Slot::SlotType::TIME),
+                     ],
+        )
+    ]
+    utterance_templates = [
+        AlexaGenerator::SampleUtteranceTemplate.new( :MyIntent, 'Alexa, please {SlotOne} {SlotTwo} at {SlotThree}')
+    ]
+    slot_bindings = [
+        AlexaGenerator::SlotBinding.new( :SlotOne, 'make me a sandwich' ),
+        AlexaGenerator::SlotBinding.new( :SlotOne, 'fix my motorcycle' ),
+
+        AlexaGenerator::SlotBinding.new( :SlotTwo, 'one' ),
+        AlexaGenerator::SlotBinding.new( :SlotTwo, 'two' ),
+
+        AlexaGenerator::SlotBinding.new( :SlotThree, '6 a.m.' ),
+        AlexaGenerator::SlotBinding.new( :SlotThree, 'noon' ),
+    ]
+
+    it 'should produce bound utterances' do
+      actual = AlexaGenerator::VoiceInterface.new(intents, utterance_templates, slot_bindings).sample_utterances(:MyIntent)
+
+      expect(actual.count).to eq(8)
+      expect(actual).to include('MyIntent Alexa, please {fix my motorcycle|SlotOne} {one|SlotTwo} at {noon|SlotThree}')
+      expect(actual).to include('MyIntent Alexa, please {fix my motorcycle|SlotOne} {two|SlotTwo} at {noon|SlotThree}')
+      expect(actual).to include('MyIntent Alexa, please {make me a sandwich|SlotOne} {one|SlotTwo} at {noon|SlotThree}')
+      expect(actual).to include('MyIntent Alexa, please {make me a sandwich|SlotOne} {two|SlotTwo} at {noon|SlotThree}')
+      expect(actual).to include('MyIntent Alexa, please {fix my motorcycle|SlotOne} {one|SlotTwo} at {6 a.m.|SlotThree}')
+      expect(actual).to include('MyIntent Alexa, please {fix my motorcycle|SlotOne} {two|SlotTwo} at {6 a.m.|SlotThree}')
+      expect(actual).to include('MyIntent Alexa, please {make me a sandwich|SlotOne} {one|SlotTwo} at {6 a.m.|SlotThree}')
+      expect(actual).to include('MyIntent Alexa, please {make me a sandwich|SlotOne} {two|SlotTwo} at {6 a.m.|SlotThree}')
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'bundler'
+Bundler.require(:default, :development)
+
+require 'rspec'
+
+require 'alexa_generator'

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: alexa_generator
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Christopher Mullins
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: chris@sidoh.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- alexa_generator.gemspec
+- lib/alexa_generator.rb
+- lib/alexa_generator/intent.rb
+- lib/alexa_generator/intent_schema.rb
+- lib/alexa_generator/sample_utterance_template.rb
+- lib/alexa_generator/slot.rb
+- lib/alexa_generator/slot_binding.rb
+- lib/alexa_generator/version.rb
+- lib/alexa_generator/voice_interface.rb
+- spec/alexa_generator/intent_spec.rb
+- spec/alexa_generator/sample_utterance_template_spec.rb
+- spec/alexa_generator/slot_spec.rb
+- spec/alexa_generator/voice_interface_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/sidoh/alexa_generator
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Generates voice interfaces for Alexa apps based on templates.
+test_files: []