languagedetection 0.3.0

data/lib/language_detection.rb

@@ -0,0 +1,161 @@
+require "httparty"
+require "hashable"
+require "language_detection/version"
+require "language_detection/detect/detect_options"
+require "language_detection/detect/detect_request"
+require "language_detection/detect/detect_response"
+require "language_detection/detect/detect_exception"
+require "language_detection/batch/batch_options"
+require "language_detection/batch/batch_request"
+require "language_detection/batch/batch_response"
+require "language_detection/batch/batch_exception"
+require "language_detection/languages/languages_options"
+require "language_detection/languages/languages_request"
+require "language_detection/languages/languages_response"
+require "language_detection/languages/languages_exception"
+
+
+module LanguageLayer
+
+  class Client
+
+    include HTTParty
+
+    base_uri 'apilayer.net/api'
+
+    def initialize(access_key)
+
+      if access_key.nil?
+        raise LanguageLayer::MissingArgumentException.new 'access_key'
+      end
+
+      @access_key = access_key
+
+    end
+
+
+    def detect(query, options = {})
+
+      if query.nil?
+        raise LanguageLayer::MissingArgumentException.new 'query'
+        return
+      end
+
+      # Create a shallow copy so we don't manipulate the original reference
+      q = options.dup
+
+      # Populate the Query
+      q.access_key = @access_key
+      q.query = query
+
+      # We then create the Request
+      req = LanguageLayer::DetectRequest.new(q)
+
+      #  We create a Hash of the request so we can send it via HTTP
+      req_dto = req.to_dh
+
+      begin
+
+        # We make the actual request
+        res = self.class.get('/detect', req_dto)
+
+        # We ensure that we tap the response so we can use the results
+        res.inspect
+
+        if (!res[LanguageLayer::DetectResponse::SUCCESS_EXPR])
+          raise LanguageLayer::DetectException.new res[LanguageLayer::DetectResponse::ERROR_EXPR]
+        end
+
+        # We just return the parsed binary response
+        return res.parsed_response
+
+      rescue => e
+        puts e.inspect
+        return
+
+      end
+    end
+
+
+    def batch(query, options = {})
+
+      if query.nil?
+        raise LanguageLayer::MissingArgumentException.new 'query'
+        return
+      end
+
+      # Create a shallow copy so we don't manipulate the original reference
+      q = options.dup
+
+      # Populate the Query
+      q.access_key = @access_key
+      q.query = query
+
+      # We then create the Request
+      req = LanguageLayer::BatchRequest.new(q)
+
+      #  We create a Hash of the request so we can send it via HTTP
+      req_dto = req.to_dh
+
+      begin
+
+        # We make the actual request
+        res = self.class.get('/batch', req_dto)
+
+        # We ensure that we tap the response so we can use the results
+        res.inspect
+
+        if (!res[LanguageLayer::BatchResponse::SUCCESS_EXPR])
+          raise LanguageLayer::BatchException.new res[LanguageLayer::BatchResponse::ERROR_EXPR]
+        end
+
+        # We just return the parsed binary response
+        return res.parsed_response
+
+      rescue => e
+        puts e.inspect
+        return
+
+      end
+    end
+
+
+    def languages(options = {})
+
+      # Create a shallow copy so we don't manipulate the original reference
+      q = options.dup
+
+      # Populate the Query
+      q.access_key = @access_key
+
+      # We then create the Request
+      req = LanguageLayer::LanguagesRequest.new(q)
+
+      #  We create a Hash of the request so we can send it via HTTP
+      req_dto = req.to_dh
+
+      begin
+
+        # We make the actual request
+        res = self.class.get('/languages', req_dto)
+
+        # We ensure that we tap the response so we can use the results
+        res.inspect
+
+        if (!res[LanguageLayer::LanguagesResponse::SUCCESS_EXPR])
+          raise LanguageLayer::LanguagesException.new res[LanguageLayer::LanguagesResponse::ERROR_EXPR]
+        end
+
+        # We just return the parsed binary response
+        return res.parsed_response
+
+      rescue => e
+        puts e.inspect
+        return
+
+      end
+    end
+
+  end
+
+end

data/out/production/language_detection/language_detection/batch/batch_exception.rb

@@ -0,0 +1,15 @@
+require "language_detection/version"
+
+module LanguageLayer
+
+  class BatchException < Exception
+
+    attr_accessor :error
+
+    def initialize(error)
+      self.error = error
+    end
+
+  end
+
+end

data/out/production/language_detection/language_detection/batch/batch_options.rb

@@ -0,0 +1,19 @@
+require "language_detection/version"
+
+module LanguageLayer
+
+  class BatchOptions
+
+    include Hashable
+
+    attr_accessor :access_key
+
+    attr_accessor :query
+
+    def initialize()
+      @query = nil
+    end
+
+  end
+
+end

data/out/production/language_detection/language_detection/batch/batch_request.rb

@@ -0,0 +1,16 @@
+require "hashable"
+
+module LanguageLayer
+
+  class BatchRequest
+
+    include Hashable
+
+    attr_accessor :query
+
+    def initialize(query = {})
+      self.query = query;
+    end
+
+  end
+end

data/out/production/language_detection/language_detection/batch/batch_response.rb

@@ -0,0 +1,17 @@
+require "language_detection/version"
+
+module LanguageLayer
+
+  class BatchResponse
+
+    SUCCESS_EXPR = 'success'
+    ERROR_EXPR = 'error'
+
+    def bar
+      SUCCESS_EXPR
+      ERROR_EXPR
+    end
+
+  end
+
+end

data/out/production/language_detection/language_detection/detect/detect_exception.rb

@@ -0,0 +1,15 @@
+require "language_detection/version"
+
+module LanguageLayer
+
+  class DetectException < Exception
+
+    attr_accessor :error
+
+    def initialize(error)
+      self.error = error
+    end
+
+  end
+
+end

data/out/production/language_detection/language_detection/detect/detect_options.rb

@@ -0,0 +1,20 @@
+require "language_detection/version"
+
+module LanguageLayer
+
+  class DetectOptions
+
+    include Hashable
+
+    attr_accessor :access_key
+
+    attr_accessor :query
+
+
+    def initialize()
+      @query = nil
+    end
+
+  end
+
+end

data/out/production/language_detection/language_detection/detect/detect_request.rb

@@ -0,0 +1,16 @@
+require "hashable"
+
+module LanguageLayer
+
+  class DetectRequest
+
+    include Hashable
+
+    attr_accessor :query
+
+    def initialize(query = {})
+      self.query = query;
+    end
+
+  end
+end

data/out/production/language_detection/language_detection/detect/detect_response.rb

@@ -0,0 +1,17 @@
+require "language_detection/version"
+
+module LanguageLayer
+
+  class DetectResponse
+
+    SUCCESS_EXPR = 'success'
+    ERROR_EXPR = 'error'
+
+    def bar
+      SUCCESS_EXPR
+      ERROR_EXPR
+    end
+
+  end
+
+end

data/out/production/language_detection/language_detection/languages/languages_exception.rb

@@ -0,0 +1,15 @@
+require "language_detection/version"
+
+module LanguageLayer
+
+  class LanguagesException < Exception
+
+    attr_accessor :error
+
+    def initialize(error)
+      self.error = error
+    end
+
+  end
+
+end

data/out/production/language_detection/language_detection/languages/languages_options.rb

@@ -0,0 +1,16 @@
+require "language_detection/version"
+
+module LanguageLayer
+
+  class LanguagesOptions
+
+    include Hashable
+
+    attr_accessor :access_key
+
+    def initialize()
+    end
+
+  end
+
+end

data/out/production/language_detection/language_detection/languages/languages_request.rb

@@ -0,0 +1,16 @@
+require "hashable"
+
+module LanguageLayer
+
+  class LanguagesRequest
+
+    include Hashable
+
+    attr_accessor :query
+
+    def initialize(query = {})
+      self.query = query;
+    end
+
+  end
+end

data/out/production/language_detection/language_detection/languages/languages_response.rb

@@ -0,0 +1,15 @@
+require "language_detection/version"
+
+module LanguageLayer
+
+  class LanguagesResponse
+
+    SUCCESS_EXPR = 'success'
+
+    def bar
+      SUCCESS_EXPR
+    end
+
+  end
+
+end

data/out/production/language_detection/language_detection/missing_argument_exception.rb

@@ -0,0 +1,13 @@
+module LanguageLayer
+
+  class MissingArgumentException < Exception
+
+    attr_accessor :argument
+
+    def initialize(argument)
+      self.argument = argument
+    end
+
+  end
+
+end

data/out/production/language_detection/language_detection/version.rb

@@ -0,0 +1,3 @@
+module LanguageLayer
+  VERSION = "0.1.0"
+end

data/out/production/language_detection/language_detection.rb

@@ -0,0 +1,161 @@
+require "httparty"
+require "hashable"
+require "language_detection/version"
+require "language_detection/detect/detect_options"
+require "language_detection/detect/detect_request"
+require "language_detection/detect/detect_response"
+require "language_detection/detect/detect_exception"
+require "language_detection/batch/batch_options"
+require "language_detection/batch/batch_request"
+require "language_detection/batch/batch_response"
+require "language_detection/batch/batch_exception"
+require "language_detection/languages/languages_options"
+require "language_detection/languages/languages_request"
+require "language_detection/languages/languages_response"
+require "language_detection/languages/languages_exception"
+
+
+module LanguageLayer
+
+  class Client
+
+    include HTTParty
+
+    base_uri 'apilayer.net/api'
+
+    def initialize(access_key)
+
+      if access_key.nil?
+        raise LanguageLayer::MissingArgumentException.new 'access_key'
+      end
+
+      @access_key = access_key
+
+    end
+
+
+    def detect(query, options = {})
+
+      if query.nil?
+        raise LanguageLayer::MissingArgumentException.new 'query'
+        return
+      end
+
+      # Create a shallow copy so we don't manipulate the original reference
+      q = options.dup
+
+      # Populate the Query
+      q.access_key = @access_key
+      q.query = query
+
+      # We then create the Request
+      req = LanguageLayer::DetectRequest.new(q)
+
+      #  We create a Hash of the request so we can send it via HTTP
+      req_dto = req.to_dh
+
+      begin
+
+        # We make the actual request
+        res = self.class.get('/detect', req_dto)
+
+        # We ensure that we tap the response so we can use the results
+        res.inspect
+
+        if (!res[LanguageLayer::DetectResponse::SUCCESS_EXPR])
+          raise LanguageLayer::DetectException.new res[LanguageLayer::DetectResponse::ERROR_EXPR]
+        end
+
+        # We just return the parsed binary response
+        return res.parsed_response
+
+      rescue => e
+        puts e.inspect
+        return
+
+      end
+    end
+
+
+    def batch(query, options = {})
+
+      if query.nil?
+        raise LanguageLayer::MissingArgumentException.new 'query'
+        return
+      end
+
+      # Create a shallow copy so we don't manipulate the original reference
+      q = options.dup
+
+      # Populate the Query
+      q.access_key = @access_key
+      q.query = query
+
+      # We then create the Request
+      req = LanguageLayer::BatchRequest.new(q)
+
+      #  We create a Hash of the request so we can send it via HTTP
+      req_dto = req.to_dh
+
+      begin
+
+        # We make the actual request
+        res = self.class.get('/batch', req_dto)
+
+        # We ensure that we tap the response so we can use the results
+        res.inspect
+
+        if (!res[LanguageLayer::BatchResponse::SUCCESS_EXPR])
+          raise LanguageLayer::BatchException.new res[LanguageLayer::BatchResponse::ERROR_EXPR]
+        end
+
+        # We just return the parsed binary response
+        return res.parsed_response
+
+      rescue => e
+        puts e.inspect
+        return
+
+      end
+    end
+
+
+    def languages(options = {})
+
+      # Create a shallow copy so we don't manipulate the original reference
+      q = options.dup
+
+      # Populate the Query
+      q.access_key = @access_key
+
+      # We then create the Request
+      req = LanguageLayer::LanguagesRequest.new(q)
+
+      #  We create a Hash of the request so we can send it via HTTP
+      req_dto = req.to_dh
+
+      begin
+
+        # We make the actual request
+        res = self.class.get('/languages', req_dto)
+
+        # We ensure that we tap the response so we can use the results
+        res.inspect
+
+        if (!res[LanguageLayer::LanguagesResponse::SUCCESS_EXPR])
+          raise LanguageLayer::LanguagesException.new res[LanguageLayer::LanguagesResponse::ERROR_EXPR]
+        end
+
+        # We just return the parsed binary response
+        return res.parsed_response
+
+      rescue => e
+        puts e.inspect
+        return
+
+      end
+    end
+
+  end
+
+end

data/out/test/language_detection/language_detection_spec.rb

@@ -0,0 +1,99 @@
+require 'dotenv'
+require 'spec_helper'
+require 'language_detection'
+
+
+# Load Environment Variables
+Dotenv.load
+
+
+describe LanguageLayer do
+
+
+  it 'has a version number' do
+    expect(LanguageLayer::VERSION).not_to be nil
+  end
+
+
+  it 'detect (simple)' do
+
+    begin
+
+      # Declare the Client instance passing in the authentication parameters
+      @client = LanguageLayer::Client.new(ENV['ACCESS_KEY'])
+
+      # Set the query to detect
+      query = 'I like apples & oranges.'
+
+      # We declare the options
+      options = LanguageLayer::DetectOptions.new()
+
+      # We make the call to detect
+      response = @client.detect(query, options)
+
+      # First we check the response
+      expect(response).not_to be nil
+
+    rescue => e
+      puts e.inspect
+
+    end
+
+  end
+
+  it 'detect (batch)' do
+
+    begin
+
+      # Declare the Client instance passing in the authentication parameters
+      @client = LanguageLayer::Client.new(ENV['ACCESS_KEY'])
+
+      # Set the query to detect
+      query = [
+          'I like apples & oranges.'
+      ]
+
+      # We declare the options
+      options = LanguageLayer::BatchOptions.new()
+
+      # We make the call to detect
+      response = @client.batch(query, options)
+
+      # First we check the response
+      expect(response).not_to be nil
+
+    rescue => e
+      puts e.inspect
+
+    end
+
+  end
+
+  it 'languages' do
+
+    begin
+
+      # Declare the Client instance passing in the authentication parameters
+      @client = LanguageLayer::Client.new(ENV['ACCESS_KEY'])
+
+      # We declare the options
+      options = LanguageLayer::LanguagesOptions.new()
+
+      # We make the call to languages
+      response = @client.languages(options)
+
+      # First we check the response
+      expect(response).not_to be nil
+
+    rescue => e
+      puts e.inspect
+
+    end
+
+  end
+
+end
+
+
+
+

data/out/test/language_detection/spec_helper.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'language_detection'