camdict 1.0.3 → 2.0.0

data/test/itest_ipa.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+require_relative 'helper'
+
+module Camdict
+  class IPAiTest < Minitest::Test
+    def test_imaginary
+      ipa_test(imaginary)
+    end
+
+    # derived word
+    def test_plagiarism
+      ipa_test(plagiarism)
+    end
+
+    def test_aluminum
+      skip 'words are both in British & American dictionary, and on two pages'
+      ipa_test(aluminum)
+    end
+
+    # two .headword
+    def test_sled
+      ipa_test(sled)
+    end
+
+    def test_no_us_ipa
+      ipa_test(match)
+    end
+
+    private
+
+    def ipa_assert(e, a)
+      uk, us, actk, acts = a
+      assert_equal e[:uk_utf8], uk, "#{e[:word]} uk ipa got a problem"
+      assert_equal e[:us_utf8], us, "#{e[:word]} us ipa got a problem"
+      assert_equal e[:uk_inx], actk, "#{e[:word]} uk superscript index issue"
+      assert_equal e[:us_inx], acts, "#{e[:word]} us superscript index issue"
+    end
+
+    def ipa_test(d)
+      defi = definition(d)
+      uk = ipa_hexes(defi, :uk)
+      us = ipa_hexes(defi, :us)
+      actual = [uk, us, defi.ipa.k, defi.ipa.s]
+      ipa_assert(d, actual)
+    end
+
+    def definition(d)
+      Camdict::Word.new(d[:word]).definition
+    end
+
+    def ipa_hexes(defi, region)
+      defi.ipa.send(region)&.unpack('U*')&.map { |n| n.to_s 16 }
+    end
+
+    def match
+      {
+        word: 'match',
+        uk_utf8: %w(6d e6 74 283),
+        us_utf8: nil,
+        uk_inx: nil,
+        us_inx: nil
+      }
+    end
+
+    def imaginary
+      {
+        word: 'imaginary',
+        uk_utf8: %w(26a 2c8 6d e6 64 292 2e 26a 2e 6e 259 72 2e 69),
+        us_utf8: %w(26a 2c8 6d e6 64 292 2e 259 2e 6e 65 72 2e 69),
+        uk_inx: [10, 1],
+        us_inx: nil
+      }
+    end
+
+    def plagiarism
+      {
+        word: 'plagiarism',
+        uk_utf8: %w(2c8 70 6c 65 26a 2e 64 292 259 72 2e 26a 2e 7a 259 6d),
+        us_utf8: %w(2c8 70 6c 65 26a 2e 64 292 25a 2e 26a 2e 7a 259 6d),
+        uk_inx: [8, 1, 14, 1],
+        us_inx: [13, 1]
+      }
+    end
+
+    def aluminum
+      {
+        word: 'aluminum',
+        uk_utf8: %w(259 2c8 6c 75 2d0 2e 6d 26a 2e 6e 259 6d),
+        us_utf8: %w(259 2c8 6c 75 2d0 2e 6d 26a 2e 6e 259 6d),
+        uk_inx: nil,
+        us_inx: nil
+      }
+    end
+
+    def sled
+      {
+        word: 'sled',
+        uk_utf8: %w(73 6c 65 64),
+        us_utf8: %w(73 6c 65 64),
+        uk_inx: nil,
+        us_inx: nil
+      }
+    end
+  end
+end

data/test/itest_pronunciation.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+require_relative 'helper'
+
+module Camdict
+  class PronunciationiTest < Minitest::Test
+    def test_uk_pronunciation
+      pron = get_pron('understand')
+      assert_equal uk_mp3, pron.uk.mp3
+      assert_equal uk_ogg, pron.uk.ogg
+    end
+
+    def test_us_pronunciation
+      pron = get_pron('understand')
+      assert_equal us_mp3, pron.us.mp3
+      assert_equal us_ogg, pron.us.ogg
+    end
+
+    def test_derived_uk
+      pron = get_pron('harmfully')
+      assert_equal harm_uk_mp3, pron.uk.mp3
+      assert_equal harm_uk_ogg, pron.uk.ogg
+    end
+
+    def test_derived_us
+      pron = get_pron('harmfully')
+      assert_equal harm_us_mp3, pron.us.mp3
+      assert_equal harm_us_ogg, pron.us.ogg
+    end
+
+    private
+
+    def get_pron(word)
+      defs = Camdict::Client.new.html_definition(word)
+      d = Camdict::Definition.new(word)
+      d.send :get_pronunciation, defs
+    end
+
+    def media
+      'http://dictionary.cambridge.org/media/english/'
+    end
+
+    def uk_mp3
+      media + 'uk_pron/u/uku/ukund/ukunder112.mp3'
+    end
+
+    def uk_ogg
+      media + 'uk_pron_ogg/u/uku/ukund/ukunder112.ogg'
+    end
+
+    def us_mp3
+      media + 'us_pron/u/und/under/understand.mp3'
+    end
+
+    def us_ogg
+      media + 'us_pron_ogg/u/und/under/understand.ogg'
+    end
+
+    def harm_uk_mp3
+      media + 'uk_pron/u/ukh/ukhar/ukhardw017.mp3'
+    end
+
+    def harm_uk_ogg
+      media + 'uk_pron_ogg/u/ukh/ukhar/ukhardw017.ogg'
+    end
+
+    def harm_us_mp3
+      media + 'us_pron/u/ush/ushan/ushangd027.mp3'
+    end
+
+    def harm_us_ogg
+      media + 'us_pron_ogg/u/ush/ushan/ushangd027.ogg'
+    end
+  end
+end

data/test/itest_word.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+require_relative 'helper'
+
+module Camdict
+  class WordiTest < Minitest::Test
+    def setup
+      @film = Camdict::Word.new('film')
+    end
+
+    def test_definitions
+      assert @film.definitions
+    end
+
+    def test_raw_definition
+      refute @film.raw_definition.empty?
+    end
+
+    def test_ipa
+      assert_equal 'fɪlm', @film.ipa
+      assert_equal 'fɪlm', @film.ipa(:us)
+    end
+
+    def test_meaning
+      m = 'a series of moving pictures, usually shown in a cinema or on' \
+        ' television and often telling a story: '
+      assert_equal m, @film.meaning
+    end
+
+    def test_meanings
+      m = 'to record moving pictures with a camera, usually to make a film' \
+        ' for television or the cinema: '
+      assert_equal m, @film.meanings.last
+      assert_equal 4, @film.meanings.size
+    end
+
+    def test_pronunciation
+      uk_mp3 = 'http://dictionary.cambridge.org/media/english/uk_pron/u/ukf/' \
+        'ukfil/ukfill_007.mp3'
+      us_mp3 = 'http://dictionary.cambridge.org/media/english/us_pron/f/fil/' \
+        'film_/film.mp3'
+      assert_equal uk_mp3, @film.pronunciation
+      assert_equal us_mp3, @film.pronunciation(:us)
+    end
+
+    def test_part_of_speech
+      assert_equal %w(noun verb), @film.part_of_speech
+    end
+  end
+end

data/test/test_array_ext.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+require_relative 'helper'
+require 'camdict/array_ext'
+
+module Camdict
+  class ArrayExtTest < Minitest::Test
+    using Camdict::ArrayExt
+
+    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'
+    end
+  end
+end

data/test/test_client.rb

@@ -1,72 +1,65 @@
+# frozen_string_literal: true
 require 'minitest/autorun'
 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 class="prefix-block">
+   <li><a href="http://dictionary.cambridge.org/dictionary/english/related" title="related definition in English"><span class='arl1'><span class="base"><b class="hw">related</b></span></a></li>
+   <li><a href="http://dictionary.cambridge.org/dictionary/english/relate" title="relate definition in English"><span class='arl1'><span class="base"><b class="hw">relate</b></span></a></li>
 </ul>
 EoHTM
 
   class ClientTest < MiniTest::Test
+    def setup
+      @client = Camdict::Client.new
+    end
 
     def test_new
-      c = Camdict::Client.new
-      assert c.instance_eval { @dictionary == "english-chinese-simplified" }
-      c = Camdict::Client.new("american-english")
-      assert c.instance_eval { @dictionary == "american-english" }
+      assert @client.instance_eval { @dictionary == 'english' }
+      c = Camdict::Client.new('english-chinese-simplified')
+      assert_equal 'english-chinese-simplified', c.dictionary
     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)
+      assert @client.send :single_def?, Nokogiri::HTML(html)
+      assert @client.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)
+      url = 'http://dictionary.cambridge.org/british/related'
+      assert_equal 'related', @client.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))
+      html = '<li><span class="base"><b class="hw">related</b></span></li>'
+      html1 = '<li><span class="base"><b class="hw">stress-related'
+      html2 = '<span class="base">knock around/about'
+      assert @client.send :matched_word?, 'related', Nokogiri::HTML(html)
+      assert !(@client.send :matched_word?, 'related', Nokogiri::HTML(html1))
+      assert @client.send :matched_word?, 'knock around', Nokogiri::HTML(html2)
+      assert @client.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
-      }
+      rurl = 'http://dictionary.cambridge.org/dictionary/english'
+      expected_result = "#{rurl}/related"
       result_list = Nokogiri::HTML(RESULTLIST)
-      links = c.send(:mentry_links, "related", result_list)
-      assert expected_result == links
+      links = @client.send(:mentry_links, 'related', result_list).first
+      assert_equal expected_result, links
     end
 
-    def test_di_head
-      # Nokogiri version 1.6.2 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)
+    def test_di_body
+      html = '<div data-tab="ds-british">' \
+        '<div class="di-body"><div class="pos-header"/><div class="pos-body">'\
+        '</div></div>'
+      assert @client.send :di_body, Nokogiri::HTML(html)
     end
 
+    def test_encode
+      assert_equal 'time-zone', @client.send(:encode, 'time zone')
+      assert_equal 'time-s-up', @client.send(:encode, "time's up")
+    end
   end
-
 end

data/test/test_common.rb

@@ -1,93 +1,37 @@
-require 'minitest/autorun'
-require 'camdict'
+# frozen_string_literal: true
+require_relative 'helper'
 
 module Camdict
   class CommonTest < Minitest::Test
     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
-      str = "fall into the/sb's trap"
-      expected = ['fall into the trap', 'fall into sb\'s trap']
-      assert_equal expected, str.flatten
-      str = "what is sb/sth?"
-      expected = ['what is sb?', 'what is sth?']
-      assert_equal expected, str.flatten
-      str = "look lively/sharp!"
-      expected = ['look lively!', 'look sharp!']
-      assert_equal expected, str.flatten
-      str = "the like of sb/sth; sb's/sth's like"
-      expected = ['the like of sb', 'the like of sth', 
-        "sb's like", "sth's like"]
-      assert_equal expected, str.flatten
-      str = "go (like/down) a bomb"
-      expected = ['go a bomb', 'go like a bomb', 'go down a bomb']
-      assert_equal expected, str.flatten
-      str = "the other side/end (of sth)"
-      expected = ['the other side', 'the other end', 'the other side of sth',
-        'the other end of sth']
-      assert_equal expected, str.flatten
-      strs = ["20/20 vision", "public enemy number one/no. 1"]
-      # todo: 
-      # "20/20 vision".flatten => "20/20 vision" no change expected
-      # public enemy number one/no. 1 =>
-      #   public enemy number one
-      #   public enemy no. 1
-      str = "the more...the more/less"
-      expected = ['the more...the more', 'the more...the less']
-      assert_equal expected, str.flatten
-      # need more examples to support complex 'or' separators 
-      #   sound like/as if/as though
-      #   look on/upon sb/sth as sth
-      #   look at/see sth through rose-coloured/tinted glasses
-      #   give /quote sth/sb chapter and verse
-    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|
+      phrase_css(Nokogiri::HTML(html), '.def-block') do |node|
         ret = Camdict::Explanation.new(node)
-      }
+      end
       assert_equal sentence, ret.examples.first.sentence
       assert_equal meaning, ret.meaning
     end
 
+    private
+
+    def meaning
+      'to have problems or be in difficult situation:'
+    end
+
+    def sentence
+      'a ship is in difficluties off the coast of Ireland.'
+    end
+
+    def 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>"
+    end
   end
 end