camdict 1.0.0

data/lib/camdict/explanation.rb

@@ -0,0 +1,128 @@
+require 'camdict/common'
+
+module Camdict
+  # Explanation are inside the def-block node.
+  class Explanation
+
+    # Elementary level. It's a symbol indicating the level when learnders know
+    # this meaning.
+    #   A1: Beginner,       A2: Elementary, 
+    #   B1: Intermediate,   B2: Upper-Intermediate,
+    #   C1: Advanced,       C2: Proficiency
+    attr_reader :level
+
+    # Get example sentences
+    attr_reader :examples
+
+    # Get synonym word
+    attr_reader :synonym
+
+    # Get opposite word
+    attr_reader :opposite
+
+    # A meaning of the word
+    attr_reader :meaning
+
+    # One or two words usage note. For example, slang.
+    attr_reader :usage
+
+    # The meaning is used in which region - UK or US.
+    attr_reader :region
+
+    # For a specific explanation, the word may have a variant form.
+    attr_reader :variant
+
+    # Grammar code. Full list is http://dictionary.cambridge.org/help/codes.html
+    attr_reader :gc
+
+    # Parse +html+ to get level, meaning, example sentences, synonym, opposite,
+    # usage, grammar code, region, variant.
+    def initialize(html)
+      @html = html
+      @level = get_level                      # String
+      @variant = get_variant                  # String
+      @meaning = get_meaning                  # String
+      @gc = css_text(".gcs")                  # String
+      @usage = css_text(".usage")             # String
+      @region = css_text(".region")           # String
+      @examples = get_examples                # [Sentence]
+      @synonym = get_synonym                  # String
+      @opposite = get_opposite                # String
+      # todo: add usage panel - the word: somewhere.
+    end
+
+    private
+    # A meaning may have a symbol representing the difficulty from A1-C2.
+    def get_level
+      css_text ".def-info .epp-xref"
+    end
+
+    # For an explanation, it may have a variant form word or phrase which has
+    # same meaning.
+    def get_variant
+      css_text ".v[title='Variant form']"
+    end
+
+    # The meaning of a word for this explanation.
+    def get_meaning
+      css_text(".def")
+    end
+
+    # Get example sentences. Returned results are Sentence or nil.
+    def get_examples
+      nodes = @html.css(".examp")
+      unless nodes.empty?
+        @examples = nodes.map { |node| 
+          Camdict::Explanation::Sentence.new(node)
+        }
+      end
+    end
+
+    # Parse and get synonym word
+    def get_synonym
+      css_text ".entry-xref[type='Synonym'] .x-h"
+    end
+
+    # Parse and get opposite word
+    def get_opposite
+      css_text ".entry-xref[type='Opposite'] .x-h"
+    end
+
+    include Camdict::Common
+
+    # Parse the html to get the example sentence and its typical usage
+    # information associated with this sentence.
+    class Sentence
+      # Get the grammar code or usage in this sentence.
+      # It means how the word is used in this sentence. 
+      # For example, a grammar code for the word - 
+      # 'somewhere' is "+to infinitive". I'm looking for somewhere to eat.
+      attr_reader :usage
+
+      # Get one sentence inside an example block.
+      attr_reader :sentence
+
+      # New a sentence object from +html+ containing the eg block.
+      def initialize(html)
+        @html = html
+        @usage = get_usage
+        @sentence = get_sentence
+      end
+
+      private 
+      # Parse html node under block gcs or usage to get its grammar code or 
+      # usage info for this sentence.
+      def get_usage
+        css_text(".gcs") || css_text(".usage")
+      end
+
+      # Get sentence inside example block(.eg).
+      def get_sentence
+        css_text(".eg")
+      end
+
+      include Camdict::Common
+    end
+
+  end
+end

data/lib/camdict/http_client.rb

@@ -0,0 +1,22 @@
+module Camdict
+  module HTTP
+
+    require "open-uri"
+
+    # A default user agent string for this http client. It can be customised.
+    AGENT = 
+      "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:26.0) Gecko/20100101 Firefox/26.0"
+
+    class Client
+
+      # Download a html page from a remote site, and return a Nokogiri::HTML
+      # +url+ will be escaped by this method, and default +agtstr+ is AGENT.
+      def self.get_html(url, agtstr=AGENT)
+        url = URI.escape(url)
+        Nokogiri::HTML(open(url, "User-Agent"=>agtstr))
+      end
+
+    end
+
+  end
+end

data/lib/camdict/word.rb

@@ -0,0 +1,36 @@
+require 'camdict/client'
+require 'camdict/definition'
+
+module Camdict
+  # Get all definitions data about a word or phrase including IPAs, 
+  # pronunciations, usage sentences, etc. from Camdict Client.
+  class Word
+
+    # New a +word+ or phrase, default +dictionary+ is british.
+    def initialize(word, dictionary=nil)
+      @word ||= word
+      @dictionary = dictionary
+      @raw_definitions = []   # each element is a hash
+      @definitions = []       # each element is a Definition object
+    end
+
+    # Get all definitions for this word from remote online dictionary
+    def definitions
+      client = Camdict::Client.new(@dictionary)
+      @raw_definitions = client.html_definition(@word)
+      if found?
+        @definitions = @raw_definitions.map { |r|
+          Camdict::Definition.new(@word, r)
+        }
+      end
+    end
+
+    # Found in the diciontary? Return number of found entries
+    def found?
+      @raw_definitions.size
+    end
+
+    alias in? found?
+
+  end
+end

data/lib/camdict.rb

@@ -0,0 +1,2 @@
+require "nokogiri"
+require "camdict/word"

data/license

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Pan Gaoyong
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/test/itest_client.rb

@@ -0,0 +1,20 @@
+require 'test/unit'
+require 'camdict'
+
+module Camdict
+  class ClientiTest < Test::Unit::TestCase
+    def test_fetch
+      c = Camdict::Client.new
+      result = c.send :fetch, "pppppp"
+      assert ! result
+    end
+
+    def test_html_definition
+      c = Camdict::Client.new
+      search_result = c.html_definition("related")
+      r = search_result.collect {|r| r.keys}
+      assert_equal ["related_1", "related_2"], r.flatten
+    end
+  end
+end
+

data/test/itest_definition.rb

@@ -0,0 +1,89 @@
+require 'test/unit'
+require 'camdict'
+
+module Camdict
+  class DefinitioniTest < Test::Unit::TestCase
+
+    def test_part_of_speech
+      data = {'aluminium' => 'noun', 'aluminum' => 'noun', 
+        'look at sth' => 'phrasal verb', 'plagiarist' => 'noun', 
+        'pass water' => 'idiom', 'ruby' => ['noun', 'adjective']}
+      data.each_pair { |word, exp_result|
+        w = Camdict::Word.new(word)
+        defa = w.definitions
+        defo = defa.pop
+        assert_equal exp_result, defo.part_of_speech
+      }
+      w = Camdict::Word.new('correct')
+      defa = w.definitions
+      assert_equal 'adjective', defa[0].part_of_speech 
+      assert_equal 'verb', defa[1].part_of_speech 
+    end
+
+    def test_explanations
+      w = Camdict::Word.new('pass water')
+      defa = w.definitions
+      expl = defa[0].explanations.first
+      assert_equal "polite expression for urinate", expl.meaning
+    end
+
+    def test_ipa
+      imaginary = {
+        :word     => "imaginary",
+        :uk_utf8  => %w(26a 2c8 6d e6 64 292 2e 26a 2e 6e 259 72 2e 69),
+        :expected => %w(26a 2c8 6d e6 64 292 2e 259 2e 6e 65 72 2e 69),
+        :uk_inx   => [10,1],
+        :spiexp   => nil,
+        :which    => 0
+      }
+      plagiarism = {
+        :word     => "plagiarism",
+        :uk_utf8  => %w(2c8 70 6c 65 26a 2e 64 292 259 72 2e 26a 2e 7a 259 6d),
+        :expected => %w(2c8 70 6c 65 26a 2e 64 292 25a 2e 26a 2e 7a 259 6d),
+        :uk_inx   => [8,1,14,1],
+        :spiexp   => [13,1],
+        :which    => 0
+      }
+      aluminum = {
+        :word     => "aluminum",
+        :uk_utf8  => %w(259 2c8 6c 75 2d0 2e 6d 26a 2e 6e 259 6d),
+        :expected => %w(259 2c8 6c 75 2d0 2e 6d 26a 2e 6e 259 6d),
+        :uk_inx   => nil,
+        :spiexp   => nil,
+        :which    => 0
+      }
+      sled = {
+        :word     => "sled",
+        :uk_utf8  => nil,
+        :expected => nil,
+        :uk_inx   => nil,
+        :spiexp   => nil,
+        :which    => 1
+      }
+      data = [imaginary, plagiarism, aluminum, sled]
+      data.each { |d|
+        w = Camdict::Word.new(d[:word])
+        defa = w.definitions
+        defo = defa[d[:which]]
+        uk = defo.ipa.uk
+        us = defo.ipa.us
+        uk = uk.unpack('U*').map { |n| n.to_s 16 } if uk
+        us = us.unpack('U*').map { |n| n.to_s 16 } if us
+        actk = defo.ipa.k
+        acts = defo.ipa.s
+        assert_equal d[:uk_utf8], uk 
+        assert_equal d[:expected], us
+        assert_equal d[:uk_inx], actk
+        assert_equal d[:spiexp], acts
+      }
+    end
+
+    def test_region
+      w = Camdict::Word.new('rubbers')
+      defa = w.definitions
+      actual = defa[0].region
+      assert_equal "US", actual
+    end
+  
+  end
+end

data/test/itest_explanation.rb

@@ -0,0 +1,34 @@
+require 'test/unit'
+require 'camdict'
+
+module Camdict
+  class ExplanationiTest < Test::Unit::TestCase
+    def test_explanations
+      w = Camdict::Word.new('correct')
+      defa = w.definitions
+      def1 = defa.first #first is adjective
+      e1 = def1.explanations.first
+      assert_equal "A2", e1.level
+      assert_equal "B2", defa.last.explanations.first.level
+      assert_equal "I've got 30 exam papers to correct.", 
+        defa.last.explanations.first.examples.last.sentence
+      w = Camdict::Word.new('correctly')
+      defa = w.definitions
+      def1 = defa.first #first is adjective
+      e1 = def1.explanations
+      assert_equal "Have I pronounced your name correctly?", 
+        e1[2].examples[0].sentence
+      assert_equal "B1", e1[2].level
+    end
+
+    def test_phrase_meaning
+      w = Camdict::Word.new('blow your nose')
+      defa = w.definitions
+      def1 = defa.first 
+      el = def1.explanations.last
+      exped = 'to force air from your lungs and through your nose to clear it'
+      assert_equal exped, el.meaning
+    end
+
+  end
+end

data/test/test_client.rb

@@ -0,0 +1,72 @@
+require 'test/unit'
+require 'camdict'
+
+module Camdict
+  RESULTLIST = <<EoHTM
+<ul class="result-list">
+   <li><a href="http://dictionary.cambridge.org/dictionary/british/related_1" title="Definition of related adjective (CONNECTED) in British English"><span class='arl1'><span class="base"><b class="hw">related</b></span> <span title="A word that describes a noun or pronoun." class="pos">adjective</span> <b class="gw" title="Guide word: helps you find the right meaning when a word has more than one meaning">(CONNECTED)</b></span></a></li>
+   <li><a href="http://dictionary.cambridge.org/dictionary/british/related_2" title="Definition of related adjective (FAMILY) in British English"><span class='arl1'><span class="base"><b class="hw">related</b></span> <span title="A word that describes a noun or pronoun." class="pos">adjective</span> <b class="gw" title="Guide word: helps you find the right meaning when a word has more than one meaning">(FAMILY)</b></span></a></li>
+   <li><a href="http://dictionary.cambridge.org/dictionary/british/stress-related" title="Definition of stress-related adjective in British English"><span class='arl2'><span class="base"><b class="hw">stress-related</b></span> <span title="A word that describes a noun or pronoun." class="pos">adjective</span></span></a></li>
+</ul>
+EoHTM
+
+  class ClientTest < Test::Unit::TestCase
+
+    def test_new
+      c = Camdict::Client.new
+      assert c.instance_eval { @dictionary == "british" }
+      c = Camdict::Client.new("american-english")
+      assert c.instance_eval { @dictionary == "american-english" }
+    end
+
+    def test_single_def?
+      c = Camdict::Client.new
+      html = '<div class="di-head"> <div class="di-title"> <h1 class="hw">'
+      assert c.send :single_def?, Nokogiri::HTML(html)
+      assert c.send :definition_page?, Nokogiri::HTML(html)
+    end
+    
+    def test_entry_id
+      c = Camdict::Client.new
+      url = "http://dictionary.cambridge.org/british/related_1"
+      assert_equal "related_1", c.send( :entry_id, url)
+    end
+
+    def test_matched_word?
+      c = Camdict::Client.new
+      html = %q(<li><span class="base"><b class="hw">related</b></span></li>)
+      html1 = %q(<li><span class="base"><b class="hw">stress-related)
+      html2 = %q(<span class="base">knock around/about)
+      assert  (c.send :matched_word?, "related", Nokogiri::HTML(html))
+      assert !(c.send :matched_word?, "related", Nokogiri::HTML(html1))
+      assert  (c.send :matched_word?, "knock around", Nokogiri::HTML(html2))
+      assert  (c.send :matched_word?, "knock about", Nokogiri::HTML(html2))
+    end
+
+    def test_mentry_links
+      c = Camdict::Client.new
+      rurl = "http://dictionary.cambridge.org/dictionary/british/"
+      expected_result = %w(related_1 related_2).map { |r|
+        rurl + r
+      }
+      result_list = Nokogiri::HTML(RESULTLIST)
+      links = c.send(:mentry_links, "related", result_list)
+      assert expected_result == links
+    end
+
+    def test_di_head
+      # Nokogiri version 1.? and later required for this test case
+      # but previous versions should also work with camdict
+      # you won't see this test case failure once 
+      # https://github.com/sparklemotion/nokogiri/pull/1020 is released.
+      c = Camdict::Client.new
+      htmla = %q(<div class="di-head">)
+      htmlb = '<h2 class="di-title cdo-section-title-hw">aluminium</h2>' +
+        '<span class="di-info"><span class="pos">noun</span></span>'
+      result = c.send :di_head, Nokogiri::HTML(htmla+htmlb)
+      assert_equal(htmlb, result)
+    end
+
+  end
+
+end

data/test/test_common.rb

@@ -0,0 +1,59 @@
+require 'test/unit'
+require 'camdict'
+
+module Camdict
+  class CommonTest < Test::Unit::TestCase
+    include Camdict::Common
+
+    def test_flatten
+      str = "blow a kiss to/at sb"
+      expected = ['blow a kiss to sb', 'blow a kiss at sb']
+      assert_equal expected, str.flatten
+      str = "blow/blew a kiss"
+      expected = ['blow a kiss', 'blew a kiss']
+      assert_equal expected, str.flatten
+      str = "knock around/about"
+      expected = ['knock around', 'knock about']
+      assert_equal expected, str.flatten
+      str = "not give/budge/move an inch"
+      expected = ['not give an inch', 'not budge an inch', 'not move an inch']
+      assert_equal expected, str.flatten
+    end
+
+    def test_expand
+      phra = ['blow your nose', 'blow a kiss to/at sb']
+      expected = ['blow your nose', 'blow a kiss to sb', 'blow a kiss at sb']
+      assert_equal expected, phra.expand
+    end
+
+    def test_has?
+      phra = ['blow your nose', 'blow a kiss to/at sb']
+      assert phra.has? "blow your nose"
+      assert phra.has? "blow a kiss to sb"
+      assert phra.has? "a kiss to sb"
+      assert phra.has? "kiss at sb"
+      assert "blow your nose".has?('nose')
+      assert ! phra[1].flatten.has?(phra[0])
+    end
+
+    def test_phrase_css
+      meaning = 'to have problems or be in difficult situation:'
+      sentence = 'a ship is in difficluties off the coast of Ireland.'
+      html = '<span class="phrase-block">' +
+        '<span class="phrase">be in difficulties</span>' +
+        '<span class="v" title="Variant form">be in difficulty</span>' +
+        '<span class="phrase-body">' +
+          "<span class='def-block'><span class='def'>#{meaning}</span>" +
+            "<span class='examp'><span class='eg'>#{sentence}</span></span>"
+      @html = Nokogiri::HTML html
+      @word = 'be in difficulty'
+      ret = ''
+      phrase_css(".def-block") { |node|
+        ret = Camdict::Explanation.new(node)
+      }
+      assert_equal sentence, ret.examples.first.sentence
+      assert_equal meaning, ret.meaning
+    end
+
+  end
+end