wit_ruby 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c3328ab2cd43c12812263d053b76ff837a49e417
-  data.tar.gz: 59e650ebf3617db50c71ea5fbc84667e6ecc4be3
+  metadata.gz: 971419a9504d3b3f6a033650f424daaba39f6a3b
+  data.tar.gz: f81c794354b97acf237ee363474b7dfb9513dff3
 SHA512:
-  metadata.gz: 1e93dc0243f06bad3cfe1df8029c8794db0967bc16da4af4ab96b95e96f69c5a2e96a34d9bf76ee65386fe5262e053d46bc7b8121b8412b3332de4edcb4f008b
-  data.tar.gz: 04c4971cf7229343f7230f1138039c67324b711f9c15d95553ee265601995a21dfe7b416307c4860b71bda3e8427f889bf63fa733bfca92eae2cb173b1666334
+  metadata.gz: ab3c0ab3b94f1c6b02d82ab2e4fe717d3a88641117fe4f2e1f45b21c7ef2e124995dcca013d3b38dee36176aae6051b38444aefa6ba957259ee5a9aa7d0b59ff
+  data.tar.gz: ec22891627f70d3d99e49abfe580c973819db15d8d6e2e052f42dc425a0fe8b9e31b13bf7b6cc05e55de23282e3a6e802030c5de20b03ae835ef4f1f5dc77ab2

data/CHANGELOG

@@ -0,0 +1,11 @@
+== 0.0.2
+* Implemented API call to get specific information from a sent message from it's given ID (GET).
+* Intent specific API calls functional (GET).
+* Changed description in gemspec.
+* Change results to be returned as specific objects that inherit from the original class Result.
+  Message, Intent, Entity, Expression are the specific wrappers for results.
+* Made error check so that only specific results can be refreshed. Refreshable objects are ones that
+  are directly returned from session calls.
+
+== 0.0.1
+* Implemented connection with wit.ai API and sending a text message (GET).

data/README.md

@@ -1,8 +1,12 @@
-[![Build Status](https://travis-ci.org/gching/wit_ruby.svg?branch=master)](https://travis-ci.org/gching/wit_ruby)[travis]
+
 
 # WitRuby
 
-Provides a Ruby interface with the Wit.ai API.
+Provides a unofficial Ruby API Wrapper for the Wit.ai API. Still implementing most functionalities. Go over to https://rubygems.org/gems/wit_ruby for specific information and documentation.
+
+[![Build Status](https://travis-ci.org/gching/wit_ruby.svg?branch=master)](https://travis-ci.org/gching/wit_ruby)
+[![Gem Version](https://badge.fury.io/rb/wit_ruby.png)](http://badge.fury.io/rb/wit_ruby)
+[![Coverage Status](https://coveralls.io/repos/gching/wit_ruby/badge.png?branch=master)](https://coveralls.io/r/gching/wit_ruby?branch=master)
 
 ## Installation
 
@@ -20,10 +24,58 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+Remember to put this up to access it!
+
+    $ require 'wit_ruby'
+
+To start using the wrapper, create a client with an authorization token given from Wit.ai. Set this either in ENV["WIT_AI_TOKEN"] or pass it on it the parameters as a hash. Default settings can be overridden by this hash as well.
+
+    $ ## Default to ENV["WIT_AI_TOKEN"]
+    $ client = Wit::REST::Client.new()
+    $ ## Override token when created
+    $ client = Wit::REST::Client.new(token: "Insert Token Here")
+
+The client provides also a session for you to mainly do API calls. I suggest you save the session somewhere for easy access.
+
+    $ session = client.session
+
+As of 0.0.2, only sending a message, getting message information and intent specific calls are implemented.
+
+## Message
+
+To send a specific message, use the saved session to send a given string as a parameter.
+
+    $ results = session.send_message("Your Message")
+
+To get a specific messages information from the wit.ai, pass in the message's ID and use the method below.
+
+    $ results = session.get_message("Message ID")
+
+## Intent
+
+To get a list of intents in the specific instance over at wit.ai.
+
+    $ ## Array of all intents used.
+    $ results = session.get_intents
+
+To get a specific intent information, pass in it's ID or name.
+
+    $ ## Specific intent information.
+    $ results = session.get_intents("Intent ID or Name")
+
+## Result
+
+Every method returns a class wrapper corresponding specifically to that result. The superclass that is inherited (Wit::REST::Result) allows for you to easily access the results of the API call. The results is converted to a hash and is saved in this result class.
+You can call methods on it and if it matches the result's hash, it will return it's value. For example,
+
+    $ ## results.hash = {"a" => "b"}
+    $ results.a
+    $  => "b"
 
 ## Contributing
 
+I am a beginner developer so do contribute or help as much as possible! I definitely need to learn a lot :).
+
 1. Fork it
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)

data/lib/wit_ruby/rest/client.rb

@@ -8,7 +8,6 @@ module Wit
     ## Wit::Session::Client class holds the authentication parameters and
     ## handles making the HTTP requests to the Wit API. These methods should be
     ## internally called and never called directly from the user.
-
     ## An example call to instantiate client is done like this with defaults:
     ##
     ## => @client = Wit::Session:Client.new
@@ -31,14 +30,15 @@ module Wit
           :retry_limit => 1,
       }
 
-      ## Allows for the reading of the last request, last response, and the
-      ## current session.
+      # Allows for the reading of the last request, last response, and the
+      # current session.
       attr_reader :last_req, :last_response, :session, :last_result
 
-      ## Initialize the new instance with either the default parameters or
-      ## given parameters.
-      ## Token is either the set token in ENV["WIT_AI_TOKEN"] or given in the
-      ## options.
+      ## Initialize the new instance with either the default parameters or given parameters.
+      ## Token can either be given in options or defaults to ENV["WIT_AI_TOKEN"]
+      ##
+      ## @param options [Hash] options to overide the defaults.
+      ## @return [Wit::REST::Client] new client connection.
       def initialize(options = {})
         ## Token is overidden if given in set params.
         @params = DEFAULTS.merge options
@@ -49,11 +49,16 @@ module Wit
 
 
       ## Change the given auth token.
+      ##
+      ## @param new_auth [String] new authorization token for client.
       def change_auth(new_auth)
         @auth_token = new_auth.strip
       end
 
       ## Defines each REST method for the given client. GET, PUT, POST and DELETE
+      ##
+      ## @param path [String] path for API call.
+      ## @return [Wit::REST::Result] results from the call.
       [:get, :put, :post, :delete].each do |rest_method|
         ## Get the given class for Net::HTTP depending on the current method.
         method_rest_class = Net::HTTP.const_get rest_method.to_s.capitalize
@@ -66,7 +71,11 @@ module Wit
         end
       end
 
-      ## Takes in a body and path and creates a net/http class and uses it to call a request to API
+      ## Takes in a body and path and creates a net/http class and uses it to call a request to API.
+      ##
+      ## @param rest [String] rest code for the call.
+      ## @param path [String] path for the call.
+      ## @param body [Hash] body of the call.
       def request_from_result(rest, path, body)
         method_rest_class = Net::HTTP.const_get rest.capitalize
         refresh_request = method_rest_class.new path, {"Authorization" => "Bearer #{@auth_token}"}
@@ -78,7 +87,7 @@ module Wit
 #################################
       private
 
-      ## Setup the session that allows for calling of
+      ## Setup the session that allows for calling of each method.
       def setup_session
         @session = Wit::REST::Session.new(self)
       end
@@ -111,6 +120,9 @@ module Wit
       end
 
       ## Connect and send the given request to Wit server.
+      ##
+      ## @param request [Net::HTTP] specific request class from Net::HTTP library.
+      ## @return [Wit::REST::Result] result from request.
       def connect_send(request)
         ## Set the last request parameter
         @last_req = request
@@ -125,19 +137,28 @@ module Wit
           case response.code
             when "200" then save_result_and_return(request, response)
             when "401" then raise Unauthorized, "Incorrect token or not set. Set ENV[\"WIT_AI_TOKEN\"] or pass into the options parameter as :token"
-            #else raise BadResponse, "response code: #{response.status}"
+            else raise BadResponse, "response code: #{response.code}"
           end
 
         end
       end
-      
+
       ## Save it into the instance last_result and return it.
+      ##
+      ## @param request [Net::HTTP] specific request class from Net::HTTP library.
+      ## @param response [Net::HTTP] response from call to API.
       def save_result_and_return(request, response)
-        @last_result = Wit::REST::Result.new(MultiJson.load(response.body), request.method, request.path, request.body)
-        return @last_result
+        ## Parse the data
+        parsed_data = MultiJson.load(response.body)
+        ## Save the last result as the super class Result
+        @last_result = Wit::REST::Result.new(parsed_data, request.method, request.path, request.body)
+        ## Return it
+        return  @last_result
       end
 
 
     end
+
+    class BadResponse < Exception; end
   end
 end

data/lib/wit_ruby/rest/entity.rb

@@ -0,0 +1,36 @@
+## entity.rb
+## Wrapper for entity results.
+
+module Wit
+  module REST
+
+    ## Encompasses entity results.
+    class Entity < Result
+
+    end
+
+    ## Internal wrapper for multiple entities for a given result.
+    class MultiEntity
+      ## Creates an instance that holds array of intents.
+      ##
+      ## @param resultData [Array] array of hashes of intents.
+      ## @return [Wit::REST::MultiEntity] with instance variable of Array of intents.
+      def initialize(resultData)
+
+        entity_arr = Array.new
+        resultData.each do |entity|
+          entity_arr << Entity.new(entity)
+        end
+        @entities = entity_arr
+      end
+
+      ## Allow for index calls to the specific intents in the instance.
+      ##
+      ## @param num [Integer] index of the specific intent.
+      def [](num)
+        @entities[num]
+      end
+
+    end
+  end
+end

data/lib/wit_ruby/rest/expression.rb

@@ -0,0 +1,12 @@
+## expression.rb
+## Internal wrapper for expression hash
+
+module Wit
+  module REST
+    ## Internal wrapper for expressions in an intent. 
+    class Expression < Result
+
+
+    end
+  end
+end

data/lib/wit_ruby/rest/intent.rb

@@ -0,0 +1,93 @@
+## intent.rb
+## Wrapper for the superclass Result for intent specific results
+
+module Wit
+  module REST
+
+    ## Intent wrapper for intent specific results
+    class Intent < Result
+
+      ## Performs additional instance variable generation for expressions.
+      ##
+      ## @param resultData [Hash] data from the call.
+      ## @param requestRest [String] rest code for the call.
+      ## @param requestPath [String] request path for the call.
+      ## @param requestBody [Hash] body of the call.
+      ## @return [Wit::REST::Expression] object that holds the intent result.
+      def initialize(resultData, requestRest=nil, requestPath=nil, requestBody=nil)
+        super
+        @expressions = @rawdata["expressions"].map do |expression_hash|
+          Expression.new(expression_hash)
+        end
+      end
+
+      ## Return the list of expressions as array of expression objects
+      ##
+      ## @return [Array] expressions in this intent.
+      def expressions
+        return @expressions
+      end
+
+      ## Return the expression bodies as an array of strings.
+      ##
+      ## @return [Array] body of each expression.
+      def expression_bodies
+        expression_bodies_arr = Array.new
+        @expressions.each do |expression|
+          expression_bodies_arr << expression.body
+        end
+        return expression_bodies_arr
+      end
+
+      ## Return entities used with there id as an array of strings.
+      ##
+      ## @return [Array] entity names that are used in this intent.
+      def entities_used
+        entities_arr = Array.new
+        @entities.each do |entity|
+          entities_arr << entity.id unless entities_arr.include?(entity.id)
+        end
+        return entities_arr
+      end
+
+
+    end
+
+    ## MultiIntent wraps around results that are an array with intents.
+    class MultiIntent < Result
+
+      ## Generates instance variable that holds intents as Wit::REST::Result.
+      ##
+      ## @param resultData [Hash] data from the call.
+      ## @param requestRest [String] rest code for the call.
+      ## @param requestPath [String] request path for the call.
+      ## @param requestBody [Hash] body of the call.
+      ## @return [Wit::REST::MultiIntent] object that holds the array of intents as result objects.
+      def initialize(resultData, requestRest=nil, requestPath=nil, requestBody=nil)
+        ## Pass in empty hash to default to method missing for everything not defined here.
+        super({}, requestRest, requestPath, requestBody)
+        @intents = resultData.map do |intent|
+          Result.new(intent)
+        end
+      end
+
+      ## Overide that assists in calling the proper index in the array of intent results.
+      ##
+      ## @param num [Integer] index of the array of Wit::REST::Result.
+      ## @return [Wit::REST::Result] specific intent at the index given.
+      def [](num)
+        @intents[num]
+      end
+
+      ## Assists in going through each intent in the instance variable.
+      ##
+      ## @return [Wit::REST::Result] lambda that provides each specific intent.
+      def each
+        @intents.each do |intent|
+          lambda{intent}
+        end
+      end
+
+    end
+  end
+end

data/lib/wit_ruby/rest/message.rb

@@ -0,0 +1,54 @@
+## message.rb
+## Wraps around results, specifically messages.
+module Wit
+  module REST
+
+
+    ## Message wrapper for message specific results.
+    class Message < Result
+
+      ## Returns the confidence of the message results.
+      ##
+      ## @return [Float] confidence in the message for the intent.
+      def confidence
+        outcome["confidence"]
+      end
+
+      ## Returns the intent that this message corresponded to.
+      ##
+      ## @return [String] intent name that this message corrsponded to.
+      def intent
+        outcome["intent"]
+      end
+
+      ## Generates Array of the names of each entity in this message.
+      ##
+      ## @return [Array] names of each entity
+      def entity_names
+        entity_arr = Array.new
+        outcome["entities"].each_key do |key|
+          entity_arr << key
+        end
+        return entity_arr
+      end
+
+      ## Checks if the method is one of the keys in the hash. Overides the one
+      ## in Wit::REST::Result as it might correspond to a given entity.
+      ## If it is then we can return the given value.
+      ## If not, then go to method_missing in Wit::REST::Result.
+      ##
+      ## @params [Symbol] possible method or key in the hash or entity.
+      ## @return [String] [Integer] [Hash] depending on the given results in the data.
+      def method_missing(possible_key, *args, &block)
+        if @rawdata["outcome"]["entities"].has_key?(possible_key.to_s)
+          entity_value = @rawdata["outcome"]["entities"][possible_key.to_s]
+          entity_value.class == Hash ? Entity.new(entity_value) : MultiEntity.new(entity_value)
+        else
+          super
+        end
+      end
+
+
+    end
+  end
+end

data/lib/wit_ruby/rest/result.rb

@@ -1,49 +1,119 @@
 ## result.rb
-## Specifies class that handles the results given from each RESTful API call.
+## Specifies superclass that handles the results given from each RESTful API call.
 
 
 module Wit
   module REST
+
+    ## Wrapper for all results that is returned by the session and API calls.
     class Result
 
 
-    ## Instantiates with a given hash.
-    def initialize(resultHash, requestRest=nil, requestPath=nil, requestBody=nil)
-      @originalHash = resultHash
-      @requestRest = requestRest
-      @requestPath = requestPath
-      @requestBody = requestBody
-    end
+      ## Instantiates with a given hash and its REST parameters.
+      ##
+      ## @param resultData [Hash] data from the call.
+      ## @param requestRest [String] rest code for the call.
+      ## @param requestPath [String] request path for the call.
+      ## @param requestBody [Hash] body of the call.
+      ## @return [Wit::REST::Result] object that holds result information.
+      def initialize(resultData, requestRest=nil, requestPath=nil, requestBody=nil)
+        @rawdata = resultData
+        @requestRest = requestRest
+        @requestPath = requestPath
+        @requestBody = requestBody
+        ## Sets self class to be the last index of the split class name.
+        @selfClass = self.class.name.split("::")[-1]
+        ## Setup lists / instance variables given the current class that is inheriting
+        setup_entities if ["Intent", "Expression"].include?(@selfClass)
+      end
 
-    ## Returns the orginalHash instance variable.
-    def hash
-      return @originalHash
-    end
+      ## Returns the orginalHash instance variable.
+      ##
+      ## @return [Hash] the raw data from the call.
+      def raw_data
+        return @rawdata
+      end
 
-    ## Returns the REST code from the given request
-    def restCode
-      return @requestRest
-    end
-    ## Returns the request's body
-    def body
-      return @requestBody
-    end
+      ## Returns the REST code from the given request.
+      ##
+      ## @return [String] request code from the call.
+      def restCode
+        return @requestRest
+      end
 
-    ## Returns the request's path
-    def path
-      return @requestPath
-    end
+      ## Returns the request's body.
+      ##
+      ## @return [String] request body from the call.
+      def restBody
+        return @requestBody
+      end
 
+      ## Returns the request's path.
+      ##
+      ## @return [String] request path from the call.
+      def restPath
+        return @requestPath
+      end
 
-    ## Checks if the method is one of the keys in the hash.
-    ## If it is then we can return the given value.
-    ## If not, then raise a NoMethodError.
-    def method_missing(possible_key, *args, &block)
-      @originalHash.has_key?(possible_key.to_s) ? @originalHash[possible_key.to_s] : super
-    end
 
+      ## Returns the list of entities from the given results. Only applicable
+      ## to a few objects. If the current class is not applicable, then raise an
+      ## error.
+      ##
+      ## @return [Array] array of entities.
+      def entities
+        unless ["Intent", "Expression"].include?(@selfClass)
+          raise NoMethodError.new(%(The current class "#{@selfClass}' does not incorporate the '#{__method__}' method.))
+        end
+
+        ## Included so return it.
+        return @entities
+      end
 
+      ## Checks if the method is one of the keys in the hash.
+      ## If it is then we can return the given value.
+      ## If not, then raise a NoMethodError.
+      ##
+      ## @params [Symbol] possible method or key in the hash
+      ## @return [String] [Integer] [Hash] depending on the given results in the data.
+      def method_missing(possible_key, *args, &block)
+        @rawdata.has_key?(possible_key.to_s) ? @rawdata[possible_key.to_s] : super
+      end
+
+      ## Method to check if this current object is refreshable.
+      ## It is refresahble if the request parameters for checking is not nil;
+      ##
+      ## @return [Boolean] indicating if the current object is refreshable.
+      def refreshable?
+        !@requestRest.nil?
+      end
+
+
+
+      private
+
+      ## Setups entities list if the current class demands it.
+      ##
+      ## @return [Array] entities in this current result object.
+      def setup_entities
+        ## Get the current entities hash
+        entities_raw = @rawdata["entities"] || @rawdata["outcome"]["entities"]
+        ## Set the intance variable to be an array containing these entities.
+        ## If its empty, then set the instance variable to nil
+        unless entities_raw.empty?
+          entities_arr = Array.new
+          entities_raw.each do |entity_value|
+              entities_arr << Entity.new(entity_value)
+          end
+          @entities = entities_arr
+        else
+          @entities = nil
+        end
+        return @entities
+
+      end
 
     end
+
   end
 end

data/lib/wit_ruby/rest/session.rb

@@ -6,29 +6,56 @@ module Wit
   module REST
     class Session
       ## Initialize with the given client.
+      ##
+      ## @param client [Wit::REST::Client] client of the connection
       def initialize(client)
         @client = client
       end
-      ## GET - extracted meaning form a sentence
+      ## GET - extracted meaning from a sentence.
+      ##
+      ## @param message [String] sentence being examined from API.
+      ## @return [Wit::REST::Message] message results from API.
       def send_message(message)
-         return @client.get("/message?q=#{message}")
+        ## Recieve unwrapped results
+        results = @client.get("/message?q=#{message}")
+        return Message.new(results.raw_data, results.restCode, results.restPath, results.restBody)
       end
 
       ## POST - extract meaning from a audio file
       ## Do check the certain documentation of what the specific audio file
       ## should be.
+      ##
+      ## @param sound [String] path to sound file.
       def send_sound_message(sound)
       end
 
       ## GET - returns stored message for specific id.
       ## TODO - possibly renaming as it is ambigious compared to send_message.
+      ## TODO - Notify Wit.ai as there documentation does not include the stats parameter
+      ##
+      ## @param message_id [String] message id of message in API servers.
+      ## @return [Wit::REST::Message] message results from the given id.
       def get_message(message_id)
+        results = @client.get("/messages/#{message_id}")
 
+        return Message.new(results.raw_data, results.restCode, results.restPath, results.restBody)
       end
 
       ## GET - returns either a list of intents if no id is given.
       ##     - returns the specific intent of the id given.
-      def get_intent(intent_id = nil)
+      ##
+      ## @param intent_indicator [String] the id or name of the intent
+      ## @return [Wit:REST::Intent] [Wit::REST::MultiIntent] results of intent call to API.
+      def get_intents(intent_indicator = nil)
+        ## TODO - Raise error if no intents
+
+        ## No spefic id, so get list of intents or specific id, return it as Intent object
+        results = intent_indicator.nil? ? @client.get("/intents") : @client.get("/intents/#{intent_indicator}")
+
+        ## Same concept but wrap it around proper object
+        returnObject = intent_indicator.nil? ? MultiIntent : Intent
+        return returnObject.new(results.raw_data, results.restCode, results.restPath, results.restBody)
+
       end
 
       ## TODO - look into corpus
@@ -76,19 +103,35 @@ module Wit
 
       end
 
-      ## Used to refresh the results from the given results.
+      ## Used to refresh the results from the given results. Only applicable to result objects that directly
+      ## came from the session.
+      ##
+      ## @param result [Wit::REST::Result] result from a call that is going to be refreshed.
+      ## @return [Wit::REST::Result] result back that will be wrapped around it's specific wrapper object
       def refresh_results(result)
         ## Call client with refresh results method
-        return @client.request_from_result(result.restCode, result.path, result.body)
+        ## Checks to see if its part of the specified objects in the Wit module
+        ## Checks to see if the object is refreshable
+        ## If it isn't part of one of these two, then raise error for not being refreshable.
+        result_class = result.class
+        unless  result_class.name.split("::")[0] == "Wit" && result.refreshable?
+          raise NotRefreshable.new(%(The inputted object with class "#{result.class}" is not refreshable.))
+        end
+        refreshed_result = @client.request_from_result(result.restCode, result.restPath, result.restBody)
+        return result_class.new(refreshed_result.raw_data, refreshed_result.restCode, refreshed_result.restPath, refreshed_result.restBody)
       end
 
       ## Used to refresh the last response given from the last request.
+      ## TODO - fix wrapper
+      ##
+      ## @return [Wit::REST::Result] refreshed result from last result
       def refresh_last
         last_result = @client.last_result
-        return @client.request_from_result(last_result.restCode, last_result.path, last_result.body)
+        return @client.request_from_result(last_result.restCode, last_result.restPath, last_result.restBody)
       end
 
-
     end
+
+    class NotRefreshable < Exception; end
   end
 end

data/lib/wit_ruby/version.rb

@@ -1,3 +1,3 @@
 module Wit
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/wit_ruby.rb

@@ -7,3 +7,7 @@ require "wit_ruby/version"
 require "wit_ruby/rest/client"
 require "wit_ruby/rest/session"
 require "wit_ruby/rest/result"
+require "wit_ruby/rest/message"
+require "wit_ruby/rest/intent"
+require "wit_ruby/rest/entity"
+require "wit_ruby/rest/expression"

data/spec/spec_helper.rb

@@ -7,9 +7,23 @@ require 'pry'
 
 require 'webmock/rspec'
 require 'vcr'
+require 'timeout'
 
 #VCR config
 VCR.configure do |c|
   c.cassette_library_dir = 'spec/fixtures/wit_cassettes'
   c.hook_into :webmock
+  allow_next_request_at = nil
+  filters = [:real?, lambda { |r| URI(r.uri).host == 'api.wit.ai' }]
+
+  c.after_http_request(*filters) do |request, response|
+    allow_next_request_at = Time.now + 1
+  end
+
+  c.before_http_request(*filters) do |request|
+    if allow_next_request_at && Time.now < allow_next_request_at
+      sleep(allow_next_request_at - Time.now)
+    end
+  end
+
 end

data/spec/wit_ruby/rest/entity_spec.rb

@@ -0,0 +1,49 @@
+## entity_spec.rb
+## Used to test functionalities of the entity wrapper for results.
+
+require 'spec_helper'
+
+describe Wit::REST::Entity do
+  let(:json) {%({
+  "builtin": true,
+  "doc": "Temperature in degrees Celcius or Fahrenheit",
+  "id": "temperature",
+  "name": "535856ea-db8b-492b-a159-fc78cd016a4b"
+  })}
+  let(:rand_path) {"rand_path"}
+  let(:rand_body) {"rand_body"}
+  let(:rest_code) {"get"}
+  let(:entity_results) {Wit::REST::Entity.new(MultiJson.load(json), rand_path, rand_body, rest_code)}
+
+  it "should have builtin as true" do
+    expect(entity_results.builtin).to eql(true)
+  end
+
+end
+
+describe Wit::REST::MultiEntity do
+  let(:json_two) {%([
+    {
+      "value": {
+        "from": "2013-10-21T00:00:00.000Z",
+        "to": "2013-10-22T00:00:00.000Z"
+      },
+      "body": "Tuesday"
+    },
+    {
+      "value": {
+        "from": "2013-10-24T00:00:00.000Z",
+        "to": "2013-10-25T00:00:00.000Z"
+      },
+      "body": "Friday"
+    }
+  ])}
+  let(:entity_coll) {Wit::REST::MultiEntity.new(MultiJson.load(json_two))}
+
+
+  it "should be an array with entities" do
+    expect(entity_coll[0].class).to eql(Wit::REST::Entity)
+    expect(entity_coll[0].body).to eql("Tuesday")
+  end
+
+end

data/spec/wit_ruby/rest/expression_spec.rb

@@ -0,0 +1,38 @@
+## expression_spec.rb
+## Used to test functionalities of internal result wrappers for expressions.
+require 'spec_helper'
+
+describe Wit::REST::Expression do
+  let(:json) {%(
+  {
+    "id" : "-2385b07a3900bd-8393b722-6d4e-4185-bb18-410136cdb794",
+    "body" : "fly from incheon to sfo",
+    "entities" : [ {
+      "wisp" : "wit$location",
+      "start" : 20,
+      "end" : 23,
+      "role" : "dest",
+      "body" : "sfo",
+      "value" : "sfo"
+    }, {
+      "wisp" : "wit$location",
+      "start" : 9,
+      "end" : 16,
+      "role" : "orig",
+      "body" : "incheon ",
+      "value" : "incheon"
+    } ]
+  })}
+  let(:express_results) {Wit::REST::Expression.new(MultiJson.load(json))}
+
+  it "should have a list of entities" do
+    expect(express_results.entities.class).to eql(Array)
+    expect(express_results.entities[0].class).to eql(Wit::REST::Entity)
+  end
+
+  it "should have the correct indexes and values" do
+    expect(express_results.entities[0].start).to eql(20)
+    expect(express_results.entities[1].start).to eql(9)
+  end
+
+end

data/spec/wit_ruby/rest/intent_spec.rb

@@ -0,0 +1,116 @@
+## intent_spec.rb
+## Used to test functionalities of intent wrapper in wit_ruby/rest/intent.rb
+
+require 'spec_helper'
+
+describe Wit::REST::Intent do
+  let(:json) {%({
+  "expressions" : [ {
+    "id" : "-2385b07a3900bd-8393b722-6d4e-4185-bb18-410136cdb794",
+    "body" : "fly from incheon to sfo",
+    "entities" : [ {
+      "wisp" : "wit$location",
+      "start" : 20,
+      "end" : 23,
+      "role" : "dest",
+      "body" : "sfo",
+      "value" : "sfo"
+    }, {
+      "wisp" : "wit$location",
+      "start" : 9,
+      "end" : 16,
+      "role" : "orig",
+      "body" : "incheon ",
+      "value" : "incheon"
+    } ]
+  }, {
+    "id" : "-2385b07e09b74a-d95db384-fac2-4e41-85ca-3072778aa99c",
+    "body" : "i wanna fly from JFK to SFO",
+    "entities" : [ {
+      "wisp" : "wit$location",
+      "start" : 24,
+      "end" : 27,
+      "role" : "dest",
+      "body" : "SFO",
+      "value" : "SFO"
+    }, {
+      "wisp" : "wit$location",
+      "start" : 17,
+      "end" : 20,
+      "role" : "orig",
+      "body" : "JFK ",
+      "value" : "JFK"
+    } ]
+  } ],
+  "entities" : [ {
+    "role" : "dest",
+    "id" : "wit$location"
+  }, {
+    "role" : "orig",
+    "id" : "wit$location"
+  } ],
+  "id" : "52bab83b-fbef-40db-b19d-a0dccd38cfdc",
+  "name" : "book_flight",
+  "doc" : "book flight"
+  })}
+  let(:rand_path) {"rand_path"}
+  let(:rand_body) {"rand_body"}
+  let(:rest_code) {"get"}
+  let(:intent_results) {Wit::REST::Intent.new(MultiJson.load(json), rand_path, rand_body, rest_code)}
+
+
+  it "should have a list of entities" do
+    expect(intent_results.entities.class).to eql(Array)
+    expect(intent_results.entities[0].class).to eql(Wit::REST::Entity)
+  end
+  it "should have a list of expressions" do
+    expect(intent_results.expressions.class).to eql(Array)
+    expect(intent_results.expressions[0].class).to eql(Wit::REST::Expression)
+  end
+
+  it "should have the right values in the entities" do
+    expect(intent_results.entities[0].role).to eql("dest")
+    expect(intent_results.entities[1].role).to eql("orig")
+  end
+
+  it "should have the right values for expressions" do
+    expect(intent_results.expressions[0].body).to eql("fly from incheon to sfo")
+    expect(intent_results.expressions[1].body).to eql("i wanna fly from JFK to SFO")
+  end
+  it "should return the body names for each expressions as an array of strings" do
+    expect(intent_results.expression_bodies).to eql(["fly from incheon to sfo", "i wanna fly from JFK to SFO"])
+  end
+  it "should return used entities as an array of strings" do
+    expect(intent_results.entities_used).to eql(["wit$location"])
+  end
+
+
+end
+
+describe Wit::REST::MultiIntent do
+  let(:json_two) {%([ {
+  "id" : "52bab833-e024-4f15-b927-8e0772d1540c",
+  "name" : "recover_password",
+  "doc" : "Recover password (which is different from Reset password).",
+  "metadata" : "password_23433253254"
+  }, {
+  "id" : "52bab833-9a1e-4bff-b659-99ee95e6c1f9",
+  "name" : "transfer",
+  "doc" : "Transfer some amount of money between two accounts."
+  }, {
+  "id" : "52bab833-3e23-4c67-9cfc-a0fed605bd77",
+  "name" : "show_movie",
+  "doc" : "Show a given movie."
+  } ])}
+  let(:rand_path) {"rand_path"}
+  let(:rand_body) {"rand_body"}
+  let(:rest_code) {"get"}
+  let(:multi_intent_results) {Wit::REST::MultiIntent.new(MultiJson.load(json_two), rand_path, rand_body, rest_code)}
+
+  it "should each be saved as a result object" do
+    multi_intent_results.each do |intent|
+      expect(intent.class).to eql Result
+    end
+  end
+
+end

data/spec/wit_ruby/rest/message_spec.rb

@@ -0,0 +1,63 @@
+## message_spec.rb
+## Used to test wrapper for message results
+
+
+require 'spec_helper'
+
+describe Wit::REST::Message do
+  let(:json) {%({
+  "msg_id": "ba0fcf60-44d3-4499-877e-c8d65c239730",
+  "msg_body": "how many people between Tuesday and Friday",
+  "outcome": {
+    "intent": "query_metrics",
+    "entities": {
+      "metric": {
+        "value": "metric_visitors",
+        "body": "people",
+        "metadata": "{'code' : 324}"
+      },
+      "datetime": [
+        {
+          "value": {
+            "from": "2013-10-21T00:00:00.000Z",
+            "to": "2013-10-22T00:00:00.000Z"
+          },
+          "body": "Tuesday"
+        },
+        {
+          "value": {
+            "from": "2013-10-24T00:00:00.000Z",
+            "to": "2013-10-25T00:00:00.000Z"
+          },
+          "body": "Friday"
+        }
+      ]
+    },
+    "confidence": 0.979
+  }
+  })}
+  let(:rand_path) {"rand_path"}
+  let(:rand_body) {"rand_body"}
+  let(:rest_code) {"get"}
+  let(:message_results) {Wit::REST::Message.new(MultiJson.load(json), rand_path, rand_body, rest_code)}
+
+
+  it "should have the following parameters, confidence and intent and entities" do
+    expect(message_results.confidence).to eql(0.979)
+    expect(message_results.intent).to eql("query_metrics")
+    expect(message_results.metric.class).to eql(Wit::REST::Entity)
+    expect(message_results.datetime.class).to eql(Wit::REST::MultiEntity)
+  end
+
+  it "should have the right values in the entities" do
+    expect(message_results.metric.value).to eql("metric_visitors")
+    expect(message_results.datetime[0].body).to eql("Tuesday")
+  end
+
+  it "should be able to return back an array of strings of the names of each entity" do
+    expect(message_results.entity_names).to eql(["metric", "datetime"])
+  end
+
+
+
+end

data/spec/wit_ruby/rest/result_spec.rb

@@ -8,10 +8,10 @@ describe Wit::REST::Result do
   let(:rand_body) {"rand_body"}
   let(:rest_code) {"post"}
   let(:result) {Wit::REST::Result.new(randHash, rest_code, rand_path, rand_body)}
-
+  let(:not_refresh_result) {Wit::REST::Result.new(randHash)}
 
   it "should have an instance of the original hash" do
-    expect(result.hash).to eql(randHash)
+    expect(result.raw_data).to eql(randHash)
   end
 
   it "should raise an error for a method that is not in the attributes of the hash" do
@@ -31,8 +31,13 @@ describe Wit::REST::Result do
 
   it "should have an optional parameters to store the original request's body and pth" do
     expect(result.restCode).to eql(rest_code)
-    expect(result.path).to eql(rand_path)
-    expect(result.body).to eql(rand_body)
+    expect(result.restPath).to eql(rand_path)
+    expect(result.restBody).to eql(rand_body)
+  end
+
+  it "should be refereshable if rest parameters and path/body are given and not if it isn't given" do
+    expect(result.refreshable?).to be_true
+    expect(not_refresh_result.refreshable?).to be_false
   end
 
 end

data/spec/wit_ruby/rest/session_spec.rb

@@ -7,6 +7,7 @@ describe Wit::REST::Session do
   let(:auth) {"randomAuth"}
   let(:randClient) {"randomClient"}
   let(:message) {"Hi"}
+  let(:rand_hash) {{"a" => "a", "b" => "b"}}
   let(:randSession) {Wit::REST::Session.new(randClient)}
   let(:session) {Wit::REST::Client.new.session}
 
@@ -29,8 +30,8 @@ describe Wit::REST::Session do
       randSession.should respond_to(:get_message)
     end
 
-    it "get_intent(intent_id = nil)" do
-      randSession.should respond_to(:get_intent)
+    it "get_intents(intent_id = nil)" do
+      randSession.should respond_to(:get_intents)
     end
 
     it ".entities(entity_id = nil)" do
@@ -72,7 +73,7 @@ describe Wit::REST::Session do
 
   describe "Sending message" do
     let(:result) {session.send_message(message)}
-    let(:result_hash){result.hash}
+    let(:result_data){result.raw_data}
 
     before do
       VCR.insert_cassette 'message', record: :new_episodes
@@ -81,12 +82,12 @@ describe Wit::REST::Session do
       VCR.eject_cassette
     end
 
-    it "should return an object of class Result" do
-      expect(result.class).to eql(Wit::REST::Result)
+    it "should return an object of class Message" do
+      expect(result.class).to eql(Wit::REST::Message)
     end
 
     it "should have a message id method" do
-      expect(result.msg_id).to eql(result.hash["msg_id"])
+      expect(result.msg_id).to eql(result_data["msg_id"])
     end
 
 
@@ -99,7 +100,7 @@ describe Wit::REST::Session do
         @results = session.send_message(message)
         stub_request(:any, /api.wit.ai/).to_timeout
       end
-
+      let(:random_result) {Wit::REST::Result.new(rand_hash)}
 
 
         it "must be able refresh and resend the call to the API given the result class" do
@@ -110,6 +111,11 @@ describe Wit::REST::Session do
           expect{session.refresh_last}.to raise_error(Timeout::Error)
         end
 
+        it "should not be able to refresh a not refreshable object" do
+          expect{session.refresh_results("random_class")}.to raise_error(Wit::REST::NotRefreshable)
+          expect{session.refresh_results(random_result)}.to raise_error(Wit::REST::NotRefreshable)
+        end
+
 
 
     end
@@ -117,4 +123,64 @@ describe Wit::REST::Session do
   end
 
 
+  describe "Geting message info" do
+    let(:sent_message_result) {session.send_message(message)}
+    let(:sent_message_id) {sent_message_result.msg_id}
+    before do
+      VCR.insert_cassette 'get_message', record: :once
+    end
+    after do
+      VCR.eject_cassette
+    end
+    describe "Getting back message info " do
+
+      before do
+        @resulting_message = session.get_message(sent_message_id)
+      end
+
+      it "should get back the same message and have the same has as the sent message results" do
+        expect(@resulting_message.msg_id).to eql(sent_message_id)
+        expect(@resulting_message.msg_body).to eql(sent_message_result.msg_body)
+      end
+    end
+  end
+
+  describe "Get intents" do
+    let(:get_intent_arr) {session.get_intents}
+
+
+    before do
+      VCR.insert_cassette 'get_intents', record: :new_episodes
+    end
+    after do
+      VCR.eject_cassette
+    end
+    it "should have returned an array of intents in class MultiIntent if not given an id" do
+      expect(get_intent_arr.class).to eql(Wit::REST::MultiIntent)
+      expect(get_intent_arr[0].class).to eql(Wit::REST::Result)
+    end
+
+  end
+
+  describe "Get specific intent" do
+    let(:get_intent_arr) {session.get_intents}
+    let(:intent_id) {get_intent_arr[0].id}
+    let(:intent_name) {get_intent_arr[0].name}
+    let(:get_intent_id) {session.get_intents(intent_id)}
+    let(:get_intent_name) {session.get_intents(intent_name)}
+    before do
+      VCR.insert_cassette 'get_intent_specific', record: :new_episodes
+    end
+    after do
+      VCR.eject_cassette
+    end
+
+    it "should return an intent result if given an id or name and must be same results" do
+      expect(get_intent_id.class).to eql(Wit::REST::Intent)
+      expect(get_intent_name.class).to eql(Wit::REST::Intent)
+      expect(get_intent_id.id).to eql(get_intent_name.id)
+    end
+
+  end
+
 end

data/wit_ruby.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.version       = Wit::VERSION
   spec.authors       = ["Gavin Ching"]
   spec.email         = ["gavinchingy@gmail.com"]
-  spec.description   = %q{Provides a Ruby interface with the Wit.ai API.}
-  spec.summary       = %q{Provides a Ruby interface with the Wit.ai API.}
+  spec.description   = %q{Provides a Ruby API wrapper with the Wit.ai API.}
+  spec.summary       = %q{Provides a Ruby API wrapper with the Wit.ai API.}
   spec.homepage      = ""
   spec.license       = "MIT"
 
@@ -19,8 +19,9 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.required_ruby_version = ">= 1.8.7"
-  spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_dependency('multi_json', '>= 1.3.0')
+
+  spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
   spec.add_development_dependency "rspec-nc"

metadata

@@ -1,43 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: wit_ruby
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Gavin Ching
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-08 00:00:00.000000000 Z
+date: 2014-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: multi_json
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
-  type: :development
+        version: 1.3.0
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: 1.3.0
 - !ruby/object:Gem::Dependency
-  name: multi_json
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.3.0
-  type: :runtime
+        version: '1.3'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.3.0
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -192,7 +192,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Provides a Ruby interface with the Wit.ai API.
+description: Provides a Ruby API wrapper with the Wit.ai API.
 email:
 - gavinchingy@gmail.com
 executables: []
@@ -202,6 +202,7 @@ files:
 - ".coveralls.yml"
 - ".gitignore"
 - ".travis.yml"
+- CHANGELOG
 - Gemfile
 - Guardfile
 - LICENSE.txt
@@ -210,11 +211,19 @@ files:
 - conf/cacert.pem
 - lib/wit_ruby.rb
 - lib/wit_ruby/rest/client.rb
+- lib/wit_ruby/rest/entity.rb
+- lib/wit_ruby/rest/expression.rb
+- lib/wit_ruby/rest/intent.rb
+- lib/wit_ruby/rest/message.rb
 - lib/wit_ruby/rest/result.rb
 - lib/wit_ruby/rest/session.rb
 - lib/wit_ruby/version.rb
 - spec/spec_helper.rb
 - spec/wit_ruby/rest/client_spec.rb
+- spec/wit_ruby/rest/entity_spec.rb
+- spec/wit_ruby/rest/expression_spec.rb
+- spec/wit_ruby/rest/intent_spec.rb
+- spec/wit_ruby/rest/message_spec.rb
 - spec/wit_ruby/rest/result_spec.rb
 - spec/wit_ruby/rest/session_spec.rb
 - wit_ruby.gemspec
@@ -241,9 +250,13 @@ rubyforge_project:
 rubygems_version: 2.1.10
 signing_key: 
 specification_version: 4
-summary: Provides a Ruby interface with the Wit.ai API.
+summary: Provides a Ruby API wrapper with the Wit.ai API.
 test_files:
 - spec/spec_helper.rb
 - spec/wit_ruby/rest/client_spec.rb
+- spec/wit_ruby/rest/entity_spec.rb
+- spec/wit_ruby/rest/expression_spec.rb
+- spec/wit_ruby/rest/intent_spec.rb
+- spec/wit_ruby/rest/message_spec.rb
 - spec/wit_ruby/rest/result_spec.rb
 - spec/wit_ruby/rest/session_spec.rb