wit_ruby 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 971419a9504d3b3f6a033650f424daaba39f6a3b
-  data.tar.gz: f81c794354b97acf237ee363474b7dfb9513dff3
+  metadata.gz: 1640efe7f4c172e77b20dfd68abb9cd32aad90fc
+  data.tar.gz: cd459ecaa05c9169b7c86287137effa7efc9381c
 SHA512:
-  metadata.gz: ab3c0ab3b94f1c6b02d82ab2e4fe717d3a88641117fe4f2e1f45b21c7ef2e124995dcca013d3b38dee36176aae6051b38444aefa6ba957259ee5a9aa7d0b59ff
-  data.tar.gz: ec22891627f70d3d99e49abfe580c973819db15d8d6e2e052f42dc425a0fe8b9e31b13bf7b6cc05e55de23282e3a6e802030c5de20b03ae835ef4f1f5dc77ab2
+  metadata.gz: b48276ba61d3b267bf6596a46d2af8b2a3935155f12ad87898c21b7d7a08546cf0cac7a3849758d9cb54c7be7a7b0fdc39668678fd85442d59677f44b7fe2dea
+  data.tar.gz: 2c418a23e162702fae0a3b7c73e4508760852975124cf30d2a639e7ca0dd2c3def1b252bf252ea12aa74b1ddddfa45419694be1fc9544ed5356ca265b5e13b95

data/.travis.yml

@@ -3,6 +3,7 @@ cache: bundler
 rvm:
 - jruby
 - 2.0.0
+- 1.9.3
 script: bundle exec rake
 env:
   global:

data/CHANGELOG

@@ -1,3 +1,16 @@
+== 0.0.3
+* Implemented getting array of entities from instance (GET).
+* Implemented getting a specific entity from its name/id (GET).
+* Implemented creation of entities (POST).
+* Implemented the ability to update entities given the ID (PUT).
+* Implemented deletion of entities (DELETE).
+* Implemented addition of values (POST).
+* Implemented deletion of values (DELETE).
+* Implemented addition of expressions (POST).
+* Implemented deletion of expressions (DELETE).
+* Changed required Ruby version from 1.8.7 to 1.9.3
+* Added new class definition for post / put calls assistance. Helps with JSON generation.
+
 == 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).

data/README.md

@@ -2,7 +2,11 @@
 
 # WitRuby
 
-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.
+Provides a unofficial and (seemingly) pleasant Ruby API Wrapper for the Wit.ai API. As of 0.0.3, most functionalities have been implemented. Go over to https://rubygems.org/gems/wit_ruby for more information.
+
+Documentation that you will definitely need : http://rubydoc.info/gems/wit_ruby/
+
+Do also reference the Wit.ai API documentation : https://wit.ai/docs/api
 
 [![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)
@@ -30,51 +34,115 @@ Remember to put this up to access it!
 
 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"]
+    ## Default to ENV["WIT_AI_TOKEN"]
     $ client = Wit::REST::Client.new()
-    $ ## Override token when created
+    ## 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.
+Please again, do look over documentation to see the full scope of usage and configuration.
+
+### Result
+
+Every method returns a class wrapper corresponding specifically to the results pertaining to it. 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"
+
+Every direct result returned from each method call defined from the session will be refreshable.
+
+### JSON Specific Calls
 
-## Message
+Methods that require JSON for the API calls will be generated through use of the class Wit::REST::BodyJson.
+BodyJson inherits from OpenStruct and will assist in providing properly formatted JSON for the methods.
+
+Depending on the data needed, certain methods are provided. For example:
+
+    ## First instantiate.
+    $ new_body = Wit::REST::BodyJson.new
+    ## Adding an ID and doc parameter
+    $ new_body.id = "Some ID"
+    $ new_body.doc = "Some doc"
+    ## Adding value and expression.
+    $ new_body.add_value("Some value", "possible expressions that--", "--that can be added to this value")
+    $ new_body.add_expression("Some existing value", "possible expressions that--", "--that can be added to this value")
+
+
+### Message
 
 To send a specific message, use the saved session to send a given string as a parameter.
 
-    $ results = session.send_message("Your Message")
+    $ 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")
+    $ session.get_message("Message ID")
 
-## Intent
+### Intent
 
 To get a list of intents in the specific instance over at wit.ai.
 
-    $ ## Array of all intents used.
-    $ results = session.get_intents
+    $ 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")
+    $ session.get_intents("Intent ID or Name")
 
-## Result
+### Entities
 
-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,
+To get a list of entities for this instance.
 
-    $ ## results.hash = {"a" => "b"}
-    $ results.a
-    $  => "b"
+    $ session.get_entities
+
+To get a specific entity, pass it in's ID
+
+    $ session.get_entities("Entity ID")
+
+To create and update entities, methods require a Wit::REST::BodyJson object with an id defined and optional doc, values and expressions defined.
+
+    ## New entity
+    $ new_entity = Wit::REST::BodyJson.new(id: "some id")
+    $ session.create_entity(new_entity)
+    ## Update it with a new doc parameter
+    $ new_entity.doc = "some doc"
+
+Deleting the entity requires the passing of it's ID
+
+    $ session.delete_entity("some entity id")
+
+
+### Values
+
+To create a new value, a Wit::REST::BodyJson object needs to be created with the ID of the entity and new value.
+
+    $ value_create = Wit::REST::BodyJson.new(id: "entity for new value")
+    $ value_create.add_value("some new value")
+    $ session.add_value(value_create)
+
+To delete, require the passing of the entity id and value name.
+
+    $ session.delete_value("entity id", "value name")
+
+### Expressions
+
+Add an expression by passing in the entity's id, value name, and the new expression.
+
+    $ session.add_expression("some entity id", "some value name", "new expression")
+
+Same goes for the deletion of an expression.
+
+    $ session.delete_expression("some entity id", "some value name", "to be deleted expression")
 
 ## Contributing
 
-I am a beginner developer so do contribute or help as much as possible! I definitely need to learn a lot :).
+I am a beginner developer so do contribute or help as much as possible! I definitely need to learn a lot :). Whoever helps will also have there name put here below this line. Amazing!
+_________________________________
+
 
 1. Fork it
 2. Create your feature branch (`git checkout -b my-new-feature`)

data/lib/wit_ruby.rb

@@ -1,7 +1,7 @@
 require 'net/http'
 require 'net/https'
 require 'multi_json'
-
+require 'ostruct'
 
 require "wit_ruby/version"
 require "wit_ruby/rest/client"
@@ -11,3 +11,4 @@ require "wit_ruby/rest/message"
 require "wit_ruby/rest/intent"
 require "wit_ruby/rest/entity"
 require "wit_ruby/rest/expression"
+require "wit_ruby/rest/bodyjson"

data/lib/wit_ruby/rest/bodyjson.rb

@@ -0,0 +1,136 @@
+## bodyjson.rb
+## Wrapper for JSON data that will be sent over to API
+## TODO - better seraching for specific hash
+
+module Wit
+  module REST
+    class BodyJson < OpenStruct
+
+      ## Allows for reading for values instance variable
+      attr_reader :values
+
+      ## Mainly generates instance variable to store values.
+      ##
+      ## @param possible_hash [Hash] used for OpenStruct if necessary
+      def initialize(possible_hash=nil)
+        ## Initialize instance variable for values
+        if( !possible_hash.nil? && possible_hash.has_key?("values") )
+          @values = possible_hash["values"]
+          ## Delete values from it and pass it to OpenStruct constructor
+          new_hash = possible_hash.clone
+          deleted_value = new_hash.delete("values")
+          new_hash_to_os = new_hash
+        else
+          @values = Array.new
+          new_hash_to_os = possible_hash
+        end
+        super(new_hash_to_os)
+      end
+
+      ## TODO - include metadata
+      ## Used to add value for an entity
+      ##
+      ## @param value [String] a possible value
+      ## @param args [Array] posible expressions for the given value
+      ## @return [Wit::REST::BodyJson] the current BodyJson with new value.
+      def add_value(value, *args)
+        ## Check to see if the value already exists
+        @values.each do |value_hash|
+          if value_hash["value"] == value
+            raise ValueAlreadyExists.new(%(The current value being inserted, "#{value}", already exists.))
+          end
+        end
+        ## Adds it if it isn't there with the given expressions
+        @values << {"value" => value,
+                    "expressions" => args
+                   }
+        return self
+      end
+
+      ## Used to add an expression given a value.
+      ##
+      ## @param value [String] value that will have a new expression
+      ## @param args [Array] new expressions for the value
+      ## @return [Wit::REST::BodyJson] returns self with added expression to value
+      def add_expression(value, *args)
+        ## Look for it, and insert new expressions if found.
+        ## If not found, raise error
+        @values.each do |value_hash|
+          if value_hash["value"] == value ## Found it and insert.
+            ## Set union for arrays, removes duplicates
+            value_hash["expressions"] = value_hash["expressions"] | args
+          else ## Not found and raise error
+            raise NotFound.new(%(The value, "#{value}", cannot be found.))
+          end
+        end
+
+        return self
+      end
+
+      ## Overide values to instead go into OpenStruct to work directly on the instance.
+      ##
+      ## @param newValues [Array] new values as an array.
+      def values=(newValues)
+        @values = newValues
+      end
+
+
+      ## Used to convert the current hash to JSON
+      ##
+      ## @return [String] JSON string of the hash
+      def json
+        ## Use the current to_h method and MultiJson convert it
+        MultiJson.dump(self.to_h)
+
+      end
+
+      ## Used to overide current to_h method for OpenStruct. Returns a hash
+      ## with string equivalent for symbols and adds the current instance variable
+      ## @values to it.
+      ##
+      ## @return [Hash] converted hash of the given BodyJson
+      def to_h
+        ## Use to_h on OpenStruct to get the current hash in the OpenStruct inheritance
+        ## Depending on version of ruby, to_h might not be supported, so instead use table method
+        ## to get the table instance variable
+        current_os_hash = self.table
+        ## Convert symbols to strings
+        converted_hash = current_os_hash.reduce({}) do |memo, (k, v)|
+          memo.merge({ k.to_s => v})
+        end
+
+        ## Merge values instance to this converted hash.
+        converted_hash["values"] = self.values
+
+        ## Return it.
+        return converted_hash
+      end
+
+      ## Used to properly convert the value in instance to JSON specifically for value calls.
+      ##
+      ## @return [String] JSON string of the one hash value.
+      def one_value_to_json
+        ## Array of one hash, and convert it to JSON
+        MultiJson.dump(@values[0])
+      end
+
+      ## Used to properly convert the first expression of the given value to JSON.
+      ##
+      ## @return [String] JSON string of the expression.
+      def one_expression_to_json(value_add)
+        @values.each do |value|
+          if value["value"] == value_add
+            ## Generate new hash with the given first expression and dump it.
+            expression_hash = {"expression" => value["expressions"][0]}
+            return MultiJson.dump(expression_hash)
+          end
+        end
+      end
+
+
+    end
+
+    class ValueAlreadyExists < Exception; end
+    class NotFound < Exception; end
+  end
+end

data/lib/wit_ruby/rest/client.rb

@@ -64,9 +64,14 @@ module Wit
         method_rest_class = Net::HTTP.const_get rest_method.to_s.capitalize
 
         ## Define the actual method for Wit::Session:Client
-        define_method rest_method do |path|#|path, params|
+        define_method rest_method do |path, params=nil|
           request = method_rest_class.new path, {"Authorization" => "Bearer #{@auth_token}"}
-          #request.set_form_data(params)#params if [:post, :put].include?(rest_method)
+          ## If post or put, set content-type to be JSON
+          if [:post, :put].include?(rest_method)
+            request.body = params
+            request["Content-Type"] = "application/json"
+            request["Accept"] = "application/vnd.wit.20160202+json"
+          end
           return connect_send(request)
         end
       end
@@ -88,12 +93,14 @@ module Wit
       private
 
       ## Setup the session that allows for calling of each method.
+      ##
       def setup_session
         @session = Wit::REST::Session.new(self)
       end
 
       ## Used to setup a connection using Net::HTTP object when making requests
       ## to the API.
+      ##
       def setup_conn
 
         ## Setup connection through the @conn instance variable and proxy if
@@ -109,6 +116,7 @@ module Wit
       end
 
       ## Setup SSL for the given connection in @conn.
+      ##
       def setup_ssl
         @conn.use_ssl = @params[:use_ssl]
         if @params[:ssl_verify_peer]
@@ -132,12 +140,13 @@ module Wit
         begin
           ## Save last response and depending on the response, return back the
           ## given body as a hash.
+          #binding.pry if request.method == "POST"
           response = @conn.request request
           @last_response = response
           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.code}"
+            else raise BadResponse, "response code: #{response.code} #{response.body}"
           end
 
         end
@@ -159,6 +168,8 @@ module Wit
 
     end
 
+    ## Raised when response code is not 200 or 401.
+    ##
     class BadResponse < Exception; end
   end
 end

data/lib/wit_ruby/rest/entity.rb

@@ -32,5 +32,44 @@ module Wit
       end
 
     end
+
+    ## Wrapper for array of entities as strings. Inherits from Results so it can
+    ## be refreshed.
+    ## TODO - Propagate these methods into Result
+    class EntityArray < Result
+
+      ## Generates instance variable that holds list of entities as strings in array.
+      ##
+      ## @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)
+        @entities = resultData
+      end
+
+      ## Overide that assists in calling the proper index in the array of entity strings.
+      ##
+      ## @param num [Integer] index of the array of Strings
+      ## @return [Wit::REST::Result] specific entity at the index given.
+      def [](num)
+        @entities[num]
+      end
+
+      ## Assists in going through each entity string in the instance variable.
+      ##
+      ## @return [String] lambda that provides each specific entity id.
+      def each
+        @entities.each do |entity|
+          lambda{entity}
+        end
+      end
+
+    end
+
+
   end
 end

data/lib/wit_ruby/rest/message.rb

@@ -37,8 +37,8 @@ module Wit
       ## 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.
+      ## @param possible_key [Symbol] possible method or key in the hash or entity.
+      ## @return [Class] 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]

data/lib/wit_ruby/rest/result.rb

@@ -74,8 +74,8 @@ module Wit
       ## 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.
+      ## @param possible_key [Symbol] possible method or key in the hash
+      ## @return [Class] 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

data/lib/wit_ruby/rest/session.rb

@@ -18,7 +18,7 @@ module Wit
       def send_message(message)
         ## Recieve unwrapped results
         results = @client.get("/message?q=#{message}")
-        return Message.new(results.raw_data, results.restCode, results.restPath, results.restBody)
+        return return_with_class(Wit::REST::Message, results)
       end
 
       ## POST - extract meaning from a audio file
@@ -38,7 +38,7 @@ module Wit
       def get_message(message_id)
         results = @client.get("/messages/#{message_id}")
 
-        return Message.new(results.raw_data, results.restCode, results.restPath, results.restBody)
+        return return_with_class(Wit::REST::Message, results)
       end
 
       ## GET - returns either a list of intents if no id is given.
@@ -54,7 +54,7 @@ module Wit
 
         ## 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)
+        return return_with_class(returnObject, results)
 
       end
 
@@ -65,42 +65,88 @@ module Wit
       ##     - returns the specific entity and its parameters with a given id.
       ## TODO - notify Wit.ai to fix their documentations as there is a wrong
       ##      - description.
-      def entities(entity_id = nil)
+      ## @param entity_id [String] entity id for specific retrieval
+      ## @return [Wit::REST::EntityArray] [Wit::REST::Entity] results and returned in either wrapper
+      def get_entities(entity_id = nil)
+        ## No specific id, so get list of entities
+        results = entity_id.nil? ? @client.get("/entities") : @client.get("/entities/#{entity_id}")
+
+        ## Same concept but wrap it properly if neccessary.
+        returnObject = entity_id.nil? ? EntityArray : Entity
+
+        return return_with_class(returnObject, results)
 
       end
 
       ## POST - creates a new entity with the given attributes.
+      ##
+      ## @param new_entity [Wit::REST::BodyJson] object with data to be sent over to API.
+      ## @return [Wit::REST::Result] results of the posting of the new entity.
       def create_entity(new_entity)
+        if new_entity.id.nil?
+          raise NotCorrectSchema.new("The current BodyJson object passed in does not have an \"id\" defined.")
+        end
+        return @client.post("/entities", new_entity.json)
       end
 
-      ## PUT - updates a given entity with the specific entity id.
-      def update_entity(entity_id)
+      ## TODO - notify Wit.ai to return back the updated entity results.
+      ## PUT - updates a given entity with the specific entity id and BodyJson data.
+      ##
+      ## @param entity_id [String] entity id that will be updated.
+      ## @param update_entity_data [Wit::REST::BodyJson] new data that will update the entity.
+      ## @return [Wit::REST::Result] results of updating the entity
+      def update_entity(entity_id, update_entity_data)
+        return @client.put("/entities/#{entity_id}", update_entity_data.json)
       end
 
       ## DELETE - deletes the given entity with the entity id.
+      ##
+      ## @param entity_id [String] entity id that is going to be deleted.
+      ## @return [Wit::REST::Result] results of the deletion of the entity
       def delete_entity(entity_id)
+        return @client.delete("/entities/#{entity_id}")
       end
 
       ## POST - adds the possible value into the list of values for the given
       ##      - entity with the id.
-      def add_value(entity_id, new_value)
-
+      ## TODO - restrict to only one value in BodyJson
+      ## TODO - notify wit.ai that documentation is off.
+      ##
+      ## @param new_value_with_entity [Wit::REST::BodyJson] includes the new value and entity name as ID.
+      ## @return [Wit::REST::Result] the results of the addition of the value
+      def add_value(new_value_with_entity)
+        return @client.post("/entities/#{new_value_with_entity.id}/values",  new_value_with_entity.one_value_to_json)
       end
 
       ## DELETE - deletes the value from the list of values in the entity with
       ##        - with the given value.
-      def delete_value(entity_id, delete_value)
-
+      ## @param entity_name [String] name of entity that will have value deleted
+      ## @param delete_value [String] name of value to be deleted
+      ## @return [Wit::REST::Result] results of the deletion of the value.
+      def delete_value(entity_name, delete_value)
+        return @client.delete("/entities/#{entity_name}/values/#{delete_value}")
       end
 
       ## POST - adds a new expression to the value of the entity.
-      def add_expression(entity_id, value, new_expression)
-
+      ##
+      ## @param new_expression_with_id_and_value [Wit::REST::BodyJson] includes new expression for said ID and value.
+      ## @return [Wit::REST::Result] results of the addition of the expression
+      def add_expression(new_expression_with_id_and_value)
+        ## Rename it for better reading
+        new_express = new_expression_with_id_and_value
+        ## Get the value that will had the expression inserted
+        value = new_express.values[0]["value"]
+        return @client.post("/entities/#{new_express.id}/values/#{value}/expressions", new_express.one_expression_to_json(value))
       end
 
-      ## DELETE - deleetes the expression in the value of the entity.
+      ## DELETE - deletes the expression in the value of the entity.
+      ##
+      ## @param entity_id [String] entity id that will have the expression deleted.
+      ## @param value [String] value name that will have the expression deleted.
+      ## @param expression [String] expression that will be deleted.
+      ## @return [Wit::REST::Result] results of the deletion of the given expression.
       def delete_expression(entity_id, value, expression)
-
+        return @client.delete("/entities/#{entity_id}/values/#{value}/expressions/#{expression}")
       end
 
       ## Used to refresh the results from the given results. Only applicable to result objects that directly
@@ -118,7 +164,7 @@ module Wit
           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)
+        return return_with_class(result_class, refreshed_result)
       end
 
       ## Used to refresh the last response given from the last request.
@@ -130,8 +176,23 @@ module Wit
         return @client.request_from_result(last_result.restCode, last_result.restPath, last_result.restBody)
       end
 
+      private
+      ## Used to return using the given return class and results.
+      ##
+      ## @param return_class return class for the specific method.
+      ## @param results [Wit::REST::Result] holding the specific results from client.
+      def return_with_class(return_class, results)
+        return return_class.new(results.raw_data, results.restCode, results.restPath, results.restBody)
+      end
+
     end
 
+    ## Raised when the given result object cannot be refreshed.
+    ##
     class NotRefreshable < Exception; end
+    
+    ## Raised when the given result object does not have required parameters.
+    ##
+    class NotCorrectSchema < Exception; end
   end
 end

data/lib/wit_ruby/version.rb

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

data/spec/wit_ruby/rest/bodyjson_spec.rb

@@ -0,0 +1,75 @@
+## bodyjson_spec.rb
+## Used to test class that assists in posting / putting JSON data to API
+
+require 'spec_helper'
+
+describe Wit::REST::BodyJson do
+  let(:id) {"some ID"}
+  let(:doc) {"some documentation"}
+  let(:value_1) {"some random value 1"}
+  let(:value_2) {"some random value 2"}
+  let(:express_1) {"some expression 1"}
+  let(:express_2) {"some expression 2"}
+  let(:json) {%({
+    "id": "#{id}",
+    "doc": "#{doc}",
+    "values": [
+      {
+        "value": "#{value_1}",
+        "expressions": ["#{express_1}"]
+      },
+      {
+        "value": "#{value_2}",
+        "expressions": ["#{express_2}"]
+      }
+    ]
+  }
+  )}
+  let(:eql_hash) {{"doc"=> doc,
+   "id" => id,
+   "values"=>
+    [{"value"=> value_1,
+      "expressions"=>[express_1]}, {"value" => value_2, "expressions" => [express_2]}]}}
+  let(:new_body) {Wit::REST::BodyJson.new}
+  let(:new_body_with_value) {Wit::REST::BodyJson.new({"values" => "a"})}
+  let(:new_body_with_one_value) {Wit::REST::BodyJson.new.add_value(value_1)}
+  let(:new_body_with_one_expression) {new_body_with_one_value.add_expression(value_1, express_1)}
+
+  before do
+    new_body.id = id
+    new_body.doc = doc
+    new_body.add_value(value_1)
+    new_body.add_expression(value_1, express_1)
+    new_body.add_value(value_2, express_2)
+  end
+
+  it "should have the correct values in id and doc" do
+    expect(new_body.id).to eql(id)
+    expect(new_body.doc).to eql(doc)
+  end
+
+  it "should have the right values and expressions" do
+    expect(new_body.values).to eql([{"value" => value_1, "expressions" => [express_1]}, {"value" => value_2, "expressions" => [express_2]}])
+  end
+
+  it "should be able to generate JSON" do
+    expect(new_body.json).to eql(MultiJson.dump(MultiJson.load(json)))
+  end
+
+  it "should be able to generate a hash with no symbols" do
+    expect(new_body.to_h).to eql(eql_hash)
+  end
+
+  it "should be able to remove values from the initial hash if given and be put in instance" do
+    expect(new_body_with_value.instance_variable_get("@values")).to eql("a")
+  end
+
+  it "should provide a method to provide JSON for a hash rather than array for a single value" do
+    expect(new_body_with_one_value.one_value_to_json).to eql("{\"value\":\"some random value 1\",\"expressions\":[]}")
+  end
+
+  it "should provide a method to provide JSON for the first expression of a given value" do
+    expect(new_body_with_one_expression.one_expression_to_json(value_1)).to eql(%({"expression":"#{express_1}"}))
+  end
+
+end

data/spec/wit_ruby/rest/entity_spec.rb

@@ -47,3 +47,23 @@ describe Wit::REST::MultiEntity do
   end
 
 end
+
+describe Wit::REST::EntityArray do
+  let(:json_three) {%([
+  "wit$amount_of_money",
+  "wit$contact",
+  "wit$datetime",
+  "wit$on_off",
+  "wit$phrase_to_translate",
+  "wit$temperature"
+  ])}
+  let(:entity_array) {Wit::REST::EntityArray.new(MultiJson.load(json_three))}
+
+
+  it "should be each transversable and be strings" do
+    entity_array.each do |entity_sring|
+      expect(entity_string.class).to eql(String)
+    end
+  end
+
+end

data/spec/wit_ruby/rest/session_spec.rb

@@ -10,6 +10,7 @@ describe Wit::REST::Session do
   let(:rand_hash) {{"a" => "a", "b" => "b"}}
   let(:randSession) {Wit::REST::Session.new(randClient)}
   let(:session) {Wit::REST::Client.new.session}
+  random_name = (0...10).map { ('a'..'z').to_a[rand(26)] }.join
 
 
   ## Testing for method response
@@ -34,15 +35,15 @@ describe Wit::REST::Session do
       randSession.should respond_to(:get_intents)
     end
 
-    it ".entities(entity_id = nil)" do
-      randSession.should respond_to(:entities)
+    it "get.entities(entity_id = nil)" do
+      randSession.should respond_to(:get_entities)
     end
 
     it ".create_entity(new_entity)" do
       randSession.should respond_to(:create_entity)
     end
 
-    it ".update_entity(entity_id)" do
+    it ".update_entity(entity_id, update_entity_data)" do
       randSession.should respond_to(:update_entity)
     end
 
@@ -50,7 +51,7 @@ describe Wit::REST::Session do
       randSession.should respond_to(:delete_entity)
     end
 
-    it ".add_value(entity_id, new_value)" do
+    it ".add_value(entity_name, new_value)" do
       randSession.should respond_to(:add_value)
     end
 
@@ -58,7 +59,7 @@ describe Wit::REST::Session do
       randSession.should respond_to(:delete_value)
     end
 
-    it ".add_expression(entity_id, value, new_expression)" do
+    it ".add_expression(new_expression_with_id_and_value)" do
       randSession.should respond_to(:add_expression)
     end
 
@@ -183,4 +184,191 @@ describe Wit::REST::Session do
 
   end
 
+
+  describe "getting entities" do
+    let(:get_entities) {session.get_entities}
+    let(:get_entity) {session.get_entities(get_entities[0])}
+
+    before do
+      VCR.insert_cassette 'get_entities', record: :new_episodes
+    end
+    after do
+      VCR.eject_cassette
+    end
+
+    describe "get list of entities" do
+
+        it "should return an array of used entities as strings" do
+          expect(get_entities.class).to eql(Wit::REST::EntityArray)
+          expect(get_entities[0].class).to eql(String)
+        end
+
+    end
+
+    describe "get specific entity from id" do
+
+
+      it "should return an entity class with same id" do
+        expect(get_entity.class).to eql(Wit::REST::Entity)
+        ## TODO - tell WIT.AI there documentation is wrong as they have name and id switched.
+        expect(get_entity.name).to eql(get_entities[0].split("$")[1])
+      end
+
+    end
+  end
+
+  describe "posting, deleting, updating entities" do
+    let(:json) {%({
+      "doc": "A city that I like",
+      "id": "#{random_name}",
+      "values": [
+        {
+          "value": "Paris",
+          "expressions": ["Paris", "City of Light", "Capital of France"]
+        }
+      ]
+    })}
+    let(:no_id_hash) {{"doc" => "AMAZING", "values" => [
+      {
+        "value" => "Paris",
+        "expressions" => ["Paris", "City of Light", "Capital of France"]
+      }
+    ] }}
+    let(:new_body) {Wit::REST::BodyJson.new(MultiJson.load(json))}
+    let(:no_id_body){Wit::REST::BodyJson.new(no_id_hash)}
+    let(:resulting_post) {session.create_entity(new_body)}
+    let(:resulting_post_name) {resulting_post.name}
+    let(:resulting_post_id) {resulting_post.id}
+
+
+    before do
+      VCR.insert_cassette 'post_update_delete_entity', record: :new_episodes
+    end
+    after do
+      VCR.eject_cassette
+    end
+    it "should raise error when the BodyJson does not have an ID parameter" do
+      expect{session.create_entity(no_id_body)}.to raise_error(Wit::REST::NotCorrectSchema)
+    end
+
+    it "should pass and return Result" do
+      expect(resulting_post.class).to eql(Wit::REST::Result)
+    end
+
+    describe "updating entities" do
+      let(:json_two) {%({
+        "doc": "A city that I like",
+        "values": [
+          {
+            "value": "Paris",
+            "expressions": ["Paris", "City of Light", "Capital of France"]
+          },
+          {
+              "value": "Seoul",
+              "expressions": ["Seoul", "Kimchi paradise"],
+              "metadata":"city_343"
+          }
+        ]
+      })}
+      let(:update_body) {Wit::REST::BodyJson.new(MultiJson.load(json_two))}
+      let(:resulting_update) {session.update_entity(resulting_post_name, update_body)}
+
+      it "should return a Result class" do
+        expect(resulting_update.class).to eql(Wit::REST::Result)
+      end
+    end
+
+    describe "deleting entities" do
+      let(:resulting_delete) {session.delete_entity(resulting_post_name)}
+
+      it "should pass and return Result with the same deleted id" do
+        expect(resulting_delete.class).to eql(Wit::REST::Result)
+        expect(resulting_delete.deleted).to eql(resulting_post_id)
+      end
+
+    end
+
+  end
+
+
+  describe "creating and deleting value for an entity" do
+    let(:entity_json) {
+      %({"id": "#{random_name}"})
+    }
+    let(:entity_body) {Wit::REST::BodyJson.new(MultiJson.load(entity_json))}
+    #let(:resulting_add_value) {session.add_value(@resulting_entity_name, with_value_added_body)}
+
+
+    before :each do
+      VCR.insert_cassette 'add_delete_value', record: :new_episodes
+      @resulting_entity = session.create_entity(entity_body)
+      @resulting_entity_name = @resulting_entity.name
+      @resulting_value_name = @resulting_entity_name
+      @body_for_value_insert = Wit::REST::BodyJson.new(id: @resulting_entity_name)
+      @body_with_id_and_value = @body_for_value_insert.add_value(@resulting_value_name)
+      @resulting_add_value = session.add_value(@body_with_id_and_value)
+      @resulting_delete_value = session.delete_value(@resulting_entity_name, @resulting_value_name)
+    end
+    after :each do
+      session.delete_entity(@resulting_entity_name)
+      VCR.eject_cassette
+    end
+    describe "creation" do
+      it "should return a Result class after creation" do
+        expect(@resulting_add_value.class).to eql(Wit::REST::Result)
+      end
+
+      it "should have the new value inserted" do
+        expect(@resulting_add_value.values[0]["value"]).to eql(@resulting_value_name)
+      end
+    end
+
+    describe "deletion" do
+      it "should return a Result class after deletion" do
+        expect(@resulting_delete_value.class).to eql(Wit::REST::Result)
+      end
+
+      it "should have the value deleted" do
+        expect(@resulting_delete_value.deleted).to eql(@resulting_value_name)
+      end
+    end
+  end
+
+  describe "creating and deleting expression from a value" do
+    let(:entity_body) {Wit::REST::BodyJson.new(id: random_name)}
+    before :each do
+      VCR.insert_cassette 'add_delete_expression', record: :new_episodes
+      entity_creation = session.create_entity(entity_body)
+      @entity_value_expression_name = entity_creation.name
+      session.add_value(Wit::REST::BodyJson.new(id: @entity_value_expression_name).add_value(@entity_value_expression_name))
+      @expression_creation = session.add_expression(Wit::REST::BodyJson.new(id:        @entity_value_expression_name).add_value(@entity_value_expression_name).add_expression(@entity_value_expression_name, @entity_value_expression_name))
+      @expression_deletion = session.delete_expression(@entity_value_expression_name, @entity_value_expression_name, @entity_value_expression_name)
+    end
+    after :each do
+      session.delete_value(@entity_value_expression_name, @entity_value_expression_name)
+      session.delete_entity(@entity_value_expression_name)
+      VCR.eject_cassette
+    end
+
+    describe "addition" do
+      it "should return a Result class" do
+        expect(@expression_creation.class).to eql(Wit::REST::Result)
+      end
+      it "should have the expression added" do
+        expect(@expression_creation.values[0]["expressions"][0]).to eql(@entity_value_expression_name)
+      end
+    end
+
+    describe "deletion" do
+      it "should return a Result class" do
+        expect(@expression_deletion.class).to eql(Wit::REST::Result)
+      end
+      it "should have deleted as the expression name" do
+        expect(@expression_deletion.deleted).to eql(@entity_value_expression_name)
+      end
+    end
+
+  end
+
+
 end

data/wit_ruby.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   spec.email         = ["gavinchingy@gmail.com"]
   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.homepage      = "https://github.com/gching/wit_ruby"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files`.split($/)
@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.required_ruby_version = ">= 1.8.7"
+  spec.required_ruby_version = ">= 1.9.3"
   spec.add_dependency('multi_json', '>= 1.3.0')
 
   spec.add_development_dependency "bundler", "~> 1.3"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wit_ruby
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Gavin Ching
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-15 00:00:00.000000000 Z
+date: 2014-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
@@ -210,6 +210,7 @@ files:
 - Rakefile
 - conf/cacert.pem
 - lib/wit_ruby.rb
+- lib/wit_ruby/rest/bodyjson.rb
 - lib/wit_ruby/rest/client.rb
 - lib/wit_ruby/rest/entity.rb
 - lib/wit_ruby/rest/expression.rb
@@ -219,6 +220,7 @@ files:
 - lib/wit_ruby/rest/session.rb
 - lib/wit_ruby/version.rb
 - spec/spec_helper.rb
+- spec/wit_ruby/rest/bodyjson_spec.rb
 - spec/wit_ruby/rest/client_spec.rb
 - spec/wit_ruby/rest/entity_spec.rb
 - spec/wit_ruby/rest/expression_spec.rb
@@ -227,7 +229,7 @@ files:
 - spec/wit_ruby/rest/result_spec.rb
 - spec/wit_ruby/rest/session_spec.rb
 - wit_ruby.gemspec
-homepage: ''
+homepage: https://github.com/gching/wit_ruby
 licenses:
 - MIT
 metadata: {}
@@ -239,7 +241,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.8.7
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -253,6 +255,7 @@ specification_version: 4
 summary: Provides a Ruby API wrapper with the Wit.ai API.
 test_files:
 - spec/spec_helper.rb
+- spec/wit_ruby/rest/bodyjson_spec.rb
 - spec/wit_ruby/rest/client_spec.rb
 - spec/wit_ruby/rest/entity_spec.rb
 - spec/wit_ruby/rest/expression_spec.rb
@@ -260,3 +263,4 @@ test_files:
 - spec/wit_ruby/rest/message_spec.rb
 - spec/wit_ruby/rest/result_spec.rb
 - spec/wit_ruby/rest/session_spec.rb
+has_rdoc: