alexa_toolbox 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 410e7ebcc29c183541f1c4d5ad5b13e898ca1263
+  data.tar.gz: 3507752cb6aa7791bf0c99db20fd00ceaf063e7a
+SHA512:
+  metadata.gz: a21accae38d9aad6543ace3ab03eddd6d327b88999aee89c87b8e3deeba4b5a32b7ab03de1413022ebe0da3cbb0631ff58d5bf9a10955ca39a9fa77ef6a6cbb8
+  data.tar.gz: 56918a9a6c88a5b562e5514b2e0b80dbbdc779ddc8c0869ef28696fbd9e5abda5e196c2889c17bafce50198bb64ed44ed21467d3a067f7d3bb60f211b7cbc488

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,38 @@
+PATH
+  remote: .
+  specs:
+    alexa_toolbox (1.0.0)
+      bundler (~> 1.14)
+      deep_merge
+      rake
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    deep_merge (1.1.1)
+    diff-lcs (1.3)
+    rake (12.0.0)
+    rspec (3.6.0)
+      rspec-core (~> 3.6.0)
+      rspec-expectations (~> 3.6.0)
+      rspec-mocks (~> 3.6.0)
+    rspec-core (3.6.0)
+      rspec-support (~> 3.6.0)
+    rspec-expectations (3.6.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.6.0)
+    rspec-mocks (3.6.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.6.0)
+    rspec-support (3.6.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  alexa_toolbox!
+  rspec (~> 3.6, >= 3.6.0)
+  rspec-mocks (~> 3.6, >= 3.6.0)
+
+BUNDLED WITH
+   1.14.6

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2017 Paul McMahon
+
+MIT License
+
+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,169 @@
+# AlexaToolbox
+
+This gem implements a full suite of tools for deploying applications for Amazon's Alexa.
+
+## Installation
+
+### For Ruby Projects:
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'alexa_toolbox'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install alexa_toolbox
+
+## Usage
+
+This Gem provides methods to create and handle requests, create response objects, and miscellaneous support functions for Alexa skills.
+
+### Requests
+
+[Amazon Request Documentation](https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/alexa-skills-kit-interface-reference#request-format)
+
+#### Handling Request JSON:
+
+```ruby
+require 'alexa_toolbox'
+request = AlexaToolbox::Request.new(params,{ :application_id => 'YOUR_APP_ID' })
+# params variable is json request retrieved by server (default is params in Ruby on Rails)
+# request application IDs are checked vs your application ID to ensure they are valid requests as per Amazon's guidelines
+```
+#### Check Request Validity:
+
+You should always check request validity as per Amazon's guidelines
+[Amazon Guidelines](https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/handling-requests-sent-by-alexa#verifying-that-the-request-is-intended-for-your-service)
+
+```ruby
+require 'alexa_toolbox'
+request = AlexaToolbox::Request.new(params,{ :application_id => 'YOUR_APP_ID' })
+if !request.valid?
+  # return 500 status
+end
+```
+#### Getting Information From the Request
+
+```ruby
+require 'alexa_toolbox'
+request = AlexaToolbox::Request.new(params,{ :application_id => 'YOUR_APP_ID' })
+
+request.type
+# Returns request type: 
+# LaunchRequest
+# IntentRequest
+# SessionEndedRequest
+# AudioPlayer
+# PlaybackController
+# System.ExceptionEncountered
+
+# Check if new session
+request.session.new?
+# Get sessionId
+request.session.session_id
+# Get userId
+request.session.user_id
+```
+
+#### Utilizing Request Hash
+
+If you are more comfortable navigating the request hash and are familiar with the setup you can still acces it.
+
+```ruby
+require 'alexa_toolbox'
+request = AlexaToolbox::Request.new(params,{ :application_id => 'YOUR_APP_ID' })
+
+# Get Session
+request.json[:session]
+# Get sessionId
+request.json[:session][:sessionId]
+```
+
+#### Utilizing Address Consent
+
+[Alexa Documentation on Address Data](https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/device-address-api)
+
+If you want to access the user's address, you'll first require their permission and then you'll receive a consent token and deviceId in the request.
+Once you have those, you will need to utilize Amazon's API to retrieve the address data. (Supporting feature a WIP.)
+
+```ruby
+require 'alexa_toolbox'
+request = AlexaToolbox::Request.new(params,{ :application_id => 'YOUR_APP_ID' })
+
+consent_token = request.session.consent_token
+device_id = request.session.device_id
+```
+
+
+### Responses
+
+[Amazon Response Documentation](https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/alexa-skills-kit-interface-reference#response-format)
+
+#### Simple Response Object Example:
+
+```ruby
+require 'alexa_toolbox'
+response = AlexaToolbox::Response.new
+response.add_speech('Creating a response is so easy!')
+response.build_response
+```
+
+#### If you want to utilize SSML (will add speak tags if you forget!):
+
+```ruby
+require 'alexa_toolbox'
+response = AlexaToolbox::Response.new
+response.add_speech('Creating a response is so easy!',true)
+# or
+# response.add_speech('<speak>Creating a response is so easy!</speak>',true)
+response.build_response
+```
+
+#### To add a card to your response:
+
+```ruby
+require 'alexa_toolbox'
+response = AlexaToolbox::Response.new
+# add_card(type,title,subtitle,content)
+# or
+# add_hash_card({ :type => type, :title => title, :subtitle => subtitle, :content => content })
+response.add_card("PlainText","Card Title","Card Subtitle","This card should have some interesting content for your user.")
+response.build_response
+```
+
+#### Will generate a valid outputspeech response in JSON format:
+
+```JSON
+{
+    "version": "1.0",
+    "response": {
+        "outputSpeech": {
+            "type": "PlainText",
+            "text": "Ruby is running ready!"
+        },
+        "shouldEndSession": true
+    }
+}
+```
+
+## Troubleshooting
+
+
+## Contributing
+
+1. Fork it
+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
+
+Please make sure to write specs for any new features!
+
+# Team Members
+* "Paul McMahon" <colpan@sircolpaniusjackson.com>

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/alexa_toolbox/address.rb

@@ -0,0 +1,106 @@
+module AlexaToolbox
+  # Handles the retrieving address information about a device.
+  class Address
+    require 'net/http'
+    attr_reader :json
+    attr_accessor :consent_token, :device_id, :full_address, :app_location
+
+    def initialize (consent_token = nil, device_id = nil, app_location = "US", full_address = false)
+      @consent_token = consent_token
+      @device_id = device_id
+      @country_code = nil
+      @postal_code = nil
+      @city = nil
+      @state_or_region = nil
+      @address_line_1 = nil
+      @address_line_2 = nil
+      @address_line_3 = nil
+      @district_or_county = nil
+      @status = nil
+      @full_address = full_address
+      @app_location = app_location
+      @json = nil
+    end
+
+    def add_request(request)
+      @consent_token = request.session.consent_token
+      @device_id = request.session.device_id
+    end
+
+    def add_token(token)
+      @consent_token = token
+    end
+
+    def add_device(device)
+      @device_id = device
+    end
+
+    def retrieve_full_address(consent_token = nil, device_id = nil)
+      token = consent_token.nil? ? @consent_token : consent_token
+      device = device_id.nil? ? @device_id : device_id
+      if !token.nil? && !device.nil?
+        if self.base_uri.nil?
+          raise ArgumentError, 'Invalid Request, Invalid app_location set'
+        else
+          full_uri = self.base_uri + "/v1/devices/" + device + "/settings/address"
+          self.execute_request(full_uri,token)
+        end
+      else
+        raise ArgumentError, 'Invalid Request, No Token or Device'
+      end
+    end
+
+    def retrieve_partial_address(consent_token = nil, device_id = nil)
+      token = consent_token.nil? ? @consent_token : consent_token
+      device = device_id.nil? ? @device_id : device_id
+      if !token.nil? && !device.nil?
+        if self.base_uri.nil?
+          raise ArgumentError, 'Invalid Request, Invalid app_location set'
+        else
+          full_uri = self.base_uri + "/v1/devices/" + device + "/settings/address/countryAndPostalCode"
+          self.execute_request(full_uri,token)
+        end
+      else
+        raise ArgumentError, 'Invalid Request, No Token or Device'
+      end
+    end
+
+    def execute_request(endpoint,token)
+      uri = URI(endpoint)
+
+      Net::HTTP.start(uri.hostname, uri.port, :use_ssl => uri.scheme == 'https') do |http|
+        request = Net::HTTP::Get.new(uri)
+        request['Authorization'] = token
+
+        response = http.request(request)
+        self.status = response.code
+        self.json = response.body
+        if response.code == 200
+          res_body = response.body
+          @country_code = res_body.key?("countryCode") ? res_body["countryCode"] : self.country_code
+          @postal_code = res_body.key?("postalCode") ? res_body["postalCode"] : self.postal_code
+          @city = res_body.key?("city") ? res_body["city"] : self.city
+          @state_or_region = res_body.key?("stateOrRegion") ? res_body["stateOrRegion"] : self.state_or_region
+          @address_line_1 = res_body.key?("addressLine1") ? res_body["addressLine1"] : self.address_line_1
+          @address_line_2 = res_body.key?("addressLine2") ? res_body["addressLine2"] : self.address_line_2
+          @address_line_3 = res_body.key?("addressLine3") ? res_body["addressLine3"] : self.address_line_3
+          @district_or_county = res_body.key?("districtOrCounty") ? res_body["districtOrCounty"] : self.district_or_county
+        else
+        end
+      end
+    end
+
+    def base_uri
+      case self.app_location
+      when "US"
+        return "https://api.amazonalexa.com"
+      when "UK"
+        return "https://api.eu.amazonalexa.com"
+      when "DE"
+        return "https://api.eu.amazonalexa.com"
+      else
+        return nil
+      end
+    end
+  end
+end

data/lib/alexa_toolbox/audioplayer.rb

@@ -0,0 +1,16 @@
+module AlexaToolbox
+  # Handles the audioplayer object in requests.
+  class AudioPlayer
+    attr_reader :type, :offset_in_milliseconds, :token, :current_playback_state, :error, :json
+
+    def initialize (audioplayer)
+      raise ArgumentError, 'Invalid AudioPlayer' if !audioplayer.key?(:type) && audioplayer[:type][0..10] != "AudioPlayer"
+      @type = audioplayer[:type][12..-1]
+      @offset_in_milliseconds = audioplayer[:offsetInMilliseconds]
+      @token = audioplayer[:token]
+      @current_playback_state = audioplayer[:currentPlaybackState]
+      @json = audioplayer
+    end
+
+  end
+end

data/lib/alexa_toolbox/context.rb

@@ -0,0 +1,27 @@
+module AlexaToolbox
+  # Handles the session object in requests.
+  class Context
+    require 'alexa_toolbox/audioplayer'
+    attr_reader :audioplayer, :system, :json
+
+    def initialize (context)
+      raise ArgumentError, 'Invalid Context' if false
+      @system = context[:System]
+      @audioplayer = context.key?(:AudioPlayer) ? AlexaToolbox::AudioPlayer.new(context[:AudioPlayer]) : nil
+      @json = context
+    end
+
+    def application_id
+      return self.system[:application][:applicationId]
+    end
+
+    def user_id
+      return self.system[:user][:userId]
+    end
+
+    def device_id
+      return self.system[:device][:deviceId]
+    end
+
+  end
+end

data/lib/alexa_toolbox/intent.rb

@@ -0,0 +1,21 @@
+module AlexaToolbox
+  # Handles the intent object in requests.
+  class Intent
+    attr_reader :name, :confirmation_status, :json
+
+    def initialize (intent)
+      raise ArgumentError, 'Invalid Intent' if intent[:name].empty?
+      @name = intent[:name]
+      @confirmation_status = intent[:confirmationStatus]
+      @json = intent
+    end
+
+    def has_slots?
+      return self.slots != {}
+    end
+
+    def slots
+      return self.json[:slots]
+    end
+  end
+end

data/lib/alexa_toolbox/request.rb

@@ -0,0 +1,59 @@
+module AlexaToolbox
+  # Echo can send 3 types of requests
+  # - LaunchRequest: The app was launched using phrasing such as 'Alexa open ______'.
+  # - IntentRequest: An intent was requested.
+  # - SessionEndedRequest: Session was closed either by user or timeout.
+  
+  class Request
+    require 'json'
+    require 'deep_merge'
+    require 'alexa_toolbox/session'
+    require 'alexa_toolbox/intent'
+    require 'alexa_toolbox/audioplayer'
+    require 'alexa_toolbox/context'
+    attr_reader :version, :session, :json, :options, :request_id, :locale, :type, :intent, :audioplayer, :error, :cause, :context
+
+    def self.default_options
+      @default_options ||= {
+        :application_id => ''
+      }
+    end
+
+    def initialize(json_request, options = {})
+      options = options.deep_merge(self.class.default_options)
+      @options = options
+
+      @request_id = json_request[:request][:requestId]
+      raise ArgumentError, 'Request ID not present' if @request_id.nil?
+      @version = json_request[:version]
+      @locale = json_request[:request][:locale]
+      @error = json_request[:request][:error]
+      @cause = json_request[:request][:cause]
+      @json   = json_request
+      @type = json_request[:request][:type][0..10] == "AudioPlayer" ? "AudioPlayer" : json_request[:request][:type]
+
+      @intent = @type == "IntentRequest" ? AlexaToolbox::Intent.new(json_request[:request][:intent]) : nil
+      @audioplayer = @type == "AudioPlayer" ? AlexaToolbox::AudioPlayer.new(json_request[:request]) : nil
+      @session = json_request.key?(:session) ? AlexaToolbox::Session.new(json_request[:session]) : nil
+      @context = json_request.key?(:context) ? AlexaToolbox::Context.new(json_request[:context]) : nil
+    end
+
+    def valid?
+      self.options[:application_id] && ((!self.session.nil? && self.options[:application_id] == self.session.application_id) || (!self.context.nil? && self.options[:application_id] == self.context.application_id))
+    end
+
+    def user_terminated?
+      if self.type != "SessionEndedRequest"
+        return nil
+      end
+      return self.json[:request][:reason] == "USER_INITIATED"
+    end
+  end
+
+  # Builds a new request for Alexa, primarily for testing purposes
+  def self.build_request(json_request, application_id = "")
+    json_request = self.transform_keys_to_symbols(json_request)
+    raise ArgumentError, 'Invalid Alexa Request. Missing session, request, version, or application id.' unless AlexaToolbox.valid_alexa?(json_request)
+    Request.new(json_request,{ :application_id => application_id })
+  end
+end

data/lib/alexa_toolbox/response.rb

@@ -0,0 +1,161 @@
+module AlexaToolbox
+  class Response
+    require 'json'
+    attr_reader :version, :reprompt, :speech, :response, :session_attributes, :card
+    attr_accessor :player_response, :session_end
+
+    # Every response will have a version, response, and shouldEndSession
+    def initialize(player_response = false, ssml = false, version = '1.0')
+      @session_attributes = Hash.new
+      @version = version
+      @directives = []
+      @player_response = player_response
+      @ssml = ssml
+      @session_end = true
+      @reprompt = nil
+      @speech = nil
+    end
+
+    # Adds a key,value pair to the session object.
+    def add_session_attribute(key, value)
+      @session_attributes[key.to_sym] = AlexaToolbox.transform_keys_to_symbols(value)
+    end
+
+    def add_speech(speech_text, ssml = nil)
+      ssml = ssml.nil? ? @ssml : ssml
+      if ssml
+        @speech = { :type => 'SSML', :ssml => check_ssml(speech_text) }
+      else
+        @speech = { :type => 'PlainText', :text => speech_text }
+      end
+    end
+
+    def add_plain_speech(speech_text)
+      @speech = { :type => 'PlainText', :text => speech_text }
+    end
+
+    def add_ssml_speech(speech_text)
+      @speech = { :type => 'SSML', :ssml => check_ssml(speech_text) }
+    end
+
+    def add_reprompt(speech_text, ssml = nil)
+      ssml = ssml.nil? ? @ssml : ssml
+      if ssml
+        @reprompt = { "outputSpeech" => { :type => 'SSML', :ssml => check_ssml(speech_text) } }
+      else
+        @reprompt = { "outputSpeech" => { :type => 'PlainText', :text => speech_text } }
+      end
+    end
+
+    def add_ssml_reprompt(speech_text)
+      @reprompt = { "outputSpeech" => { :type => 'SSML', :ssml => check_ssml(speech_text) } }
+    end
+    
+    def add_audio_play_directive(url, play_behavior = '', token = '', expected_previous_token = '', offset = 0)
+      directive = {
+        'type' => 'AudioPlayer.Play',
+        'playBehavior' => play_behavior,
+        'audioItem' => {
+          'stream' => {
+            'token' => token,
+            'url' => url,
+            'offsetInMilliseconds' => offset
+          }
+        }
+      }
+      directive['audioItem']['stream']['expectedPreviousToken'] = expected_previous_token if play_behavior == "ENQUEUE"
+      @directives << directive
+    end
+
+    def add_audio_clear_directive(clear_all = false)
+      @directives << {
+        'type' => 'AudioPlayer.ClearQueue',
+        'clearBehavior' => clear_all ? "CLEAR_ALL" : "CLEAR_ENQUEUED"
+      }
+    end
+
+    def add_audio_stop_directive
+      @directives << {
+        'type' => 'AudioPlayer.Stop'
+      }
+    end
+
+    # "type": "string",
+    # "title": "string",
+    # "content": "string"
+    # Standard uses :text instead of :content
+    def add_card(type = nil, title = nil, content = nil, smallImageUrl = nil, largeImageUrl = nil)
+      @card = Hash.new
+      @card[:type] = type.nil? ? 'Simple' : type
+      if @card[:type] != "LinkAccount"
+        @card[:title] = title unless title.nil?
+        @card[:type] = 'Simple' if smallImageUrl.nil? && largeImageUrl.nil?
+        if @card[:type] == 'Simple'
+          @card[:content] = content unless content.nil?
+        else
+          @card[:text] = content unless content.nil?
+          @card[:image] = {
+            :smallImageUrl => smallImageUrl,
+            :largeImageUrl => largeImageUrl
+          }
+        end
+      end
+    end
+
+    # Add Permission Card for Location Information
+    def add_permission_card(full_address = false)
+      @card = Hash.new
+      @card[:type] = 'AskForPermissionsConsent'
+      permission = full_address ? "read::alexa:device:all:address" : "read::alexa:device:all:address:country_and_postal_code"
+      @card[:permissions] = [permission]
+    end
+
+    # Add a card as a single hash
+    def add_hash_card(card)
+      card[:type] = 'Simple' if card[:type].nil?
+      @card = card
+    end
+
+    # The response object as hash (with outputspeech, cards and session end)
+    def build_standard_response_object(session_end = true)
+      @response = Hash.new
+      @response[:outputSpeech] = @speech unless @speech.nil?
+      @response[:directives] = @directives unless @directives.empty?
+      @response[:card] = @card unless @card.nil?
+      @response[:reprompt] = @reprompt unless @reprompt.nil?
+      @response[:shouldEndSession] = session_end
+      @response
+    end
+
+    # For Responses to AudioPlayer or PlaybackController Requests
+    # Cannot Include: outputSpeech, card, reprompt, shouldEndSession
+    def build_player_response_object(session_end = true)
+      @response = Hash.new
+      @response[:directives] = @directives unless @directives.empty?
+      @response
+    end
+
+    # Builds a response object, can be json or hash if json is false
+    def build_response(session_end = nil, player_response = nil, json = true)
+      is_player_response = player_response.nil? ? @player_response : player_response
+      end_session = session_end.nil? ? @session_end : session_end
+      response = Hash.new
+      if is_player_response
+        response_object = build_player_response_object(end_session)
+      else
+        response_object = build_standard_response_object(end_session)
+        response[:sessionAttributes] = @session_attributes unless @session_attributes.empty?
+      end
+      response[:version] = @version
+      response[:response] = response_object
+      json ? JSON.parse(response.to_json) : response
+    end
+
+    private
+
+      def check_ssml(ssml_string)
+        ssml_string = ssml_string.strip[0..6] == "<speak>" ? ssml_string : "<speak>" + ssml_string
+        ssml_string.strip[-8..1] == "</speak>" ? ssml_string : ssml_string + "</speak>"
+      end
+  end
+end

data/lib/alexa_toolbox/session.rb

@@ -0,0 +1,61 @@
+module AlexaToolbox
+  # Handles the session object in requests.
+  class Session
+    attr_reader :new, :session_id, :attributes, :user, :application_id, :device
+
+    def initialize (session)
+      raise ArgumentError, 'Invalid Session' if session.nil? || session[:new].nil? || session[:sessionId].nil?
+      @new = session[:new]
+      @session_id = session[:sessionId]
+      @attributes = session[:attributes].nil? ? Hash.new : session[:attributes]
+      @user = session[:user]
+      @application_id = session[:application][:applicationId]
+      @device = session[:device]
+    end
+
+    # Checks whether this is a new session
+    def new?
+      @new
+    end
+
+    # Checks if user is defined
+    def user_defined?
+      !@user.nil? || !@user[:userId].nil?
+    end
+
+    # Returns user's id
+    def user_id
+      @user[:userId] if @user
+    end
+
+    def access_token?
+      @user.key?(:accessToken) && !@user[:accessToken].empty?
+    end
+
+    # Returns user's access token if provided
+    def access_token
+      @user[:accessToken] if @user
+    end
+
+    def consent_token?
+      @user.key?(:permissions) && @user[:permissions].key?(:consentToken) && !@user[:permissions][:consentToken].empty?
+    end
+
+    def consent_token
+      @user[:permissions][:consentToken] if @user && @user.key?(:permissions) && @user[:permissions].key?(:consentToken)
+    end
+
+    def device_id
+      @device[:deviceId]
+    end
+
+    def supported_interfaces
+      @device[:supportedInterfaces]
+    end
+
+    # Check to see if attributes are present.
+    def has_attributes?
+      !@attributes.empty?
+    end
+  end
+end

data/lib/alexa_toolbox/version.rb

@@ -0,0 +1,3 @@
+module AlexaToolbox
+  VERSION = '1.0.0'
+end

data/lib/alexa_toolbox.rb

@@ -0,0 +1,28 @@
+require 'alexa_toolbox/request'
+require 'alexa_toolbox/version'
+require 'alexa_toolbox/response'
+require 'alexa_toolbox/address'
+
+module AlexaToolbox
+  # Prints a JSON object.
+  def self.print_json(json)
+    p json
+  end
+
+  # Prints the Gem version.
+  def self.print_version
+    p AlexaToolbox::VERSION
+  end
+
+  # Returns true if all the Alexa objects are set.
+  def self.valid_alexa?(request_json)
+    !request_json.nil? && !request_json[:version].nil? && !request_json[:request].nil?
+  end
+
+  # Take keys of hash and transform those to a symbols
+  def self.transform_keys_to_symbols(input)
+    return input if not input.is_a?(Hash)
+    hash = input.inject({}){|store,(key,val)| store[key.to_sym] = self.transform_keys_to_symbols(val); store}
+    return hash
+  end
+end

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification
+name: alexa_toolbox
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Paul McMahon
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-05-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: deep_merge
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.6.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.6.0
+- !ruby/object:Gem::Dependency
+  name: rspec-mocks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.6.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.6.0
+description: Full top to bottom toolbox for creating a custom Alexa skill.
+email:
+- colpan@sircolpaniusjackson.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/alexa_toolbox.rb
+- lib/alexa_toolbox/address.rb
+- lib/alexa_toolbox/audioplayer.rb
+- lib/alexa_toolbox/context.rb
+- lib/alexa_toolbox/intent.rb
+- lib/alexa_toolbox/request.rb
+- lib/alexa_toolbox/response.rb
+- lib/alexa_toolbox/session.rb
+- lib/alexa_toolbox/version.rb
+homepage: https://github.com/colpan/alexa-toolbox
+licenses:
+- MIT
+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.4.5.1
+signing_key: 
+specification_version: 4
+summary: Full top to bottom toolbox for creating a custom Alexa skill.
+test_files: []