mw_dictionary_api 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 80f489f6fae5b0f1b982015d98eca2fe4ebb4a2c
+  data.tar.gz: b7d1b0ac8af7932169d75b7ba5a40c6b0ff63605
+SHA512:
+  metadata.gz: efb2c50f4c1d612e36b1077c0455bde9bfd4df2c3b0e1b8225d8536c8a613557ae5aa12f9b35001262d86cc38c5aae17f5fe3999574616d69bef9f36b354c803
+  data.tar.gz: 2a72daf3bcbf6a2e2e4471cb6ca7c528b0193e616d07ecd91adceadd70bde7fb1403c4cf6fe5f1bb782de55148d5c30f789a3eabfbd21d24ce83c6adc7db71c7

data/lib/mw_dictionary_api.rb

@@ -0,0 +1,17 @@
+# require 'active_support/core_ext/class/attribute'
+require 'nokogiri'
+require 'mw_dictionary_api/client'
+require 'mw_dictionary_api/result'
+require "mw_dictionary_api/parsable"
+require 'mw_dictionary_api/memory_cache'
+require 'mw_dictionary_api/parsers/entry_parser'
+require 'mw_dictionary_api/parsers/result_parser'
+require 'mw_dictionary_api/parsers/definition_parser'
+
+module MWDictionaryAPI
+  API_ENDPOINT = 'http://www.dictionaryapi.com/api/v1/references'
+
+  class ResponseException < Exception
+  end
+
+end

data/lib/mw_dictionary_api/client.rb

@@ -0,0 +1,76 @@
+# encoding: UTF-8
+
+require 'cgi'
+require 'open-uri'
+
+module MWDictionaryAPI
+  class Client
+    class << self
+      def cache
+        @cache ||= MemoryCache
+      end
+
+      def cache=(cache)
+        @cache = cache
+      end
+
+      def parser_class
+        @parser_class ||= Parsers::ResultParser
+      end
+
+      def parser_class=(parser_class)
+        @parser_class = parser_class
+      end
+    end
+    
+    
+    attr_accessor :api_key, :api_type, :api_endpoint, :response_format
+
+    # search_cache is something that should have the following interface
+    #   search_cache.find(term) -> the raw response for the given term
+    #   search_cache.add(term, result) -> saves the raw response into the cache
+    #   search_cache.remove(term) -> remove the cached response for the term
+    #   (optional) search_cache.clear -> clear the cache
+    # attr_accessor :search_cache
+
+    def initialize(api_key, api_type: "sd4", response_format: "xml", api_endpoint: API_ENDPOINT)
+      @api_key = api_key
+      @api_type = api_type
+      @response_format = response_format
+      @api_endpoint = api_endpoint
+    end
+
+    def url_for(word)
+      "#{api_endpoint}/#{api_type}/#{response_format}/#{CGI.escape(word)}?key=#{api_key}"
+    end
+
+    def search(term, update_cache: false, parser_class: nil)
+      if self.class.cache
+        if update_cache
+          response = fetch_response(term)
+          self.class.cache.remove(term)
+          self.class.cache.add(term, response)
+        else
+          response = self.class.cache.find(term)
+          unless response
+            response = fetch_response(term)
+            self.class.cache.add(term, response)
+          end
+        end
+      else
+        response = fetch_response(term)
+      end
+      parser_class = self.class.parser_class if parser_class.nil?
+      Result.new(term, response, api_type: api_type, response_format: response_format, parser_class: parser_class)
+    end
+
+    def fetch_response(term)
+      result = open(url_for(term))
+      if result.status[0] != "200" or result.meta["content-type"] != response_format
+        raise ResponseException, result.read
+      else
+        result.read
+      end
+    end
+  end
+end

data/lib/mw_dictionary_api/memory_cache.rb

@@ -0,0 +1,27 @@
+module MWDictionaryAPI
+
+  class MemoryCache
+
+    def self.find(term)
+      cache[term]
+    end
+
+    def self.add(term, result)
+      cache[term] = result
+    end
+
+    def self.remove(term)
+      cache.delete(term)
+    end
+
+    # following methods are optional
+    def self.clear
+      cache.clear
+    end
+
+    def self.cache
+      @cache ||= {}
+    end
+
+  end
+end

data/lib/mw_dictionary_api/parsable.rb

@@ -0,0 +1,50 @@
+module MWDictionaryAPI
+  module Parsable
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def rules
+        @rules ||= {}
+      end
+
+      def inherited_rules
+        if superclass.respond_to? :inherited_rules
+          superclass.inherited_rules.merge(rules)
+        else
+          rules
+        end
+      end
+
+      def rule(attr_name, **options, &block)
+        rules[attr_name] = { attr_name: attr_name, options: options, block: block }
+      end
+
+      def apply_rule(attr_name, data, options)
+        inherited_rules[attr_name][:block].call(data, options)
+      end
+
+      def rule_helpers(&block)
+        instance_eval(&block)
+      end
+    end
+
+    def initialize(**options)
+      @options = options
+    end
+
+    def parse(data)
+      attributes = {}
+
+      self.class.inherited_rules.each do |attr_name, rule|
+        unless rule[:options][:hidden]
+          options = @options.merge(rule[:options])
+          attributes[attr_name] = rule[:block].call(data, options)
+        end
+      end
+      attributes
+    end
+
+  end
+end

data/lib/mw_dictionary_api/parsers/definition_parser.rb

@@ -0,0 +1,46 @@
+# encoding: UTF-8
+
+module MWDictionaryAPI
+  module Parsers
+    class DefinitionParser
+      include Parsable
+
+      rule :sense_number do |data, opts|
+        current_sn = (data[:sn] or "1")
+        previous_sn = data[:prev_sn]
+
+        current_sn = current_sn.gsub(" ", "")
+
+        if previous_sn.nil?
+          current_sn
+        else
+          if current_sn =~ /^\d+/ # starts with a digit
+            current_sn
+          elsif current_sn =~ /^[a-z]+/ # starts with a alphabet
+            m = /^(\d+)/.match(previous_sn)
+            (m) ? m[1] + current_sn : current_sn
+          else # starts with a bracket ( e.g. (1)
+            m = /^(\d+)*([a-z]+)*/.match(previous_sn)
+            m[1..2].select { |segment| !segment.nil? }.join("") + current_sn
+          end
+        end
+      end
+
+      rule :text do |data, opts|
+        dt_without_vi = data[:dt].dup
+        dt_without_vi.css("vi").remove
+        dt_without_vi.content.strip
+      end
+
+      rule :verbal_illustration do |data, opts|
+        data[:dt].at_css("vi").content if data[:dt].at_css("vi")
+      end
+
+      rule :cross_reference do |data, opts|
+        data[:dt].xpath("sx").inject([]) do |xrefs, sx|
+          xrefs << sx.content
+        end
+      end
+    end
+  end
+end

data/lib/mw_dictionary_api/parsers/entry_parser.rb

@@ -0,0 +1,74 @@
+# encoding: UTF-8
+
+module MWDictionaryAPI
+  module Parsers
+    class EntryParser
+      include Parsable
+
+      rule :id_attribute do |data, opts|
+        data.attribute("id").value
+      end
+
+      rule :head_word do |data, opts|
+        parse_entity(data, "hw")
+      end
+
+      rule :pronunciation do |data, opts|
+        parse_entity(data, "pr")
+      end
+
+      rule :part_of_speech do |data, opts|
+        parse_entity(data, "fl")
+      end
+
+      rule :sound do |data, opts|
+        parse_entity(data, "sound wav")
+      end
+
+      rule :word do |data, opts|
+        id_attribute = data.attribute("id").value
+        m = /(.*)\[(\d+)\]/.match(id_attribute)
+        (m) ? m[1] : id_attribute
+      end
+
+      rule :id do |data, opts|
+        id_attribute = data.attribute("id").value
+        m = /(.*)\[(\d+)\]/.match(id_attribute)
+        (m) ? m[2].to_i : 1
+      end
+
+      rule :definitions do |data, opts|
+        # here we assume 
+        # 1. sense number (sn) alway appear before a definition (dt) in pairs
+        # 2. definition (dt) appear by itself
+        data.xpath("def//sn | def//dt").each_slice(2).inject([]) do |definitions, nodes|
+          hash = Hash[nodes.map {|n| n.name.to_sym}.zip(nodes.map {|n| (n.name == 'sn') ? n.content : n })]
+          hash[:prev_sn] = definitions[-1][:sense_number] if definitions[-1]
+          definitions << DefinitionParser.new(parser_options(opts)).parse(hash)
+        end  
+      end
+
+      rule :inflections do |data, opts|
+        data.xpath("in//il | in//if").each_slice(2).inject([]) do |hashes, nodes|
+          hash = Hash[nodes.map {|n| n.name.to_sym}.zip(nodes.map {|n| n.content})]
+          hash[:il] = hashes[-1][:il] if hashes[-1] and hash[:il] == "or"
+          hashes << hash
+        end.inject({}) do |inflections, hash|
+          inflections[hash[:il].to_sym] ||= []
+          inflections[hash[:il].to_sym] << hash[:if].gsub(/\W/, "")
+          inflections
+        end
+      end
+
+      rule_helpers do
+        def parser_options(opts)
+          { api_type: opts[:api_type], response_format: opts[:response_format] }
+        end
+
+        def parse_entity(data, tag)
+          data.at_css(tag).content if data.at_css(tag)
+        end
+      end
+    end
+  end
+end

data/lib/mw_dictionary_api/parsers/result_parser.rb

@@ -0,0 +1,23 @@
+# encoding: UTF-8
+
+module MWDictionaryAPI
+  module Parsers
+    class ResultParser
+      include Parsable
+
+      rule :entries do |data, opts|
+        data.css("entry").inject([]) do |entries, xml_entry|
+          parser = Parsers::EntryParser.new(api_type: opts[:api_type], response_format: opts[:response_format])
+          entries << parser.parse(xml_entry)
+          entries
+        end
+      end
+
+      rule :suggestions do |data, opts|
+        data.css("suggestion").inject([]) do |suggestions, suggestion_xml|
+          suggestions << suggestion_xml.content
+        end
+      end
+    end
+  end
+end

data/lib/mw_dictionary_api/result.rb

@@ -0,0 +1,35 @@
+# encoding: UTF-8
+
+module MWDictionaryAPI
+  class Result
+    
+    attr_accessor :parser_class
+    attr_reader :term, :raw_response, :api_type, :response_format,
+                :entries, :suggestions
+
+    def initialize(term, raw_response, api_type: "sd4", response_format: "xml", parser_class: Parsers::ResultParser)
+      @term = term
+      @raw_response = raw_response
+      @api_type = api_type
+      @response_format = response_format
+      @parser_class = parser_class
+      
+      parse!
+    end
+
+    def parse!
+      parser = parser_class.new(api_type: api_type, response_format: response_format)
+      attributes = parser.parse(Nokogiri::XML(raw_response))
+      @entries = attributes[:entries]
+      @suggestions = attributes[:suggestions]
+    end
+
+    def to_hash
+      {
+        term: term,
+        entries: entries,
+        suggestions: suggestions
+      }
+    end
+  end
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: mw_dictionary_api
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Frank Liu
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A Simple Way to Query Merriam Webster Dictionary API
+email: gniquil@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/mw_dictionary_api.rb
+- lib/mw_dictionary_api/client.rb
+- lib/mw_dictionary_api/memory_cache.rb
+- lib/mw_dictionary_api/parsable.rb
+- lib/mw_dictionary_api/result.rb
+- lib/mw_dictionary_api/parsers/result_parser.rb
+- lib/mw_dictionary_api/parsers/entry_parser.rb
+- lib/mw_dictionary_api/parsers/definition_parser.rb
+homepage: https://github.com/gniquil/mw_dictionary_api
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.6
+signing_key: 
+specification_version: 4
+summary: Merriam Webster Dictionary API
+test_files: []