wit_ruby 0.0.1

data/lib/wit_ruby/rest/client.rb

@@ -0,0 +1,143 @@
+## client.rb
+## Facilitates the secure connection between the Wit servers and ruby application.
+## Quite confusing as Net::HTTP and Net::HTTPs is a messy library.
+## Do look it up if you need more help understanding!
+
+module Wit
+  module REST
+    ## 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
+    ##
+    class Client
+
+      ## Default settings for the client connection to the Wit api.
+      DEFAULTS = {
+          :token => ENV["WIT_AI_TOKEN"],
+          :addr => 'api.wit.ai',
+          :port => 443,
+          :use_ssl => true,
+          :ssl_verify_peer => true,
+          :ssl_ca_file => File.dirname(__FILE__) + '/../../../conf/cacert.pem',
+          :timeout => 30,
+          :proxy_addr => nil,
+          :proxy_port => nil,
+          :proxy_user => nil,
+          :proxy_pass => nil,
+          :retry_limit => 1,
+      }
+
+      ## 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.
+      def initialize(options = {})
+        ## Token is overidden if given in set params.
+        @params = DEFAULTS.merge options
+        @auth_token = @params[:token].strip
+        setup_conn
+        setup_session
+      end
+
+
+      ## Change the given auth token.
+      def change_auth(new_auth)
+        @auth_token = new_auth.strip
+      end
+
+      ## Defines each REST method for the given client. GET, PUT, POST and DELETE
+      [: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
+
+        ## Define the actual method for Wit::Session:Client
+        define_method rest_method do |path|#|path, params|
+          request = method_rest_class.new path, {"Authorization" => "Bearer #{@auth_token}"}
+          #request.set_form_data(params)#params if [:post, :put].include?(rest_method)
+          return connect_send(request)
+        end
+      end
+
+      ## Takes in a body and path and creates a net/http class and uses it to call a request to API
+      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}"}
+        refresh_request.set_form_data(body) unless body == nil
+        ## Connect and send it to the API server.
+        return connect_send(refresh_request)
+      end
+
+#################################
+      private
+
+      ## Setup the session that allows for calling of
+      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
+        ## if given.
+        @conn = Net::HTTP.new(@params[:addr], @params[:port],
+          @params[:proxy_addr], @params[:proxy_port],
+          @params[:proxy_user], @params[:proxy_pass]
+          )
+        setup_ssl
+        ## Set timeouts
+        @conn.open_timeout = @params[:timeout]
+        @conn.read_timeout = @params[:timeout]
+      end
+
+      ## Setup SSL for the given connection in @conn.
+      def setup_ssl
+        @conn.use_ssl = @params[:use_ssl]
+        if @params[:ssl_verify_peer]
+          @conn.verify_mode = OpenSSL::SSL::VERIFY_PEER
+          @conn.ca_file = @params[:ssl_ca_file]
+        else
+          @conn.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
+      end
+
+      ## Connect and send the given request to Wit server.
+      def connect_send(request)
+        ## Set the last request parameter
+        @last_req = request
+        ## Set the retries if necessary to send again.
+        left_retries = @params[:retry_limit]
+        ## Start sending request
+        begin
+          ## Save last response and depending on the response, return back the
+          ## given body as a hash.
+          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.status}"
+          end
+
+        end
+      end
+      
+      ## Save it into the instance last_result and return it.
+      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
+      end
+
+
+    end
+  end
+end

data/lib/wit_ruby/rest/result.rb

@@ -0,0 +1,49 @@
+## result.rb
+## Specifies class that handles the results given from each RESTful API call.
+
+
+module Wit
+  module REST
+    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
+
+    ## Returns the orginalHash instance variable.
+    def hash
+      return @originalHash
+    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 request's path
+    def path
+      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
+
+
+
+    end
+  end
+end

data/lib/wit_ruby/rest/session.rb

@@ -0,0 +1,94 @@
+## session.rb
+## Handles all the neccesary methods to do certain API RESTful calls.
+## Documentation from Wit for these methods - https://wit.ai/docs/api
+
+module Wit
+  module REST
+    class Session
+      ## Initialize with the given client.
+      def initialize(client)
+        @client = client
+      end
+      ## GET - extracted meaning form a sentence
+      def send_message(message)
+         return @client.get("/message?q=#{message}")
+      end
+
+      ## POST - extract meaning from a audio file
+      ## Do check the certain documentation of what the specific audio file
+      ## should be.
+      def send_sound_message(sound)
+      end
+
+      ## GET - returns stored message for specific id.
+      ## TODO - possibly renaming as it is ambigious compared to send_message.
+      def get_message(message_id)
+
+      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)
+      end
+
+      ## TODO - look into corpus
+
+      ## GET - returns a list of available entities given this instance with the
+      ##       given token if no id is given.
+      ##     - 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)
+
+      end
+
+      ## POST - creates a new entity with the given attributes.
+      def create_entity(new_entity)
+      end
+
+      ## PUT - updates a given entity with the specific entity id.
+      def update_entity(entity_id)
+      end
+
+      ## DELETE - deletes the given entity with the entity id.
+      def delete_entity(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)
+
+      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)
+
+      end
+
+      ## POST - adds a new expression to the value of the entity.
+      def add_expression(entity_id, value, new_expression)
+
+      end
+
+      ## DELETE - deleetes the expression in the value of the entity.
+      def delete_expression(entity_id, value, expression)
+
+      end
+
+      ## Used to refresh the results from the given results.
+      def refresh_results(result)
+        ## Call client with refresh results method
+        return @client.request_from_result(result.restCode, result.path, result.body)
+      end
+
+      ## Used to refresh the last response given from the last request.
+      def refresh_last
+        last_result = @client.last_result
+        return @client.request_from_result(last_result.restCode, last_result.path, last_result.body)
+      end
+
+
+    end
+  end
+end

data/lib/wit_ruby/version.rb

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

data/lib/wit_ruby.rb

@@ -0,0 +1,9 @@
+require 'net/http'
+require 'net/https'
+require 'multi_json'
+
+
+require "wit_ruby/version"
+require "wit_ruby/rest/client"
+require "wit_ruby/rest/session"
+require "wit_ruby/rest/result"

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+
+require 'coveralls'
+Coveralls.wear!
+
+require 'wit_ruby'
+require 'pry'
+
+require 'webmock/rspec'
+require 'vcr'
+
+#VCR config
+VCR.configure do |c|
+  c.cassette_library_dir = 'spec/fixtures/wit_cassettes'
+  c.hook_into :webmock
+end

data/spec/wit_ruby/rest/client_spec.rb

@@ -0,0 +1,63 @@
+## client_spec.rb
+## Test the functionalities of lib/wit_ruby/rest/client.rb
+
+require 'spec_helper'
+
+describe Wit::REST::Client do
+  let(:rand_auth) {"someAuth"}
+  let(:another_auth)  {"someOtherAuth"}
+  let(:new_host) {"api.fakewit.ai"}
+  let(:new_port) {132}
+  let(:new_proxy) {"localhost"}
+  let(:new_proxy_port) {241}
+  let(:new_timeout) {rand(30)}
+  let(:new_ssl_path) {"some/ssl/path"}
+
+  it "should create a new client instance given some auth token" do
+    #pending("Need to instantiate the given client with a given token.")
+    @client = Wit::REST::Client.new(token: rand_auth)
+    expect(@client.instance_variable_get("@auth_token")).to  eql(rand_auth)
+  end
+
+  it "should have the proper default connection parameters" do
+    @client = Wit::REST::Client.new(token: rand_auth)
+    @conn = @client.instance_variable_get("@conn")
+    expect(@conn.address).to  eql("api.wit.ai")
+    expect(@conn.use_ssl?).to be_true
+
+  end
+
+  it "should allow the change of the current instance's auth token" do
+    #pending("Change the instance auth token to another")
+    @client = Wit::REST::Client.new(token: rand_auth)
+    @client.change_auth(another_auth)
+    expect(@client.instance_variable_get("@auth_token")).to eql(another_auth)
+  end
+
+  it "should allow for change of the default options and accept proxy" do
+    @client = Wit::REST::Client.new(token: rand_auth, addr: new_host,
+      port: new_port, ssl_ca_file: new_ssl_path, timeout: new_timeout,
+      proxy_addr: new_proxy, proxy_port: new_proxy_port)
+    @conn = @client.instance_variable_get("@conn")
+    expect(@conn.address).to eql(new_host)
+    expect(@conn.port).to eql(new_port)
+    expect(@conn.proxy?).to be_true
+    expect(@conn.proxy_address).to eql(new_proxy)
+    expect(@conn.proxy_port).to eql(new_proxy_port)
+    expect(@conn.open_timeout).to eql(new_timeout)
+    expect(@conn.read_timeout).to eql(new_timeout)
+    expect(@conn.ca_file).to eql(new_ssl_path)
+
+  end
+
+  it "should setup a session parameter to properly wrap API with commands" do
+    @client = Wit::REST::Client.new(token: rand_auth)
+    expect(@client.instance_variable_get("@session")).to be_true
+  end
+
+
+  it "should be able to do an API call when given a result object" do
+    @client = Wit::REST::Client.new(token: rand_auth)
+    expect(@client).to respond_to(:request_from_result)
+  end
+end

data/spec/wit_ruby/rest/result_spec.rb

@@ -0,0 +1,38 @@
+## result_spec.rb
+## Tests functionalities of lib/wit_ruby/rest/result.rb
+require 'spec_helper'
+
+describe Wit::REST::Result do
+  let(:randHash) {{"a" => "a", "b" => "b"}}
+  let(:rand_path) {"rand_path"}
+  let(:rand_body) {"rand_body"}
+  let(:rest_code) {"post"}
+  let(:result) {Wit::REST::Result.new(randHash, rest_code, rand_path, rand_body)}
+
+
+  it "should have an instance of the original hash" do
+    expect(result.hash).to eql(randHash)
+  end
+
+  it "should raise an error for a method that is not in the attributes of the hash" do
+    expect{result.random_method}.to raise_error(NoMethodError)
+  end
+
+  it ".method_missing(name, *args, &block" do
+    expect(result).to respond_to(:method_missing)
+  end
+
+  it "should not raise any errors for the given keys in a hash" do
+    randHash.each_key do |key|
+      expect{result.send(key)}.not_to raise_error
+    end
+  end
+
+
+  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)
+  end
+
+end

data/spec/wit_ruby/rest/session_spec.rb

@@ -0,0 +1,120 @@
+## session_spec.rb
+## Used to test lib/wit_ruby/rest/session_spec.rb
+
+require 'spec_helper'
+
+describe Wit::REST::Session do
+  let(:auth) {"randomAuth"}
+  let(:randClient) {"randomClient"}
+  let(:message) {"Hi"}
+  let(:randSession) {Wit::REST::Session.new(randClient)}
+  let(:session) {Wit::REST::Client.new.session}
+
+
+  ## Testing for method response
+  describe "Default attributes and method definitions" do
+    it "should have a client instance variable" do
+      randSession.instance_variable_get("@client").should be_eql randClient
+    end
+
+    it '.send_message(message)' do
+      randSession.should respond_to(:send_message)
+    end
+
+    it ".send_sound_message(soundwave)" do
+      randSession.should respond_to(:send_sound_message)
+    end
+
+    it ".get_message(message_id)" do
+      randSession.should respond_to(:get_message)
+    end
+
+    it "get_intent(intent_id = nil)" do
+      randSession.should respond_to(:get_intent)
+    end
+
+    it ".entities(entity_id = nil)" do
+      randSession.should respond_to(:entities)
+    end
+
+    it ".create_entity(new_entity)" do
+      randSession.should respond_to(:create_entity)
+    end
+
+    it ".update_entity(entity_id)" do
+      randSession.should respond_to(:update_entity)
+    end
+
+    it ".delete_entity(entity_id)" do
+      randSession.should respond_to(:delete_entity)
+    end
+
+    it ".add_value(entity_id, new_value)" do
+      randSession.should respond_to(:add_value)
+    end
+
+    it ".delete_value(entity_id, delete_value)" do
+      randSession.should respond_to(:delete_value)
+    end
+
+    it ".add_expression(entity_id, value, new_expression)" do
+      randSession.should respond_to(:add_expression)
+    end
+
+    it ".delete_expression(entity_id, value, expression)" do
+      randSession.should respond_to(:delete_expression)
+    end
+  end
+
+
+
+################# Functionalities with API mockup ###########################
+
+  describe "Sending message" do
+    let(:result) {session.send_message(message)}
+    let(:result_hash){result.hash}
+
+    before do
+      VCR.insert_cassette 'message', record: :new_episodes
+    end
+    after do
+      VCR.eject_cassette
+    end
+
+    it "should return an object of class Result" do
+      expect(result.class).to eql(Wit::REST::Result)
+    end
+
+    it "should have a message id method" do
+      expect(result.msg_id).to eql(result.hash["msg_id"])
+    end
+
+
+
+
+    describe "caching" do
+      ## Use webmock to disable the network connection after the api request
+      ## We use the simple sending message method for testing.
+      before do
+        @results = session.send_message(message)
+        stub_request(:any, /api.wit.ai/).to_timeout
+      end
+
+
+
+        it "must be able refresh and resend the call to the API given the result class" do
+          expect{session.refresh_results(@results)}.to raise_error(Timeout::Error)
+        end
+
+        it "should be able to refresh the last result" do
+          expect{session.refresh_last}.to raise_error(Timeout::Error)
+        end
+
+
+
+    end
+
+  end
+
+
+end

data/wit_ruby.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'wit_ruby/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "wit_ruby"
+  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.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  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 "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rspec-nc"
+  spec.add_development_dependency "guard"
+  spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "pry-remote"
+  spec.add_development_dependency "pry-nav"
+  spec.add_development_dependency "coveralls"
+  spec.add_development_dependency "webmock"
+  spec.add_development_dependency "vcr"
+end