alexa_web_service 0.0.6 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3430dcd433c560a334840529c3ecb341836158d9
-  data.tar.gz: a58146e5d3509a760883f277e4ae8733d70b7f19
+  metadata.gz: 4e77c95bba2bc9c56617f050c1579f572e76450c
+  data.tar.gz: 04ed856e3976cc87dcc15957bc27a4101c032fe1
 SHA512:
-  metadata.gz: ac7eb3ef3827e29692f5fad90e08df2a0ed7e533dd5f355dc5e8a27ae669371df12df02cdd5f1234025df9335abf3e26f583009af357ac11920b3cfa4bef8739
-  data.tar.gz: fd580581d53ba5632d11ec9aee5116623e6947666cd47451301e9d957e3d666d5a7e189830c87ccbf26632f44f54738153309e1640bfa63f380b5f0f8cbdabf5
+  metadata.gz: a6d032a7f83d9a97043165a8601cac3781280d22b37822a816597f19ef9b5136dfebfc7a7bebc1aad7a6447c0b50d488eed899bee629058e78f7e064f0420d4f
+  data.tar.gz: 460410d8ae38d6b3eddfdf90f9c58c64f6045f1344f8cbad40a93b7914a180349808b21484f9a414e437f9ad60dbcad8f11459e429c11dbb99adc58d3224434e

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in alexa_web_service.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,41 @@
+PATH
+  remote: .
+  specs:
+    alexa_web_service (1.0.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.2.5)
+    httparty (0.15.7)
+      multi_xml (>= 0.5.2)
+    json (2.1.0)
+    multi_xml (0.6.0)
+    rake (10.5.0)
+    rspec (3.5.0)
+      rspec-core (~> 3.5.0)
+      rspec-expectations (~> 3.5.0)
+      rspec-mocks (~> 3.5.0)
+    rspec-core (3.5.2)
+      rspec-support (~> 3.5.0)
+    rspec-expectations (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-mocks (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-support (3.5.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  alexa_web_service!
+  bundler (~> 1.15)
+  httparty (~> 0.15.7)
+  json (~> 2.1, >= 2.1.0)
+  rake (~> 10.0)
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   1.16.1

data/README.md

@@ -0,0 +1,235 @@
+# AlexaWebService
+
+Framework for building an Alexa skill. 
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'alexa_web_service'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install alexa_web_service
+
+## Usage ##
+
+The Alexa Web Service gem handles the JSON requests and responses that constitute an Alexa "Skill."
+For general information on creating an Alexa skill as a web service, look here:
+https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/alexa-skills-kit-interface-reference#Introduction
+
+Alexa will send your web service JSON in an HTTP POST request, like so:
+
+````Ruby
+{
+  "session": {
+    "sessionId": "SessionId.abc12d34-12ab-1abc-111-a12c3456d7ef9",
+    "application": {
+      "applicationId": "amzn1.echo-sdk-ams.app.xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
+    },
+    "attributes": {},
+    "user": {
+      "userId": "amzn1.account.AHHLP1234ABC5DEFG6HIJK7XLMN"
+    },
+    "new": true
+  },
+  "request": {
+    "type": "LaunchRequest",
+    "requestId": "EdwRequestId.xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
+    "timestamp": "2016-06-17T21:07:57Z",
+    "locale": "en-US"
+  },
+  "version": "1.0"
+}
+````
+
+#### Verify: Verify the Alexa request ####
+
+The Alexa Web Service framework will automatically verify that the request comes from Amazon, as outlined [here](https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/developing-an-alexa-skill-as-a-web-service)
+
+The AlexaVerify class takes two parameters: the request body sent by the client, and the raw environment hash.
+So if you're setting up a Sinatra server, you can verify the request like so:
+
+````Ruby
+# If the request body has been read, like in the Eight Ball example,
+# you need to rewind it.
+request.body.rewind
+
+# Verify the request.
+verified = AlexaWebService::Verify.new(request.env, request.body.read).verify_request
+halt 400, "#{verified}" unless verified == "OK"
+````
+
+#### Request: Handling the request from Alexa ####
+
+Create an instance of the AlexaRequest class to provide some convenience methods for handling the JSON request:
+
+````Ruby
+@echo_request = AlexaWebService::Request.new(request_json)
+
+@echo_request.intent_name
+@echo_request.slots
+@echo_request.slots.myslot
+@echo_request.launch_request?
+@echo_request.intent_request?
+@echo_request.session_ended_request?
+@echo_request.session_new?
+````
+
+Your skill provides different responses (see next section) depending on the the type/name/slot values of the request: 
+
+````Ruby
+if @echo_request.launch_request
+  # have alexa say hello
+elsif @echo_request.intent_name == "InformationRequest"
+  # ask use for what kind of information she wants
+elsif @echo_request.slots.time
+  # tell user the time
+end
+````
+
+(Take a look at eight_ball.rb for some further examples.)
+
+
+#### Response: Respond to Alexa requests ####
+
+The AlexaResponse class generates the proper JSON to make Alexa responses.
+
+Create a new response object:
+
+````response = AlexaWebService::Response.new````
+
+Then, define the response attributes:
+
+````Ruby
+response.end_session = true
+response.spoken_response = "This is what Alexa will say to you"
+response.reprompt_text = "This is what she'll say if she doesn't hear your response the first time."
+````
+
+You can then send the response back to Alexa with the following command:
+
+
+````Ruby
+response.without_card.to_json
+````
+
+So, putting the AlexaRequest and AlexaResponse together:
+
+````Ruby
+response = AlexaWebService::Response.new
+
+if @echo_request.launch_request
+  response.spoken_response = "Hello user"
+  response.end_session = true
+end
+
+response.without_card.to_json
+````
+ 
+You can use [SSML](https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/speech-synthesis-markup-language-ssml-reference):
+
+````Ruby
+response.speech_type = "SSML"
+response.text_type = "ssml"
+response.spoken_response = "<speak>Here is a word spelled out: <say-as interpret-as="spell-out">hello</say-as></speak>"
+````
+
+Alexa uses a "session attribute" to persist data within a session. (It's the empty "attributes" hash in the sample JSON request above.) The #add_attribute adds key:value pairs to that attributes hash.
+
+````Ruby
+response.add_attribute("favorite_color", "blue" )
+````
+### Adding a  Directive ###
+AlexaWebService supports directives: [hint and display directives](https://developer.amazon.com/docs/custom-skills/display-interface-reference.html) (for Alexa devices with screens), and [progresssive response](https://developer.amazon.com/docs/custom-skills/send-the-user-a-progressive-response.html). They work a little differently. 
+
+*Display Directive*
+Please see the Amazon docs. Display Directives are a bit involved.
+First, create the directive:
+````ruby
+display = AlexaWebService::DisplayDirective.new(
+  type: "Body Template Type", token: "Your Token", title: "Your Title"
+  )
+display.add_text(primary_text: "first text", secondary_text: "second_text", tertiary_text: "third text")
+display.add_background_image("title", url)
+display.add__image("title", url)
+````
+then, add it to your response:
+````
+response.add_directive(display.directive)
+````
+*Hint Directive*
+````
+hint = AlexaWebService::HintDirective.new("Buy low, sell high!")
+response.add_directive(hint.directive)
+````
+*Progressive Response*
+These are a bit different than other directives. They are not sent with your response, but are sent before. They take two parameters, the entire request object, and the text you'd like Alexa to speak.
+````
+progressive_response = AlexaWebService::ProgressiveResponse.new(request, "Hang on, looking up information.")
+````
+Then send it....
+````
+progressive_response.post
+````
+
+
+### Sending a Card ###
+
+You can also [send a card](https://developer.amazon.com/docs/custom-skills/include-a-card-in-your-skills-response.html) to the Alexa app:
+AlexaWebService supports four kinds of cards:
+- Plain Text
+- Image
+- Linking
+- Permissions
+
+First, create a card: 
+````
+card = AlexaWebService::Card.new
+````
+
+Then add the card attributes you want (text, image, or permissions if sending a permissions card):
+````Ruby
+card.title = "My Alexa Card"
+card.content "Formating is really limited to: \nline breaks"
+card.small_image = "https://your_small_image_url.jpg"
+card.large_image = "https://your_large_image_url.jpg"
+````
+Finally, add the card to your response, specifying the kind of card you created:
+````
+response.add_card(card.with_image)
+````
+other possibilities:
+````
+# text only
+response.add_card(card.with_text)    
+
+# permissions
+response.add_card(card.with_permissions)
+````
+If you create a skill that uses [account linking](https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/linking-an-alexa-user-with-a-user-in-your-system)
+````
+# linking
+response.add_card(card.linking)
+````
+Finally, post your response
+
+````
+response.post
+````
+
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/alexa_web_service/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`)
+5. Create a new Pull Request
+

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/alexa_web_service.gemspec

@@ -0,0 +1,39 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "alexa_web_service/version"
+
+
+Gem::Specification.new do |spec|
+  spec.name          = "alexa_web_service"
+  spec.version       = AlexaWebService::VERSION
+  spec.authors       = ["sarkonovich"]
+  spec.email         = ["arkonovs @ reed. edu"]
+
+  spec.summary       = "A framework to handle the JSON request/responses for an Alexa skill"
+  spec.description   = "A framework to handle and verify the JSON request/responses for an Alexa skill"
+  spec.homepage      = "https://github.com/sarkonovich/Alexa-Web-Service"
+  spec.license       = 'MIT'
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  # if spec.respond_to?(:metadata)
+  #   spec.metadata["allowed_push_host"] = "http://mygemserver.com"
+  # else
+  #   raise "RubyGems 2.0 or newer is required to protect against " \
+  #     "public gem pushes."
+  # end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "httparty", "~> 0.15.7"
+  spec.add_development_dependency "json", '~> 2.1', '>= 2.1.0'
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "alexa_web_service"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/alexa_web_service.rb

@@ -1,7 +1,10 @@
-require 'alexa_web_service/version'
-require 'alexa_web_service/alexa_response'
-require 'alexa_web_service/alexa_request'
-require 'alexa_web_service/alexa_verify'
+require_relative 'alexa_web_service/display_directive'
+require_relative 'alexa_web_service/hint_directive'
+require_relative 'alexa_web_service/progressive_response'
+require_relative 'alexa_web_service/request'
+require_relative 'alexa_web_service/response'
+require_relative 'alexa_web_service/verify'
+require_relative 'alexa_web_service/card'
 
 module AlexaWebService
 end

data/lib/alexa_web_service/card.rb

@@ -0,0 +1,54 @@
+module AlexaWebService
+  class Card
+    attr_accessor :title, :content, :small_image, :large_image, :permissions
+
+    def initialize(type = 'text_card')
+      @title = ''
+      @content = ''
+      @small_image = nil
+      @large_image = nil
+      @type = type
+      @permissions = []
+    end
+
+    def with_image
+      {
+        "type": "Standard",
+        "title": title,
+        "text": content,
+        "image": {
+          "smallImageUrl": small_image,
+          "largeImageUrl": large_image
+          }
+        }
+    end
+
+    def with_text
+      {
+        "type": "Simple",
+        "title": title,
+        "content": content
+      }
+    end
+
+    def linking
+      {"type": "LinkAccount"}
+    end
+
+    # Will only return permissions requested in skill configuration
+    # Possible values for permissions:
+    # write for notifications:  "write::alexa:devices:all:notifications:standard"
+    # read for full address: "read::alexa:device:all:address"
+    # read for restricted address: "read::alexa:device:all:address:country_and_postal_code"
+    
+    def add_permission(permission) 
+      self.permissions << permission
+    end
+
+    def with_permission
+      {
+      "type": "AskForPermissionsConsent", "permissions": permissions
+      }
+    end
+  end
+end

data/lib/alexa_web_service/display_directive.rb

@@ -0,0 +1,73 @@
+
+module AlexaWebService    
+  class DisplayDirective
+    attr_accessor :directive
+
+    def initialize(type: "BodyTemplate1", token: "", back_button: "VISIBLE", title: "")
+      @directive = {
+        "type": "Display.RenderTemplate",
+        "template": {
+          "type": type,
+          "token": token,
+          "backButton": back_button,
+          "backgroundImage": image_object,
+          "title": title,
+          "image": image_object,
+          "textContent": {}
+        }
+      }
+    end
+    
+    def image_object(content_description = '', url = '', size = 'X_SMALL')
+      {
+        "contentDescription": content_description,
+        "sources": [
+          {
+            "url": url,
+            "size": size
+          }
+        ]
+      }
+    end
+    
+    def add_image(content_description, url, size = 'X_SMALL')
+      @directive[:template][:image] = image_object(content_description, url, size = 'X_SMALL')    
+    end
+    
+    def add_background_image(content_description, url, size = 'X_SMALL')
+      @directive[:template][:backgroundImage] = image_object(content_description, url, size = 'X_SMALL')  
+    end
+
+    def text_object(primary_text: nil, secondary_text: nil, tertiary_text: nil)
+      {
+        "primaryText": {
+          "text": primary_text,
+          "type": "RichText"
+        },
+        "secondaryText": {
+          "text": secondary_text,
+          "type": "RichText"
+        },
+        "tertiaryText": {
+          "text": tertiary_text,
+          "type": "RichText"
+        }
+      }
+    end
+
+    def add_text(primary_text:, secondary_text: nil, tertiary_text: nil)
+      @directive[:template][:textContent] = text_object(primary_text: primary_text, secondary_text: secondary_text, tertiary_text: tertiary_text)
+    end
+
+    # To create Show lists, first create image and text objects and then add show list item.
+    def add_list_item(token: '', image_object: {}, text_object: {})
+      item = { 
+        "token": token,
+        "image": image_object,
+        "textContent": text_object
+      }
+      @directive[:template][:listItems] ||= []
+      @directive[:template][:listItems] << item
+    end
+  end
+end

data/lib/alexa_web_service/hint_directive.rb

@@ -0,0 +1,15 @@
+module AlexaWebService    
+  class HintDirective
+    attr_accessor :directive
+
+    def initialize(hint) 
+        @directive = {
+        "type": "Hint",
+        "hint": {
+          "type": "PlainText",
+          "text": hint
+        }
+      }
+    end
+  end
+end

data/lib/alexa_web_service/progressive_response.rb

@@ -0,0 +1,39 @@
+require 'httparty'
+
+module AlexaWebService
+  class ProgressiveResponse
+    attr_accessor :speech
+    attr_reader :directive, :request
+    
+    def initialize(request, speech)
+      @request = request
+      @speech = speech  
+      @directive = {
+        "header"=> { 
+          "requestId"=>request.request_id
+        },
+        "directive"=> { 
+          "type"=>"VoicePlayer.Speak",
+          "speech"=>speech
+        }
+      }
+    end
+
+    def url
+      if request.api_endpoint
+        request.api_endpoint + "/v1/directives"
+      end
+    end
+
+    def headers
+      {
+        "Authorization" => "Bearer #{request.api_access_token}",
+        "Content-Type" => "application/json"
+      }
+    end
+    
+    def post
+      HTTParty.post(url, :headers=>headers, :body=>self.directive.to_json)
+    end
+  end
+end

data/lib/alexa_web_service/request.rb

@@ -0,0 +1,80 @@
+module AlexaWebService
+  class Request
+    attr_reader :request_hash, :api_access_token, :api_endpoint, :device_id, 
+                :request_id, :request_type, :timestamp, :session_new, :user_id,
+                :access_token, :application_id, :intent_name, :slots
+    
+    attr_accessor :attributes
+
+    def initialize(request_hash)
+      @request_hash     = request_hash
+      @api_access_token = request_hash["context"]["System"]["apiAccessToken"]
+      @api_endpoint     = request_hash["context"]["System"]["apiEndpoint"]
+      @device_id        = request_hash["context"]["System"]["device"]["deviceId"]
+      @request_id       = request_hash["request"]["requestId"]
+      @request_type     = request_hash["request"]["type"]
+      @timestamp        = request_hash["request"]["timestamp"]
+      @session_new      = request_hash["session"]["new"]
+      @user_id          = request_hash["session"]["user"]["userId"]
+      @access_token     = request_hash["session"]["user"]["accessToken"]
+      @application_id   = request_hash["session"]["application"]["applicationId"]
+      @intent_name      = get_intent_name
+      @slots            = get_slots
+      @attributes       = get_attributes
+    end
+
+    def filled_slots
+      @slots.select { |slot| slot != nil} rescue []
+    end
+
+    def intent_request?
+      request_type == "IntentRequest"
+    end
+
+    def launch_request?
+      request_type == "LaunchRequest"
+    end
+
+    def slot_hash
+      if request_hash["request"]["intent"]
+        request_hash["request"]["intent"]["slots"]
+      end
+    end
+
+    def session_ended_request?
+      request_type == "SessionEndedRequest"
+    end
+
+    def session_new?
+      session_new
+    end 
+
+    
+    private
+    def get_intent_name
+      if request_hash["request"]["intent"]
+        request_hash["request"]["intent"]["name"]
+      end
+    end
+
+    def get_slots
+      if request_hash["request"]["intent"]
+        build_struct(request_hash["request"]["intent"]["slots"])
+      end
+    end
+
+    def get_attributes
+      request_hash["session"]["attributes"] ? request_hash["session"]["attributes"] : {} 
+    end
+
+    def build_struct(hash)
+      if hash.nil? || hash.empty?
+        nil
+      else
+        slot_names = hash.keys.map {|k| k.to_sym.downcase }
+        slot_values = hash.values.map { |v| v["value"] }
+        Struct.new(*slot_names).new(*slot_values)
+      end
+    end
+  end
+end

data/lib/alexa_web_service/response.rb

@@ -0,0 +1,52 @@
+module AlexaWebService
+  class Response
+    attr_accessor :session_attributes, :spoken_response, :card, 
+                  :reprompt_text, :end_session, :speech_type, 
+                  :text_type, :directives
+    
+    def initialize
+      @session_attributes = {}
+      @speech_type        = "PlainText"
+      @spoken_response    = ''
+      @reprompt_text      = ''
+      @text_type          = "text"
+      @end_session        = 'true'
+      @card               = nil
+      @directives         = []
+    end
+
+    def add_attribute(key, value)
+      @session_attributes.merge!(key => value)
+    end
+
+    def add_directive(directive)
+      self.directives << directive if $display_support == true
+    end
+
+    def add_card(card)
+      self.card = card
+    end
+
+    def post
+      {
+        "version": "1.0",
+        "sessionAttributes": @session_attributes,  
+        "response": {
+          "outputSpeech": {
+            "type": speech_type,
+            "#{text_type}": spoken_response
+          },
+          "card": card,
+          "reprompt": {
+            "outputSpeech": {
+              "type": speech_type,
+              "text": reprompt_text
+            }
+          },
+          "directives": @directives,
+          "shouldEndSession": end_session
+        }
+      }.to_json
+    end
+  end
+end

data/lib/alexa_web_service/{alexa_verify.rb → verify.rb}

@@ -1,5 +1,5 @@
 module AlexaWebService
-	class AlexaVerify
+	class Verify
 
     def initialize(request_env, request_body)
       @request_body = request_body

data/lib/alexa_web_service/version.rb

@@ -1,3 +1,3 @@
 module AlexaWebService
-  VERSION = "0.0.6"
+  VERSION = "1.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: alexa_web_service
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 1.0.0
 platform: ruby
 authors:
 - sarkonovich
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-07-07 00:00:00.000000000 Z
+date: 2018-02-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.10'
+        version: '1.15'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.10'
+        version: '1.15'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -38,40 +38,54 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: httparty
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.13.5
-  type: :runtime
+        version: 0.15.7
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.13.5
+        version: 0.15.7
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: '2.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.8.3
-  type: :runtime
+        version: 2.1.0
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: '2.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.8.3
+        version: 2.1.0
 description: A framework to handle and verify the JSON request/responses for an Alexa
   skill
 email:
@@ -80,10 +94,22 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- alexa_web_service.gemspec
+- bin/console
+- bin/setup
 - lib/alexa_web_service.rb
-- lib/alexa_web_service/alexa_request.rb
-- lib/alexa_web_service/alexa_response.rb
-- lib/alexa_web_service/alexa_verify.rb
+- lib/alexa_web_service/card.rb
+- lib/alexa_web_service/display_directive.rb
+- lib/alexa_web_service/hint_directive.rb
+- lib/alexa_web_service/progressive_response.rb
+- lib/alexa_web_service/request.rb
+- lib/alexa_web_service/response.rb
+- lib/alexa_web_service/verify.rb
 - lib/alexa_web_service/version.rb
 homepage: https://github.com/sarkonovich/Alexa-Web-Service
 licenses:
@@ -97,7 +123,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.0.0
+      version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/alexa_web_service/alexa_request.rb

@@ -1,54 +0,0 @@
-module AlexaWebService
-	class AlexaRequest
-		attr_reader :intent_name, :slots, :timestamp, :request_type, :session_new, :user_id, :access_token, :application_id
-		attr_accessor :attributes
-		alias :session_new? :session_new
-
-		def initialize(response_hash)
-			session = response_hash["session"]
-      request = response_hash["request"]
-      if session
-        @attributes = session["attributes"] ? session["attributes"] : {}
-        @user_id = session["user"]["userId"] if session["user"]
-        @access_token = session["user"]["accessToken"] if session["user"]
-        @application_id = session["application"]["applicationId"] if session["application"]
-      end
-
-      if request
-        @request_type = request["type"]
-        @timestamp = request["timestamp"]
-        @session_new = request["new"]
-
-        if request["intent"]
-          @intent_name  =  request["intent"]["name"] if request["intent"]
-          @slots      = build_struct(request["intent"]["slots"]) if request["intent"]
-        end
-    	end
-  	end
-
-		def filled_slots
-			@slots.select { |slot| slot != nil} rescue []
-		end
-
-		def intent_request?
-			request_type == "IntentRequest"
-		end
-
-		def launch_request?
-			request_type == "LaunchRequest"
-		end
-
-		def session_ended_request?
-			request_type == "SessionEndedRequest"
-		end
-
-		private	
-		def build_struct(hash)
-			unless hash.nil?
-				slot_names = hash.keys.map {|k| k.to_sym.downcase }
-				slot_values = hash.values.map { |v| v["value"] }
-				Struct.new(*slot_names).new(*slot_values)
-			end
-		end
-	end
-end

data/lib/alexa_web_service/alexa_response.rb

@@ -1,57 +0,0 @@
-module AlexaWebService
-	class Response
-		attr_accessor :session_attributes, :spoken_response, :card_title, :card_content, :reprompt_text, :end_session, :speech_type, :text_type
-		def initialize(params={})
-      @session_attributes = params[:session_attributes] || {}
-      @speech_type = params[:speech_type] || "PlainText"
-      @spoken_response = params[:spoken_response] || nil
-      @card_title = params[:card_title] || nil
-      @card_content = params[:card_content] || nil
-      @reprompt_text = params[:reprompt_text] || nil
-      @text_type = params[:text_type] || "text"
-      @end_session = params[:end_session] || true
-    end
-
-		def add_attribute(key, value)
-			@session_attributes.merge!(key => value)
-		end
-
-		def append_attribute(key, value)
-			@session_attributes[key] << value if @session_attributes[key] != nil
-		end
-
-		def with_card
-				{
-				  "version" => "1.0",
-				  "sessionAttributes" =>
-				    @session_attributes, 	
-					"response" => {
-					  "outputSpeech" => {
-					    "type" => speech_type,
-					    "#{text_type}" => spoken_response
-					  },
-					  "card" => {
-					    "type" => "Simple",
-					    "title" => card_title,
-					    "content" => card_content
-					  },
-				  "reprompt" => {
-				    "outputSpeech" => {
-				      "type" => speech_type,
-				      "text" => reprompt_text
-				    }
-				  },
-				  "shouldEndSession" => end_session 
-				}
-			}
-		end
-
-		def link_card
-			self.with_card.tap { |hs| hs["response"]["card"] = {"type" => "LinkAccount"} }
-		end
-
-		def without_card
-			self.with_card.tap { |hs| hs["response"].delete("card") }
-		end
-	end
-end