wlapi 0.8.1 → 0.8.3

data/.yardopts

@@ -2,5 +2,5 @@
 --protected
 --title 'WLAPI - Ruby based API for Wortschatz Leipzig web services'
 -
-CHANGELOG
-LICENSE
+CHANGELOG.rdoc
+LICENSE.rdoc

data/{CHANGELOG → CHANGELOG.rdoc}

@@ -1,4 +1,11 @@
 == COMPLETED
+=== 0.8.3
+Implemented a simple error handling strategy, it is possible to intercept
+the <tt>WLAPI::Error</tt> which covers all error types.
+
+Added error for inconvinient user argumets.
+
+Added new tests and refactored old tests.
 === 0.8.1
 Moved to dependency management via Bundler.
 === 0.8.0
@@ -15,11 +22,14 @@ Initial release of the lib.
 
 
 == PLANNED
-=== 0.8.2
+=== 0.8.4
+Test the lib against mri, rbx, jruby, win rubies.
+=== 0.8.5
 Introduce +nokogiri+ for parsing responses.
-Refactore all test and implement server response stubs with +fakeweb+.
-=== 0.8.3
-Implement an error handling strategy.
+=== 0.8.6
+=== 0.8.7
+=== 0.8.8
+=== 0.8.9
 === 0.9.0
 === 1.0.0
 

data/{README → README.rdoc}

@@ -1,8 +1,10 @@
 = WLAPI
 
 * {RubyGems}[http://rubygems.org/gems/wlapi]
-* Developers {Homepage}[http://www.uni-trier.de/index.php?id=24140]
-* {WLAPI Project Page}[http://wlapi.rubyforge.org/]
+* Developers {Homepage}[http://bu.chsta.be/]
+* {WLAPI Project Page}[http://bu.chsta.be/projects/wlapi/]
+* {Source Code}[https://github.com/arbox/wlapi]
+* {Bug Tracker}[https://github.com/arbox/wlapi/issues]
 
 == DESCRIPTION
 WLAPI is a programmatic API for web services provided by the project
@@ -22,7 +24,6 @@ You can use the following search methods:
 * domain;
 * experimental_synonyms;
 * frequencies;
-* intersection;
 * left_collocation_finder;
 * left_neighbours;
 * right_collocation_finder;
@@ -33,6 +34,8 @@ You can use the following search methods:
 * thesaurus;
 * wordforms.
 
+There are three additional services by Wortschatz Leipzig: Kreuzworträtsel, MARS and Kookurrenzschnitt. They will not be implemented.
+
 == INSTALLATION
 WLAPI is provided as a .gem package. Simply install it via
 {RubyGems}[http://rubygems.org/gems/wlapi].
@@ -66,6 +69,28 @@ credentials and instantiate an authenticated client:
 See documentation in the WLAPI::API class for details
 on particular search methods.
 
+== EXCEPTION HIERARCHY
+While using WLAPI you can face following errors:
+* <tt>WLAPI::UserError</tt>;
+* <tt>WLAPI::ExternalError</tt>.
+
+The errors here are presented in the order they may occur
+during WLAPI's work.
+
+First WLAPI checks the user input and throws a <tt>WLAPI::UserError</tt>
+if the arguments are not appropriate.
+
+Then it fetches a response from a remote server, it can result
+in a <tt>WLAPI::ExternalError</tt>. In most cases it will be a simple wrapper
+around other errors, e.g. <tt>Savon::SOAP::Fault</tt>.
+
+All of them are subcalsses of <tt>YANAPI::Error</tt> which is in turn a subclass
+of the standard +RuntimeError+.
+
+If you want to intercept any and every exception thrown by YANAPI simply rescue
+<tt>YANAPI::Error</tt>.
+
+
 == SUPPORT
 If you have question, bug reports or any suggestions, please drop me an email :) 
 Any help is deeply appreciated!

data/lib/wlapi/api.rb

@@ -2,9 +2,10 @@
 # 2010-, Andrei Beliankou
 
 # :title: Ruby based API for Wortschatz Leipzig web services
-# :main: README
+# :main: README.rdoc
 
 require 'savon'
+require 'wlapi/error'
 
 # REXML is fast enough for our task.
 require 'rexml/document'
@@ -81,17 +82,21 @@ module WLAPI
     # in the corpus. The higher the class, the rarer the word:
     #   api.frequencies("Autos") => ["40614", "9"]
     def frequencies(word)
+      check_params(word)
+      
       arg1 = ['Wort', word]
       answer = query(@cl_Frequencies, arg1)
 
       get_answer(answer)
     end
     
-    # Gets the baseform (whatever it is :) not lemma).
+    # Gets the baseform (whatever it is :), not lemma).
     # Returns the lemmatized (base) form of the input word
     # and the POS tag in an array:
     #   api.baseform("Auto") => ["Auto", "N"]
     def baseform(word)
+      check_params(word)
+      
       arg1 = ['Wort', word]
       answer = query(@cl_Baseform, arg1)
 
@@ -104,6 +109,8 @@ module WLAPI
     # Is it a good name? all names are in English, but here..
     # let's call it domain, not sachgebiet
     def domain(word)
+      check_params(word)
+      
       arg1 = ['Wort', word]
       answer = query(@cl_Sachgebiet, arg1)
       
@@ -116,6 +123,8 @@ module WLAPI
     # Returns all other word forms of the same lemma for a given word form.
     #   api.wordforms("Auto") => ["Auto", "Autos"]
     def wordforms(word, limit = 10)
+      check_params(word, limit)
+      
       # note, it is the only service which requires 'Word', not 'Wort'
       arg1 = ['Word', word]
       arg2 = ['Limit', limit]
@@ -129,6 +138,8 @@ module WLAPI
     # and thus returns more synonyms:
     #   api.thesaurus("Auto") => ["Auto", "Bahn", "Wagen", "Zug", "Schiff", ...]
     def thesaurus(word, limit = 10)
+      check_params(word, limit)
+      
       arg1 = ['Wort', word]
       arg2 = ['Limit', limit]
       answer = query(@cl_Thesaurus, arg1, arg2)
@@ -140,6 +151,8 @@ module WLAPI
     # Returns synonyms of the input word. In other words, this is a thesaurus.
     #   api.synonyms("Auto") => ["Kraftwagen", "Automobil", "Benzinkutsche", ...]
     def synonyms(word, limit = 10)
+      check_params(word, limit)
+      
       arg1 = ['Wort', word]
       arg2 = ['Limit', limit]
       answer = query(@cl_Synonyms, arg1, arg2)
@@ -157,6 +170,8 @@ module WLAPI
     #--
     # ok, but results should be filtered
     def sentences(word, limit = 10)
+      check_params(word, limit)
+      
       arg1 = ['Wort', word]
       arg2 = ['Limit', limit]
       answer = query(@cl_Sentences, arg1, arg2)
@@ -170,6 +185,8 @@ module WLAPI
     #--
     # ok, but results should be filtered
     def left_neighbours(word, limit = 10)
+      check_params(word, limit)
+      
       arg1 = ['Wort', word]
       arg2 = ['Limit', limit]
       answer = query(@cl_LeftNeighbours, arg1, arg2)
@@ -183,6 +200,8 @@ module WLAPI
     #--
     # ok, but results should be filtered
     def right_neighbours(word, limit = 10)
+      check_params(word, limit)
+      
       arg1 = ['Wort', word]
       arg2 = ['Limit', limit]
       answer = query(@cl_RightNeighbours, arg1, arg2)
@@ -199,6 +218,8 @@ module WLAPI
     # may take a long time.
     #   api.similarity("Auto") => ["Auto", "Wagen", "26", ...]
     def similarity(word, limit = 10)
+      check_params(word, limit)
+      
       arg1 = ['Wort', word]
       arg2 = ['Limit', limit]
       answer = query(@cl_Similarity, arg1, arg2)
@@ -210,6 +231,8 @@ module WLAPI
     #--
     # don't know, if we have to include this service...
     def experimental_synonyms(word, limit = 10)
+      check_params(word, limit)
+      
       arg1 = ['Wort', word]
       arg2 = ['Limit', limit]
       answer = query(@cl_ExperimentalSynonyms, arg1, arg2)
@@ -229,6 +252,8 @@ module WLAPI
     #   api.right_collocation_finder("Auto", "V", 10) =>
     #   ["Auto", "abfackeln", "V", ...]
     def right_collocation_finder(word, pos, limit = 10)
+      check_params(word, pos, limit)
+      
       arg1 = ['Wort', word]
       arg2 = ['Wortart', pos]
       arg3 = ['Limit', limit]
@@ -246,6 +271,8 @@ module WLAPI
     #   api.left_collocation_finder("Stuhl", "A", 10) =>
     #   ["apostolisch", "A", "Stuhl", ...]
     def left_collocation_finder(word, pos, limit = 10)
+      check_params(word, pos, limit)
+      
       arg1 = ['Wort', word]
       arg2 = ['Wortart', pos]
       arg3 = ['Limit', limit]
@@ -256,23 +283,31 @@ module WLAPI
     
     # Returns statistically significant co-occurrences of the input word.
     def cooccurrences(word, sign, limit = 10)
+      check_params(word, sign, limit)
+      
       arg1 = ['Wort', word]
       arg2 = ['Mindestsignifikanz', sign]
       arg3 = ['Limit', limit]
-      raise NotImplementedError, 'Not implemented yet!'
+      answer = query(@cl_Cooccurrences, arg1, arg2, arg3)
+      
+      get_answer(answer)
     end
     
     # Returns statistically significant co-occurrences of the input word.
-    # However, it searches in the unrestricted version of the co-occurrences table
-    # as in the Cooccurrences services,
+    # However, it searches in the unrestricted version of the co-occurrences
+    # table as in the Cooccurrences services,
     # which means significantly longer wait times.
     def cooccurrences_all(word, sign, limit = 10)
+      check_params(word, sign, limit)
+      
       arg1 = ['Wort', word]
       arg2 = ['Mindestsignifikanz', sign]
       arg3 = ['Limit', limit]
-      raise NotImplementedError, 'Not implemented yet!'
+      answer = query(@cl_CooccurrencesAll, arg1, arg2, arg3)
+      
+      get_answer(answer)
     end
-    
+
     # Returns the intersection of the co-occurrences of the two given words.
     # The result set is ordered according to the sum of the significances
     # in descending order. Note that due to the join involved,
@@ -281,13 +316,15 @@ module WLAPI
     # let's call it intersection, not kookurrenzschnitt
     # is being used INTERN, we need additional credentials
     def intersection(word1, word2, limit = 10)
+      check_params(word1, word2, limit)
+      
       arg1 = ['Wort 1', word1]
       arg2 = ['Wort 2', word2]
       arg3 = ['Limit', limit]
-      # we are not going to implement it now
-      raise NotImplementedError, 'Will never be implemented!'
-    end
-    
+      answer = query(@cl_Kookurrenzschnitt, arg1, arg2, arg3)
+      
+      get_answer(answer)
+    end    
     private
     
     # Main query method, it invokes the soap engine.
@@ -296,48 +333,53 @@ module WLAPI
     # with keys and values for the soap query.
     def query(cl, *args)
       # WSDL is disabled since calling the server for wsdl can last too long.
-      resp = cl.request(:urn, :execute) do |soap|
-
-        # Every service has a different namespace.
-        soap.namespaces['xmlns:urn'] = cl.wsdl.namespace
-        
-        soap.namespaces['xmlns:dat'] =
-          "http://datatypes.webservice.wortschatz.uni_leipzig.de"
 
-        v = []
-        body = {
-          'urn:objRequestParameters' => {
-            'urn:corpus' => 'de',
-            'urn:parameters' => {
-              'urn:dataVectors' => v
+      begin
+        resp = cl.request(:urn, :execute) do |soap|
+          
+          # Every service has a different namespace.
+          soap.namespaces['xmlns:urn'] = cl.wsdl.namespace
+          
+          soap.namespaces['xmlns:dat'] =
+            "http://datatypes.webservice.wortschatz.uni_leipzig.de"
+          
+          v = []
+          body = {
+            'urn:objRequestParameters' => {
+              'urn:corpus' => 'de',
+              'urn:parameters' => {
+                'urn:dataVectors' => v
+              }
             }
           }
-        }
-
-        # Setting the first argument (usually 'Wort').
-        v << {'dat:dataRow'=>[
-                              args[0][0],
-                              args[0][1]
-                             ]
-        } if args[0]
-        # Setting the second argument (usually 'Limit').
-        v << {'dat:dataRow'=>[
-                              args[1][0],
-                              args[1][1]
-                             ]
-        } if args[1]
-        # Setting the third argument (no common value)
-        v << {'dat:dataRow'=>[
-                              args[2][0],
-                              args[2][1]
-                             ]
-        } if args[2]
-
-        soap.body = body
-        warn(soap.to_xml) if $DEBUG
-
+          
+          # Setting the first argument (usually 'Wort').
+          v << {'dat:dataRow'=>[
+                                args[0][0],
+                                args[0][1]
+                               ]
+          } if args[0]
+          # Setting the second argument (usually 'Limit').
+          v << {'dat:dataRow'=>[
+                                args[1][0],
+                                args[1][1]
+                               ]
+          } if args[1]
+          # Setting the third argument (no common value)
+          v << {'dat:dataRow'=>[
+                                args[2][0],
+                                args[2][1]
+                               ]
+          } if args[2]
+          
+          soap.body = body
+          warn(soap.to_xml) if $DEBUG
+          
+        end
+      rescue => e
+        fail(WLAPI::ExternalError, e)
       end
-
+      
       doc = Document.new(resp.to_xml)
       warn(doc) if $DEBUG
       
@@ -360,5 +402,34 @@ module WLAPI
       result.any? ? result : nil
     end
 
+    def check_params(*args)
+      m = caller(1).first.match(/^.+`(.*)'$/)[1]
+      num_of_args = self.method(m.to_sym).arity
+      messages = []
+
+      # Arity can be negativ => .abs.
+      case num_of_args.abs
+      when 1
+        messages << msg(args[0], m, 'String') unless args[0].is_a?(String)
+      when 2
+        messages << msg(args[0], m, 'String') unless args[0].is_a?(String)
+        messages << msg(args[1], m, 'Numeric') unless args[1].is_a?(Fixnum)
+      when 3
+        messages << msg(args[0], m, 'String') unless args[0].is_a?(String)
+        unless args[1].is_a?(String) || args[1].is_a?(Fixnum)
+          messages << msg(args[1], m, 'String or Numeric')
+        end
+        messages << msg(args[2], m, 'Numeric') unless args[2].is_a?(Fixnum)
+      end
+
+      if messages.any?
+        fail WLAPI::UserError, messages.join("\n")
+      end
+    end
+
+    def msg(arg, meth, cls)
+      "Argument <#{arg}> for the method <#{meth}> should be a <#{cls}>, " +
+      "not <#{arg.class}>!"
+    end
   end # class
 end # module

data/lib/wlapi/error.rb

@@ -0,0 +1,16 @@
+module WLAPI
+
+  class Error < StandardError; end
+
+  class ExternalError < Error
+    def initialize(e)
+      msg = "Some external error occured:\n"
+      msg << "#{e.class}: #{e.message}"        
+
+      super(msg)
+    end
+  end
+
+  class UserError < Error; end
+
+end

data/lib/wlapi/version.rb

@@ -1,3 +1,3 @@
 module WLAPI
-  VERSION = '0.8.1'
+  VERSION = '0.8.3'
 end

data/test/test_api.rb

@@ -1,11 +1,49 @@
 # -*- coding: utf-8 -*-
 require 'test/unit'
-require 'fakeweb'
 require 'wlapi'
 
 
 class TestApi < Test::Unit::TestCase
 
+  METHODS = [:baseform,
+             :domain,
+             :wordforms,
+             :thesaurus,
+             :synonyms,
+             :sentences,
+             :left_neighbours,
+             :right_neighbours,
+             :similarity,
+             :experimental_synonyms,
+             :right_collocation_finder,
+             :left_collocation_finder,
+             :cooccurrences,
+             :cooccurrences_all,
+             :intersection,
+             :frequencies
+            ]
+
+  ONE_PAR = [:frequencies,
+             :baseform,
+             :domain
+            ]
+  
+  THREE_PAR = [:right_collocation_finder,
+               :left_collocation_finder,
+               :cooccurrences,
+               :cooccurrences_all,
+               :intersection
+              ]
+
+  TWO_PAR = [:wordforms,
+             :thesaurus,
+             :synonyms,
+             :sentences,
+             :left_neighbours,
+             :right_neighbours,
+             :similarity,
+             :experimental_synonyms
+            ]
   def setup
     @api = WLAPI::API.new
     @word = 'Stuhl'
@@ -14,232 +52,236 @@ class TestApi < Test::Unit::TestCase
   def teardown
   end
   
-  # test constants
+  # Test constants.
   def test_constants
     assert(WLAPI::VERSION.is_a?(String))
     assert_equal(false, WLAPI::VERSION.empty?)
   end
-=begin
-  # It should generate a valid soap request for some input.
-  def test_soap_generation
-    file = 'test/data/soap_request.txt'
-    soap = File.read(file)
-    
-    url = 'http://wortschatz.uni-leipzig.de/axis/services/Thesaurus'
-    FakeWeb.register_uri(:post, url, :response => http_resp)
 
-    actual_api_answer = query.get
-    assert_instance_of(String, actual_api_answer, 'Not String!')
-    assert_equal(expected_api_answer, actual_api_answer)
+  def test_availability_of_pulic_methods
+    METHODS.each { |m| assert_respond_to(@api, m) }
   end
-=end
-  # one parameter
-  def test_frequencies
-    assert_respond_to(@api, :frequencies)
+
+  def test_for_absent_arguments
     assert_raise(ArgumentError) do
-      @api.frequencies(@word, 5)
+      METHODS.each { |m| @api.send(m) }
     end
+  end
+
+  def test_for_redundant_arguments
+
     assert_raise(ArgumentError) do
-      @api.frequencies
+      ONE_PAR.each { |m| @api.send(m, 'a', 2) }
     end
-    response = @api.frequencies(@word)
-    assert_not_nil(response)
-    assert_instance_of(Array, response)
-    assert(!response.empty?)
+
+    assert_raise(ArgumentError) do
+      TWO_PAR.each { |m| @api.send(m, 'a', 2, 3) }
+    end
+    
+
+    assert_raise(ArgumentError) do
+      THREE_PAR.each { |m| @api.send(m, 'a', 'a', 3, 4) }
+    end    
+  end
+
+  def test_argument_semantics
+    assert_raise(WLAPI::UserError) do
+      ONE_PAR.each { |m| @api.send(m, 1) }
+    end
+=begin
+    assert_raise(WLAPI::UserError) do
+      TWO_PAR.each { |m| @api.send(m, 'Haus', 1) }
+    end
+=end  
+    assert_raise(WLAPI::UserError) do
+      THREE_PAR.each { |m| @api.send(m, 3, 3.5, 'a') }
+    end
+  end  
+  # One parameter.
+  def test_frequencies
+    response = @api.frequencies('Haus')
+    check_response(response)
+
     assert_equal(2, response.size)
     assert_match(/\d+/, response[0])
     assert_match(/\d+/, response[1])
+    assert_equal(["122072", "7"], response)
   end
 
   def test_baseform
-    assert_respond_to(@api, :baseform)
-    assert_raise(ArgumentError) do
-      @api.baseform(@word, 5)
-    end
-    assert_raise(ArgumentError) do
-      @api.baseform
-    end
-    response = @api.baseform(@word)
-    assert_not_nil(response)
-    assert_instance_of(Array, response)
-    assert(!response.empty?)
+    response = @api.baseform('Autos')
+    check_response(response)
+
     assert_equal(2, response.size)
     assert_match(/\w+/, response[0])
     assert_match(/[AVN]/, response[1])
+    assert_equal(["Auto", "N"], response)
   end
 
   def test_domain
-    assert_respond_to(@api, :domain)
-    assert_raise(ArgumentError) do
-      @api.domain(@word, 5)
-    end
-    assert_raise(ArgumentError) do
-      @api.domain
-    end
-    response = @api.domain(@word)
-    assert_not_nil(response)
-    assert_instance_of(Array, response)
-    assert(!response.empty?)
-    # we cannot predict the minimal structure of the response
+    response = @api.domain('Buch')
+    check_response(response)
+
+    expected_response = ["Sprachwissenschaft",
+                         "Nachname",
+                         "Stadt",
+                         "Buchkunde/Buchhandel",
+                         "Motive",
+                         "Literarische/Motive/Stoffe/Gestalten",
+                         "Buchkunde/Buchhandel",
+                         "Papierherstellung/Graphische/Technik",
+                         "Buchkunde/Buchhandel",
+                         "Bücher",
+                         "Ort in D"
+                        ]
+    assert_equal(expected_response, response)
+    # We cannot predict the minimal structure of the response.
   end
   
   # two parameters
   def test_wordforms
-    assert_respond_to(@api, :wordforms)
-    assert_raise(ArgumentError) do
-      @api.wordforms
-    end
-    assert_raise(ArgumentError) do
-      @api.wordforms(1, 2, 3)
-    end
-    response = @api.wordforms(@word)
-    assert_not_nil(response)
-    assert_instance_of(Array, response)
-    assert(!response.empty?)
+    response = @api.wordforms('Buch')
+    check_response(response)
+
+    expected_response = ["Buch",
+                         "Bücher",
+                         "Büchern",
+                         "Buches",
+                         "Buchs",
+                         "Bucher"
+                        ]
+    assert_equal(expected_response, response)
   end
 
   def test_thesaurus
-    assert_respond_to(@api, :thesaurus)
-    assert_raise(ArgumentError) do
-      @api.thesaurus
-    end
-    assert_raise(ArgumentError) do
-      @api.thesaurus(1, 2, 3)
-    end
-    response = @api.thesaurus(@word)
-    assert_not_nil(response)
-    assert_instance_of(Array, response)
-    assert(!response.empty?)
+    response = @api.thesaurus('Buch')
+    check_response(response)
+
+    expected_response = ["Buch", "Titel", "Werk", "Zeitung", "Band",
+                         "Literatur", "Zeitschrift", "Bruch", "Lektüre",
+                         "Schrift"]
+    assert_equal(expected_response, response)
   end
 
   def test_synonyms
-    assert_respond_to(@api, :synonyms)
-    assert_raise(ArgumentError) do
-      @api.synonyms
-    end
-    assert_raise(ArgumentError) do
-      @api.synonyms(1, 2, 3)
-    end
-    response = @api.synonyms(@word)
-    assert_not_nil(response)
-    assert_instance_of(Array, response)
-    assert(!response.empty?)
+    response = @api.synonyms('Brot')
+    check_response(response)
+
+    expected_response = ["Laib", "Brotlaib", "Laib", "Schnitte", "Stulle"]
+    assert_equal(expected_response, response)
   end
 
   def test_sentences
-    assert_respond_to(@api, :sentences)
-    assert_raise(ArgumentError) do
-      @api.sentences
-    end
-    assert_raise(ArgumentError) do
-      @api.sentences(1, 2, 3)
-    end
-    response = @api.sentences(@word)
-    assert_not_nil(response)
-    assert_instance_of(Array, response)
-    assert(!response.empty?)
+    response = @api.sentences('Klasse', 1)
+    check_response(response)
+    expected_response = ["40829928",
+                         "Bei den Grünen war ich wohl im Urteil der politisch korrekten Klasse bei den Richtigen, auch wenn ich in ihren Augen das Falsche sagte."] 
+    assert_equal(expected_response, response)
   end
 
   def test_left_neighbours
-    assert_respond_to(@api, :left_neighbours)
-    assert_raise(ArgumentError) do
-      @api.left_neighbours
-    end
-    assert_raise(ArgumentError) do
-      @api.left_neighbours(1, 2, 3)
-    end
-    response = @api.left_neighbours(@word)
-    assert_not_nil(response)
-    assert_instance_of(Array, response)
-    assert(!response.empty?)
+    response = @api.left_neighbours('Stuhl', 2)
+    check_response(response)
+
+    expected_response = ["elektrischen", "Stuhl", "626",
+                         "seinem", "Stuhl", "592"]
+    assert_equal(expected_response, response)
   end
 
   def test_right_neighbours
-    assert_respond_to(@api, :right_neighbours)
-    assert_raise(ArgumentError) do
-      @api.right_neighbours
-    end
-    assert_raise(ArgumentError) do
-      @api.right_neighbours(1, 2, 3)
-    end
-    response = @api.right_neighbours(@word)
-    assert_not_nil(response)
-    assert_instance_of(Array, response)
-    assert(!response.empty?)
+    response = @api.right_neighbours('Stuhl', 2)
+    check_response(response)
+
+    expected_response = ["Stuhl", "räumen", "189",
+                         "Stuhl", "hin und her", "130"]
+    assert_equal(expected_response, response)
   end
 
   def test_similarity
-    assert_respond_to(@api, :similarity)
-    assert_raise(ArgumentError) do
-      @api.similarity
-    end
-    assert_raise(ArgumentError) do
-      @api.similarity(1, 2, 3)
-    end
-    response = @api.similarity(@word)
-    assert_not_nil(response)
-    assert_instance_of(Array, response)
-    assert(!response.empty?)
+    response = @api.similarity('Stuhl', 3)
+    check_response(response)
+
+    expected_response = ["Stuhl", "Sessel", "26",
+                         "Stuhl", "Lehnstuhl", "24",
+                         "Stuhl", "Sofa", "21"] 
+    assert_equal(expected_response, response)   
   end
 
   def test_experimental_synonyms
-    assert_respond_to(@api, :experimental_synonyms)
-    assert_raise(ArgumentError) do
-      @api.experimental_synonyms
-    end
-    assert_raise(ArgumentError) do
-      @api.experimental_synonyms(1, 2, 3)
-    end
-    response = @api.experimental_synonyms(@word)
-    assert_not_nil(response)
-    assert_instance_of(Array, response)
-    assert(!response.empty?)
+    response = @api.experimental_synonyms('Stuhl')
+    check_response(response)
+
+    expected_response = ["Einrichtungsgegenstand", "v",
+                         "Bett", "v",
+                         "Lampe", "v",
+                         "Tisch", "v",
+                         "Schrank", "v",
+                         "Teppich", "v",
+                         "Gebrauchsmöbel", "v",
+                         "Möbelstück", "v",
+                         "Bank", "v",
+                         "Bord", "v"
+                        ]
+    assert_equal(expected_response, response)
   end
   
   # three parameters
   def test_right_collocation_finder
-    assert_respond_to(@api, :right_collocation_finder)
-        assert_raise(ArgumentError) do
-      @api.right_collocation_finder
-    end
-    assert_raise(ArgumentError) do
-      @api.right_collocation_finder(1, 2, 3, 4)
-    end
-    response = @api.right_collocation_finder(@word, 'V')
-    assert_not_nil(response)
-    assert_instance_of(Array, response)
-    assert(!response.empty?)
+    response = @api.right_collocation_finder('Stuhl', 'V', 3)
+    check_response(response)
+
+    expected_response = ["Stuhl", "aufmöbeln", "V",
+                         "Stuhl", "aufreihen", "V",
+                         "Stuhl", "aufspringen", "V"
+                        ]
+    assert_equal(expected_response, response) 
   end
 
   def test_left_collocation_finder
-    assert_respond_to(@api, :left_collocation_finder)
-    assert_raise(ArgumentError) do
-      @api.left_collocation_finder
-    end
-    assert_raise(ArgumentError) do
-      @api.left_collocation_finder(1, 2, 3, 4)
-    end
-    response = @api.left_collocation_finder(@word, 'A')
-    assert_not_nil(response)
-    assert_instance_of(Array, response)
-    assert(!response.empty?)
+    response = @api.left_collocation_finder('Stuhl', 'A', 3)
+    check_response(response)
+    expected_response = ["Hl", "A", "Stuhl",
+                         "abwaschbar", "A", "Stuhl",
+                         "alle", "A", "Stuhl"
+                        ]
+    assert_equal(expected_response, response) 
   end
 
   def test_cooccurrences
-    assert_raise(NotImplementedError) do
-      @api.cooccurrences(@word, 1, 10)
-    end
+    response = @api.cooccurrences('Haus', 10000)
+    check_response(response)
+    expected_response = ["Haus", "das", "11747"]
+    
+    assert_equal(expected_response, response) 
   end
 
   def test_cooccurrences_all
-    assert_raise(NotImplementedError) do
-      @api.cooccurrences_all(@word, 1, 10)
+    begin
+      @api.cooccurrences_all('Haus', 10000)
+    rescue RuntimeError => e
+      assert_match(/You're not allowed to access this service./, e.message)
     end
+    # Not possible to test without access credential.
   end
 
   def test_intersection
-    assert_raise(NotImplementedError) do
-      @api.intersection(@word, @word, 10)
+    begin
+      @api.intersection('Haus', 'Brot', 1)
+    rescue RuntimeError => e
+      assert_match(/You're not allowed to access this service./, e.message)
     end
+    # Not possible to test without access credentials.
+  end
+
+
+################## HELPER METHODS ###############################################
+  def check_input(*args)
+  end
+
+  
+  def check_response(response)
+    assert_not_nil(response)
+    assert_instance_of(Array, response)
+    assert(response.any?)
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: wlapi
 version: !ruby/object:Gem::Version 
-  hash: 61
+  hash: 57
   prerelease: 
   segments: 
   - 0
   - 8
-  - 1
-  version: 0.8.1
+  - 3
+  version: 0.8.3
 platform: ruby
 authors: 
 - Andrei Beliankou
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-18 00:00:00 Z
+date: 2011-12-16 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: savon
@@ -64,7 +64,7 @@ dependencies:
   type: :development
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
-  name: rdoc
+  name: yard
   prerelease: false
   requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
@@ -78,7 +78,7 @@ dependencies:
   type: :development
   version_requirements: *id004
 - !ruby/object:Gem::Dependency 
-  name: yard
+  name: rake
   prerelease: false
   requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
@@ -91,48 +91,6 @@ dependencies:
         version: "0"
   type: :development
   version_requirements: *id005
-- !ruby/object:Gem::Dependency 
-  name: fakeweb
-  prerelease: false
-  requirement: &id006 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :development
-  version_requirements: *id006
-- !ruby/object:Gem::Dependency 
-  name: rake
-  prerelease: false
-  requirement: &id007 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :development
-  version_requirements: *id007
-- !ruby/object:Gem::Dependency 
-  name: ruby-debug
-  prerelease: false
-  requirement: &id008 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :development
-  version_requirements: *id008
 description: WLAPI is a programmatic API for web services provided by the project Wortschatz, University of Leipzig. These services are a great source of linguistic knowledge for morphological, syntactic and semantic analysis of German both for traditional and Computational Linguistics (CL). Use this API to gain data on word frequencies, left and right neighbours, collocations and semantic similarity. Check it out if you are interested in Natural Language Processing (NLP) and Human Language Technology (HLT).
 email: a.belenkow@uni-trier.de
 executables: []
@@ -140,16 +98,17 @@ executables: []
 extensions: []
 
 extra_rdoc_files: 
-- README
-- LICENSE
-- CHANGELOG
+- README.rdoc
+- LICENSE.rdoc
+- CHANGELOG.rdoc
 files: 
+- lib/wlapi/error.rb
 - lib/wlapi/version.rb
 - lib/wlapi/api.rb
 - lib/wlapi.rb
-- README
-- LICENSE
-- CHANGELOG
+- README.rdoc
+- LICENSE.rdoc
+- CHANGELOG.rdoc
 - .yardopts
 - test/test_api.rb
 - test/data/soap_request.txt
@@ -159,7 +118,7 @@ licenses: []
 post_install_message: 
 rdoc_options: 
 - -m
-- README
+- README.rdoc
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -184,8 +143,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: "0"
 requirements: []
 
-rubyforge_project: wlapi
-rubygems_version: 1.8.7
+rubyforge_project: 
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: WLAPI is a programmatic API for web services provided by the project Wortschatz, University of Leipzig. Use different linguistic services such as synonym and collocation search.