camdict 1.0.3 → 2.0.0

data/lib/camdict/word.rb

@@ -1,36 +1,102 @@
+# frozen_string_literal: true
 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.
+  # Get all definitions data about a word or phrase including IPAs,
+  # pronunciations, usage sentences, etc. from Cambridge dictionary.
   class Word
-
     # New a +word+ or phrase, default +dictionary+ is british.
-    def initialize(word, dictionary=nil)
-      @word ||= word
+    def initialize(word, dictionary = nil)
+      @word = word
       @dictionary = dictionary
-      @raw_definitions = []   # each element is a hash
-      @definitions = []       # each element is a Definition object
+    end
+
+    def part_of_speech
+      s = definition.senses.map(&:part_of_speech).uniq
+      return s.first if s.count < 2
+      s
+    end
+
+    def pronunciation(region = :uk)
+      p = definition.pronunciation.send(region)
+      p.mp3 || p.ogg
+    end
+
+    def ipa(region = :uk)
+      definition.ipa.send(region)
+    end
+
+    def meaning
+      definition.senses.first.explanations.first.meaning
+    end
+
+    def meanings
+      definition.senses.map { |s| s.explanations.map(&:meaning) }.flatten
+    end
+
+    # show all important dictionary information, returns
+    # { meaning: [{ pos: '', category: '',
+    #             sense: [{ meaning:, eg: [], level: '', code: '', synonym: '',
+    #                      opposite: '', usage: '', region: ''}] }]
+    #   ipa: '' | { uk: , us: },
+    #   pronunciation: { uk: mp3|ogg, us: mp3|ogg }
+    # }
+    def show
+      {
+        meaning: meanings_json,
+        ipa: ipa_json,
+        pronunciation: { uk: pronunciation, us: pronunciation(:us) }
+      }
+    end
+
+    def print
+      require 'pp'
+      pp show
     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)
+      @definitions ||= g_definitions
+    end
+
+    def raw_definition
+      @raw_definition ||= retrieve.to_html(save_with: 0)
+    end
+
+    alias pos part_of_speech
+    alias definition definitions
+
+    private
+
+    def retrieve
+      @retrieved ||= Camdict::Client.new(@dictionary).html_definition(@word)
+    end
+
+    def g_definitions
+      Camdict::Definition.new(@word).parse(retrieve)
+    end
+
+    def meanings_json
+      definition.senses.map do |s|
+        {
+          pos: s.part_of_speech, category: s.category,
+          sense: s.explanations.map do |e|
+            { meaning: e.meaning, eg: e.examples&.map(&:sentence) }
+              .merge(optional_meaning_items(e))
+          end
         }
       end
     end
 
-    # Found in the diciontary? Return number of found entries
-    def found?
-      @raw_definitions.size
+    def ipa_json
+      ipa(:uk) == ipa(:us) ? ipa : { uk: ipa(:uk), us: ipa(:us) }
     end
 
-    alias in? found?
-
+    def optional_meaning_items(exp)
+      %w(level code synonym opposite usage region).inject({}) do |ret, o|
+        exp.public_send(o) ? ret.merge({ o => exp.public_send(o) }) : ret
+      end
+    end
   end
 end

data/test/debug.rb

@@ -0,0 +1,60 @@
+require_relative 'helper'
+
+module Camdict
+  # test in a way that how camdict is working, so that remote changes can
+  # be found quickly, especially for css class changes.
+  class Debug < Minitest::Test
+    def setup
+      @word = ARGV[0]
+      check_input
+      @wordict = Camdict::Word.new(@word)
+      @client = Camdict::Client.new
+      $cache ||= {}
+    end
+
+    def test_search
+      assert @client.send :fetch, @word
+    end
+
+    def test_word_page
+      assert @client.send :single_def?, word_page
+    end
+
+    def test_british_tab
+    end
+
+    def test_where
+      where = definations.send(:where, word_content)
+      print 'where=', where
+      refute_equal 'unknown', where
+    end
+
+    def test_ipa
+      definations
+    end
+
+    def test_print
+      puts
+      @wordict.print
+    end
+
+    private
+
+    def check_input
+      @word || abort('please specify a word on command line')
+    end
+
+    def definations
+      $cache[:definitions] ||=
+        Camdict::Definition.new(@word).parse(word_content)
+    end
+
+    def word_content
+      $cache[:word_content] ||= @client.send(:di_extracted, word_page)
+    end
+
+    def word_page
+      $cache[:word_page] ||= @client.get_html(@client.word_url(@word))
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,2 @@
+require 'minitest/autorun'
+require 'camdict'

data/test/itest_client.rb

@@ -1,20 +1,51 @@
+# frozen_string_literal: true
 require 'minitest/autorun'
 require 'camdict'
 
 module Camdict
   class ClientiTest < Minitest::Test
+    def setup
+      @client = Camdict::Client.new
+      @imaginary = @client.word_url('imaginary')
+    end
+
     def test_fetch
-      c = Camdict::Client.new
-      result = c.send :fetch, "pppppp"
-      assert ! result
+      assert !@client.send(:fetch, 'pppppp')
+      assert @client.send(:fetch, 'mind')
+    end
+
+    def test_single_def?
+      html = @client.get_html(@imaginary)
+      assert @client.send :single_def?, html
+    end
+
+    def test_mentry_links
+      related_html = @client.get_html(@client.search_url('related'))
+      related_links = @client.send :mentry_links, 'related', related_html
+      assert_equal 1, related_links.size
+    end
+
+    def test_matched_word?
+      mind_url = @client.search_url('mind')
+      mind_node = @client.get_html(mind_url).css('.prefix-item').first
+      assert @client.send :matched_word?, 'mind', mind_node
+    end
+
+    def test_di_extracted
+      html = @client.get_html(@imaginary)
+      r = @client.send :di_extracted, html
+      assert r.css('.cdo-section-title-hw')
+      assert r.css('.pron-info')
+    end
+
+    def test_di_body
+      html = @client.get_html(@imaginary)
+      assert @client.send :di_body, html
     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
+      search_result = @client.html_definition('related')
+      assert search_result.first
     end
   end
 end
-

data/test/itest_definition.rb

@@ -1,90 +1,39 @@
-require 'minitest/autorun'
-require 'camdict'
+# frozen_string_literal: true
+require_relative 'helper'
 
 module Camdict
   class DefinitioniTest < Minitest::Test
-
     def test_part_of_speech
-      data = {'aluminium' => 'noun', 'aluminum' => 'noun', 
-        'look at sth' => 'phrasal verb', 'plagiarist' => 'noun', 
-        'pass water' => 'idiom', 'ruby' => 'noun'}
-      # adjective for ruby exists in British dictionary
-      data.each_pair { |word, exp_result|
+      pos_data.each_pair do |word, exp_result|
         w = Camdict::Word.new(word)
-        defa = w.definitions
-        defo = defa.pop
-        assert_equal exp_result, defo.part_of_speech
-      }
+        assert_equal exp_result, w.part_of_speech
+      end
+    end
+
+    def test_pos
       w = Camdict::Word.new('correct')
-      defa = w.definitions
-      assert_equal 'adjective', defa[0].part_of_speech 
-      assert_equal 'verb', defa[1].part_of_speech 
+      assert_equal %w(adjective verb), w.pos
     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
+    def test_region_in_block
+      skip 'word in block'
+      w = Camdict::Word.new('rubbers')
+      assert_equal 'US', w.region
     end
 
-    def test_ipa
-      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,
-        :which    => 0
-      }
-      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],
-        :which    => 0
-      }
-      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,
-        :which    => 0
-      }
-      sled = {
-        :word     => "sled",
-        :uk_utf8  => nil,
-        :us_utf8  => nil,
-        :uk_inx   => nil,
-        :us_inx   => 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, "#{d[:word]} uk ipa got a problem"
-        assert_equal d[:us_utf8], us, "#{d[:word]} us ipa got a problem"
-        assert_equal d[:uk_inx], actk, "#{d[:word]} uk superscript index issue"
-        assert_equal d[:us_inx], acts, "#{d[:word]} us superscript index issue"
-      }
+    def test_meaning
+      skip 'phrase'
+      w = Camdict::Word.new('pass water')
+      expl = w.definition.senses.first.explanations.first
+      assert_equal 'polite expression for urinate', expl.meaning
     end
 
-    def test_region
-      w = Camdict::Word.new('rubbers')
-      defa = w.definitions
-      actual = defa[0].region
-      assert_equal "US", actual
+    def pos_data
+      # 'aluminum' => 'noun', US variant ought to be got from American tab
+      { 'aluminium' => 'noun',
+        'plagiarist' => 'noun',
+        'ruby' => 'noun' }
+      # adjective for ruby exists in British dictionary
     end
-  
   end
 end

data/test/itest_entry.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+require_relative 'helper'
+
+module Camdict
+  class EntryiTest < Minitest::Test
+    def setup
+      fly_e = Camdict::Client.new.html_definition('fly')
+                             .css('.entry-body__el').first
+      @senses = Camdict::Definition.new('fly').send(:get_senses, fly_e)
+    end
+
+    def test_senses
+      assert_equal 4, @senses.size
+    end
+
+    def test_meaning
+      expect = 'When a bird, insect, or aircraft flies, it moves through ' \
+        'the air: '
+      assert_equal expect, @senses.first.explanations.first.meaning
+    end
+
+    def test_part_of_speech
+      assert_equal 'verb', @senses.first.part_of_speech
+    end
+
+    def test_category
+      assert_equal 'TRAVEL', @senses.first.category
+    end
+
+    def test_derived_pos
+      html = Camdict::Client.new.html_definition('plagiarism')
+                            .css('.entry-body__el')
+      senses = Camdict::Definition.new('plagiarism').send(:get_senses, html)
+      assert_equal 'noun', senses.first.part_of_speech
+    end
+  end
+end

data/test/itest_explanation.rb

@@ -1,35 +1,56 @@
-require 'minitest/autorun'
-require 'camdict'
+# frozen_string_literal: true
+require_relative 'helper'
 
 module Camdict
   class ExplanationiTest < Minitest::Test
-    def test_explanations
-      w = Camdict::Word.new('correct')
-      defa = w.definitions
-      def1 = defa.first #first is adjective
-      e1 = def1.explanations.first
-      #todo: level info is not in english-chinese-simplied dictionary
-      #assert_equal "A2", e1.level
-      #assert_equal "B2", defa.last.explanations.first.level
-      assert_equal "I've got thirty 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
+    def test_level
+      assert_equal 'B2', sense(:last).explanations.first.level
+    end
+
+    def test_sentence
+      e = sense(:first).explanations.first
+      assert_equal 'A2', e.level
+      assert_equal %("Your name is Angela Black?" "That is correct."),
+                   e.examples.last.sentence
+    end
+
+    def test_code
+      w = Camdict::Word.new('cause')
+      def1 = w.definitions
+      e1 = def1.senses.first.explanations.first
+      assert_equal ' C or U ', e1.code
+    end
+
+    def test_gc_usage
+      w = Camdict::Word.new('cause')
+      def1 = w.definition
+      e2 = def1.senses[2].explanations.first
+      assert_equal ' + two objects ', e2.examples.last.usage
+    end
+
+    def test_correctly
+      skip 'derived word - on the same page with its original'
+      w = Camdict::Word.new('correctly').definition
+      e1 = w.senses.first.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
+      skip 'phrase ought have its own class'
       w = Camdict::Word.new('blow your nose')
       defa = w.definitions
-      def1 = defa.first 
+      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
 
+    private
+
+    def sense(nth)
+      Camdict::Word.new('correct').definition.senses.send(nth)
+    end
   end
 end