oxford_dictionary 1.0.1 → 1.2.0

data/fixtures/vcr_cassettes/lemmas_lemma-es.yml

@@ -0,0 +1,95 @@
+---
+http_interactions:
+- request:
+    method: get
+    uri: https://od-api.oxforddictionaries.com/api/v2/lemmas/es/fuego
+    body:
+      encoding: US-ASCII
+      string: ''
+    headers:
+      Accept-Encoding:
+      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
+      Accept:
+      - application/json
+      User-Agent:
+      - Ruby
+      Host:
+      - od-api.oxforddictionaries.com
+      App-Id:
+      - APP_ID
+      App-Key:
+      - APP_KEY
+  response:
+    status:
+      code: 200
+      message: OK
+    headers:
+      Api-Version:
+      - v2
+      Code-Version:
+      - v2.3.2-g02aa52c
+      Content-Type:
+      - application/json;charset=utf-8
+      Date:
+      - Sat, 22 Jun 2019 23:43:20 GMT
+      Server:
+      - openresty/1.13.6.2
+      Content-Length:
+      - '1429'
+      Connection:
+      - keep-alive
+    body:
+      encoding: UTF-8
+      string: |-
+        {
+            "metadata": {
+                "provider": "Oxford University Press"
+            },
+            "results": [
+                {
+                    "id": "fuego",
+                    "language": "es",
+                    "lexicalEntries": [
+                        {
+                            "grammaticalFeatures": [
+                                {
+                                    "id": "masculine",
+                                    "text": "Masculine",
+                                    "type": "Gender"
+                                }
+                            ],
+                            "inflectionOf": [
+                                {
+                                    "id": "fuego",
+                                    "text": "fuego"
+                                }
+                            ],
+                            "language": "es",
+                            "lexicalCategory": {
+                                "id": "noun",
+                                "text": "Noun"
+                            },
+                            "text": "fuego"
+                        },
+                        {
+                            "inflectionOf": [
+                                {
+                                    "id": "fuego",
+                                    "text": "fuego"
+                                }
+                            ],
+                            "language": "es",
+                            "lexicalCategory": {
+                                "id": "interjection",
+                                "text": "Interjection"
+                            },
+                            "text": "fuego"
+                        }
+                    ],
+                    "word": "fuego"
+                }
+            ]
+        }
+    http_version: 
+  recorded_at: Sat, 22 Jun 2019 23:43:20 GMT
+recorded_with: VCR 4.0.0

data/fixtures/vcr_cassettes/lemmas_lemma-verbs.yml

@@ -0,0 +1,81 @@
+---
+http_interactions:
+- request:
+    method: get
+    uri: https://od-api.oxforddictionaries.com/api/v2/lemmas/en/ace?lexicalCategory=verb
+    body:
+      encoding: US-ASCII
+      string: ''
+    headers:
+      Accept-Encoding:
+      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
+      Accept:
+      - application/json
+      User-Agent:
+      - Ruby
+      Host:
+      - od-api.oxforddictionaries.com
+      App-Id:
+      - APP_ID
+      App-Key:
+      - APP_KEY
+  response:
+    status:
+      code: 200
+      message: OK
+    headers:
+      Api-Version:
+      - v2
+      Code-Version:
+      - v2.3.2-g02aa52c
+      Content-Type:
+      - application/json;charset=utf-8
+      Date:
+      - Sat, 22 Jun 2019 23:43:19 GMT
+      Server:
+      - openresty/1.13.6.2
+      Content-Length:
+      - '964'
+      Connection:
+      - keep-alive
+    body:
+      encoding: UTF-8
+      string: |-
+        {
+            "metadata": {
+                "provider": "Oxford University Press"
+            },
+            "results": [
+                {
+                    "id": "ace",
+                    "language": "en",
+                    "lexicalEntries": [
+                        {
+                            "grammaticalFeatures": [
+                                {
+                                    "id": "transitive",
+                                    "text": "Transitive",
+                                    "type": "Subcategorization"
+                                }
+                            ],
+                            "inflectionOf": [
+                                {
+                                    "id": "ace",
+                                    "text": "ace"
+                                }
+                            ],
+                            "language": "en",
+                            "lexicalCategory": {
+                                "id": "verb",
+                                "text": "Verb"
+                            },
+                            "text": "ace"
+                        }
+                    ],
+                    "word": "ace"
+                }
+            ]
+        }
+    http_version: 
+  recorded_at: Sat, 22 Jun 2019 23:43:19 GMT
+recorded_with: VCR 4.0.0

data/fixtures/vcr_cassettes/lemmas_lemma.yml

@@ -0,0 +1,109 @@
+---
+http_interactions:
+- request:
+    method: get
+    uri: https://od-api.oxforddictionaries.com/api/v2/lemmas/en/ace
+    body:
+      encoding: US-ASCII
+      string: ''
+    headers:
+      Accept-Encoding:
+      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
+      Accept:
+      - application/json
+      User-Agent:
+      - Ruby
+      Host:
+      - od-api.oxforddictionaries.com
+      App-Id:
+      - APP_ID
+      App-Key:
+      - APP_KEY
+  response:
+    status:
+      code: 200
+      message: OK
+    headers:
+      Api-Version:
+      - v2
+      Code-Version:
+      - v2.3.2-g02aa52c
+      Content-Type:
+      - application/json;charset=utf-8
+      Date:
+      - Sat, 22 Jun 2019 23:42:51 GMT
+      Server:
+      - openresty/1.13.6.2
+      Content-Length:
+      - '1866'
+      Connection:
+      - keep-alive
+    body:
+      encoding: UTF-8
+      string: |-
+        {
+            "metadata": {
+                "provider": "Oxford University Press"
+            },
+            "results": [
+                {
+                    "id": "ace",
+                    "language": "en",
+                    "lexicalEntries": [
+                        {
+                            "inflectionOf": [
+                                {
+                                    "id": "ace",
+                                    "text": "ace"
+                                }
+                            ],
+                            "language": "en",
+                            "lexicalCategory": {
+                                "id": "noun",
+                                "text": "Noun"
+                            },
+                            "text": "ace"
+                        },
+                        {
+                            "inflectionOf": [
+                                {
+                                    "id": "ace",
+                                    "text": "ace"
+                                }
+                            ],
+                            "language": "en",
+                            "lexicalCategory": {
+                                "id": "adjective",
+                                "text": "Adjective"
+                            },
+                            "text": "ace"
+                        },
+                        {
+                            "grammaticalFeatures": [
+                                {
+                                    "id": "transitive",
+                                    "text": "Transitive",
+                                    "type": "Subcategorization"
+                                }
+                            ],
+                            "inflectionOf": [
+                                {
+                                    "id": "ace",
+                                    "text": "ace"
+                                }
+                            ],
+                            "language": "en",
+                            "lexicalCategory": {
+                                "id": "verb",
+                                "text": "Verb"
+                            },
+                            "text": "ace"
+                        }
+                    ],
+                    "word": "ace"
+                }
+            ]
+        }
+    http_version: 
+  recorded_at: Sat, 22 Jun 2019 23:42:51 GMT
+recorded_with: VCR 4.0.0

data/lib/oxford_dictionary/client.rb

@@ -3,6 +3,9 @@ require 'oxford_dictionary/endpoints/inflection_endpoint'
 require 'oxford_dictionary/endpoints/search_endpoint'
 require 'oxford_dictionary/endpoints/wordlist_endpoint'
 
+require 'oxford_dictionary/endpoints/entries'
+require 'oxford_dictionary/endpoints/lemmas'
+
 module OxfordDictionary
   # The client object to interact with
   class Client
@@ -21,5 +24,53 @@ module OxfordDictionary
         instance_variable_set("@#{key}", value)
       end
     end
+
+    def entry(*args)
+      if args.first.is_a?(Hash)
+        args = args.first
+          entry_endpoint.entry(
+            word: args[:word],
+            dataset: args[:dataset],
+            params: args[:params]
+          )
+      else
+        warn '''
+          The V1 interface for this library is DEPRECATED and will become
+          non-functional on June 30, 2019. Use the new V2 interface for this
+          method instead. Reference github.com/swcraig/oxford-dictionary/pull/8
+          for more information. Specifically check out
+          OxfordDictionary::Endpoints::Entries#entry for the new interface.
+        '''
+        # Support V1 behaviour
+        super(*args)
+      end
+    end
+
+    def entry_snake_case(word:, dataset:, params: {})
+      warn 'Client#entry_snake_case is DEPRECATED. Use Client#entry instead.'
+      entry_endpoint.
+        entry_snake_case(word: word, dataset: dataset, params: params)
+    end
+
+    def lemma(word:, language:, params: {})
+      lemma_endpoint.lemma(word: word, language: language, params: params)
+    end
+
+    private
+
+    def lemma_endpoint
+      @lemma_endpoint ||=
+        OxfordDictionary::Endpoints::Lemmas.new(request_client: request_client)
+    end
+
+    def entry_endpoint
+      @entry_endpoint ||=
+        OxfordDictionary::Endpoints::Entries.new(request_client: request_client)
+    end
+
+    def request_client
+      @request_client ||=
+        OxfordDictionary::Request.new(app_id: @app_id, app_key: @app_key)
+    end
   end
 end

data/lib/oxford_dictionary/deprecated_request.rb

@@ -0,0 +1,127 @@
+require 'json'
+require 'net/http'
+require 'plissken'
+require 'oxford_dictionary/error'
+
+module OxfordDictionary
+  # Handles all of the actual API calls
+  module DeprecatedRequest
+    BASE = 'https://od-api.oxforddictionaries.com/api/v1'.freeze
+    HTTP_OK = '200'.freeze
+    ACCEPT_TYPE = 'application/json'.freeze
+    # May be used by the wordlist endpoint
+    ADVANCED_FILTERS = [:exact, :exclude, :exclude_senses,
+                        :exclude_prime_senses, :limit, :offset,
+                        :prefix, :word_length].freeze
+
+    def request(endpoint, q, params)
+      url = URI(build_url(endpoint, q, params))
+      response = Net::HTTP.start(url.host, url.port, use_ssl: true) do |http|
+        request = build_get_request(url)
+        http.request(request)
+      end
+      parse_body_or_raise(response)
+    end
+
+    private
+
+    def parse_body_or_raise(response)
+      unless response.code == HTTP_OK
+        raise(Error.new(response.code), error_message(response.body))
+      end
+      JSON.parse(response.body).to_snake_keys
+    end
+
+    def build_url(endpoint, q, params)
+      params[:lang] || params[:lang] = 'en'
+      url_start = "#{BASE}/#{endpoint}/#{params[:lang]}"
+      if params[:q]
+        "#{url_start}#{search_endpoint_url(params)}".chomp('/')
+      else
+        unless q
+          # The wordlist endpoint uses a slightly different url structure
+          return "#{url_start}/#{build_advanced_url(params)}".chomp('/')
+        end
+        "#{url_start}/#{q}/#{finish_url(params)}".chomp('/')
+      end
+    end
+
+    def build_advanced_url(params)
+      advanced_params = {}
+      params.each do |k, v|
+        if ADVANCED_FILTERS.include?(k)
+          params.delete(k)
+          advanced_params[k] = v
+        end
+      end
+      "#{create_query_string(params)}#{advanced_query(advanced_params)}"
+    end
+
+    def advanced_query(params)
+      unless params.empty?
+        params[:exact] || params[:exact] = false
+        return "?#{create_query_string(params, '&')}"
+      end
+      ''
+    end
+
+    # The search endpoint has a slightly different url structure
+    def search_endpoint_url(params)
+      params[:prefix] || params[:prefix] = false
+      append = ''
+      if params[:translations]
+        append = "/translations=#{params[:translations]}"
+        params.delete(:translations)
+      end
+      "#{append}?#{create_query_string(params, '&')}"
+    end
+
+    def finish_url(params)
+      params[:end] || create_query_string(params)
+    end
+
+    def create_query_string(params, seperator = ';')
+      params.delete(:lang)
+      count = 0
+      query = ''
+      params.each do |k, v|
+        query += "#{k}=#{options(v)}"
+        query += seperator if count < params.size - 1
+        count += 1
+      end
+      query
+    end
+
+    def options(v)
+      if v.is_a?(Array)
+        hash_element?(v[0]) ? query_from_hash(v) : v.join(',')
+      else
+        v
+      end
+    end
+
+    def query_from_hash(hash)
+      query = ''
+      hash.each { |h| query += create_query_string(h) }
+      query
+    end
+
+    # Remove <p> and </p> in error message
+    def error_message(response)
+      response.lines.last.chomp[3..-5]
+    end
+
+    # The wordlist endpoint may nest filters
+    def hash_element?(element)
+      element.is_a?(Hash)
+    end
+
+    def build_get_request(url)
+      request = Net::HTTP::Get.new(url)
+      request['Accept'] = ACCEPT_TYPE
+      request['app_id'] = app_id
+      request['app_key'] = app_key
+      request
+    end
+  end
+end