wlapi 0.7.4 → 0.8.0

data/CHANGELOG

@@ -1,4 +1,8 @@
 == COMPLETED
+=== 0.8.0
+WLAPI depends on Savon <tt>>=0.8.0</tt>
+with all interface changes have been implemented.
+
 === 0.7.4
 Small fixes in the project infrastructure and test refactoring.
 === 0.7.3
@@ -9,8 +13,12 @@ Initial release of the lib.
 
 
 == PLANNED
-=== 0.8.0
-Reimplement the lib using the latest version of savon.
+=== 0.8.1
+Refactore all test and implement server response stubs with +fakeweb+.
+=== 0.8.2
+Introduce +nokogiri+ for parsing responses.
+=== 0.8.3
+Implement an error handling strategy.
 === 0.9.0
 === 1.0.0
 

data/README

@@ -5,25 +5,79 @@
 * {WLAPI Project Page}[http://wlapi.rubyforge.org/]
 
 == DESCRIPTION
+WLAPI is a programmatic API for web services provided by the project
+{Wortschatz}[http://wortschatz.uni-leipzig.de/],
+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).
 
-WLAPI is a simple API for Wortschatz Leipzig project.
+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).
+=== Implemented Features
+You can use the following search methods:
+* baseform;
+* cooccurrences;
+* cooccurrences_all;
+* domain;
+* experimental_synonyms;
+* frequencies;
+* intersection;
+* left_collocation_finder;
+* left_neighbours;
+* right_collocation_finder;
+* right_neighbours;
+* sentences;
+* similarity;
+* synonyms;
+* thesaurus;
+* wordforms.
 
 == INSTALLATION
+WLAPI is provided as a .gem package. Simply install it via
+{RubyGems}[http://rubygems.org/gems/wlapi].
+To install WLAPI ussue the following command:
+  $ gem install wlapi
+
+You might want to install versions prior to +0.8.0+, if you are bound on
+the old implementations of {savon}[http://savonrb.com/]:
+  $ gem install wlapi -v 0.7.4
+
+If you want to do a system wide installation, do this as root
+(possibly using +sudo+).
+
+Alternatively use your Gemfile for dependency management.
 
-WLAPI is provided as a .gem package. Simply install it via RubyGems.
 
 == SYNOPSIS
+
+Basic usage is very simple:
   $ require 'wlapi'
   $ api = WLAPI::API.new
   $ api.synonyms('Haus', 15) # returns an array with string values (UTF8 encoded)
-  $ api.domain('Auto') # returns an array with strings
+  $ api.domain('Auto') # => Array
 
-See documentation in the WLAPI::API class for details on particular methods.
+If you are going to send mass requests, please contact the support team
+of the project {Wortschatz}[http://wortschatz.uni-leipzig.de/], get your private
+credentials and instantiate an authenticated client:
+  $ require 'wlapi'
+  $ api = WLAPI::API.new(username, password)
+
+See documentation in the WLAPI::API class for details
+on particular search methods.
 
 == SUPPORT
+If you have question, bug reports or any suggestions, please drop me an email :) 
+Any help is deeply appreciated!
+
+== CHANGELOG
+For details on future plan and working progress see CHANGELOG.
 
-If you have question, bug reports or any suggestions, please drop me an email :) Any help is deeply appreciated!
+== CAUTION
+This library is <b>work in process</b>! Though the interface is mostly complete,
+you might face some not implemented features.
 
+Please contact me with your suggestions, bug reports and feature requests.
 == LICENSE
 
 WLAPI is a copyrighted software by Andrei Beliankou, 2010, 2011

data/lib/wlapi/api.rb

@@ -4,14 +4,8 @@
 # :title: Ruby based API for Wortschatz Leipzig web services
 # :main: README
 
-begin
-  gem('savon', '0.7.9')
-  require 'savon'
-rescue NoMethodError, LoadError
-  require 'rubygems'
-  retry
-end
-  
+require 'savon'
+
 # REXML is fast enough for our task.
 require 'rexml/document'
 include REXML
@@ -33,22 +27,22 @@ module WLAPI
       # This hash contains the URLs to the single services.
       endpoint = 'http://wortschatz.uni-leipzig.de/axis/services'
       @services = {
-        'Thesaurus' => "#{endpoint}/Thesaurus",
-        'Baseform' => "#{endpoint}/Baseform",
-        'Similarity' => "#{endpoint}/Similarity",
-        'Synonyms' => "#{endpoint}/Synonyms",
-        'Sachgebiet' => "#{endpoint}/Sachgebiet",
-        'Frequencies' => "#{endpoint}/Frequencies",
-        'Kookurrenzschnitt' => "#{endpoint}/Kookkurrenzschnitt",
-        'ExperimentalSynonyms' => "#{endpoint}/ExperimentalSynonyms",
-        'RightCollocationFinder' => "#{endpoint}/RightCollocationFinder",
-        'LeftCollocationFinder' => "#{endpoint}/LeftCollocationFinder",
-        'Wordforms' => "#{endpoint}/Wordforms",
-        'CooccurrencesAll' => "#{endpoint}/CooccurrencesAll",
-        'LeftNeighbours' => "#{endpoint}/LeftNeighbours",
-        'RightNeighbours' => "#{endpoint}/RightNeighbours",
-        'Sentences' => "#{endpoint}/Sentences",
-        'Cooccurrences' => "#{endpoint}/Cooccurrences"
+        :Thesaurus => "#{endpoint}/Thesaurus",
+        :Baseform => "#{endpoint}/Baseform",
+        :Similarity => "#{endpoint}/Similarity",
+        :Synonyms => "#{endpoint}/Synonyms",
+        :Sachgebiet => "#{endpoint}/Sachgebiet",
+        :Frequencies => "#{endpoint}/Frequencies",
+        :Kookurrenzschnitt => "#{endpoint}/Kookkurrenzschnitt",
+        :ExperimentalSynonyms => "#{endpoint}/ExperimentalSynonyms",
+        :RightCollocationFinder => "#{endpoint}/RightCollocationFinder",
+        :LeftCollocationFinder => "#{endpoint}/LeftCollocationFinder",
+        :Wordforms => "#{endpoint}/Wordforms",
+        :CooccurrencesAll => "#{endpoint}/CooccurrencesAll",
+        :LeftNeighbours => "#{endpoint}/LeftNeighbours",
+        :RightNeighbours => "#{endpoint}/RightNeighbours",
+        :Sentences => "#{endpoint}/Sentences",
+        :Cooccurrences => "#{endpoint}/Cooccurrences"
         # no MARSService and Kreuzwortrraetsel
       }
       
@@ -58,13 +52,17 @@ module WLAPI
       # we should investigate the typical user behaviour.
       # If only one service is used in the separate session => rewrite the class!
       @services.each do |key, val|
-        cl_name = '@cl_' + key
-        eval("#{cl_name} = Savon::Client.new(val)")
-        eval("#{cl_name}.request.basic_auth(login, pass)")
+        cl_name = '@cl_' + key.to_s
+        eval("#{cl_name} = Savon::Client.new { |wsdl| wsdl.endpoint = val}")
+        eval("#{cl_name}.wsdl.namespace = val")
+        eval("#{cl_name}.http.auth.basic(login, pass)")
       end
       
       # Savon creates very verbose logs, switching off.
-      Savon::Request.log = false unless $DEBUG
+      Savon.configure do |config|
+        config.log = false unless $DEBUG
+      end
+      HTTPI.log = false unless $DEBUG
     end
     
     # Main methods to access different services.
@@ -72,11 +70,11 @@ module WLAPI
     # You can define the limit for the result set, it defaults to 10.
     # If you want to get all the results, you should provide a number,
     # which would be greater than the result set since we cannot
-    # predict how many answers the server will give us. Just try it.
-    ##############################################################################
+    # predict how many answers the server will give us.
+    #############################################################################
     
     ## One parameter methods.
-    ##############################################################################
+    #############################################################################
     
     # Returns the frequency and frequency class of the input word.
     # Frequency class is computed in relation to the most frequent word
@@ -84,8 +82,9 @@ module WLAPI
     #   api.frequencies("Autos") => ["40614", "9"]
     def frequencies(word)
       arg1 = ['Wort', word]
-      answer = query(@cl_Frequencies, @services['Frequencies'], arg1)
-      return get_answer(answer)
+      answer = query(@cl_Frequencies, arg1)
+
+      get_answer(answer)
     end
     
     # Gets the baseform (whatever it is :) not lemma).
@@ -94,8 +93,9 @@ module WLAPI
     #   api.baseform("Auto") => ["Auto", "N"]
     def baseform(word)
       arg1 = ['Wort', word]
-      answer = query(@cl_Baseform, @services['Baseform'], arg1)
-      return get_answer(answer)
+      answer = query(@cl_Baseform, arg1)
+
+      get_answer(answer)
     end
     
     # Returns categories for a given input word as an array:
@@ -105,12 +105,13 @@ module WLAPI
     # let's call it domain, not sachgebiet
     def domain(word)
       arg1 = ['Wort', word]
-      answer = query(@cl_Sachgebiet, @services['Sachgebiet'], arg1)
-      return get_answer(answer)
+      answer = query(@cl_Sachgebiet, arg1)
+      
+      get_answer(answer)
     end
     
     ## Two parameter methods.
-    ##############################################################################
+    #############################################################################
     
     # Returns all other word forms of the same lemma for a given word form.
     #   api.wordforms("Auto") => ["Auto", "Autos"]
@@ -118,8 +119,9 @@ module WLAPI
       # note, it is the only service which requires 'Word', not 'Wort'
       arg1 = ['Word', word]
       arg2 = ['Limit', limit]
-      answer = query(@cl_Wordforms, @services['Wordforms'], arg1, arg2)
-      return get_answer(answer)
+      answer = query(@cl_Wordforms, arg1, arg2)
+      
+      get_answer(answer)
     end
     
     # As the Synonyms service returns synonyms of the given input word.
@@ -129,8 +131,9 @@ module WLAPI
     def thesaurus(word, limit = 10)
       arg1 = ['Wort', word]
       arg2 = ['Limit', limit]
-      answer = query(@cl_Thesaurus, @services['Thesaurus'], arg1, arg2)
-      return get_answer(answer)
+      answer = query(@cl_Thesaurus, arg1, arg2)
+      
+      get_answer(answer)
     end
     
     # This method searches for synonyms.
@@ -139,14 +142,16 @@ module WLAPI
     def synonyms(word, limit = 10)
       arg1 = ['Wort', word]
       arg2 = ['Limit', limit]
-      answer = query(@cl_Synonyms, @services['Synonyms'], arg1, arg2)
+      answer = query(@cl_Synonyms, arg1, arg2)
+
       # Synonym service provides multiple values, so we take only odd. 
-      return get_answer(answer, '[position() mod 2 = 1 ]')
+      get_answer(answer, '[position() mod 2 = 1 ]')
     end
     
     # Returns sample sentences containing the input word.
     # The return value is an array:
-    #   api.sentences("Auto") => ["40808144", "Zweitens der freche, frische Klang der Hupe
+    #   api.sentences("Auto") => ["40808144", "Zweitens der freche,
+    #   frische Klang der Hupe
     #   und drittens die hinreißend gestylten 16-Zoll-Felgen,
     #   die es leider nur für dieses Auto gibt.", ...]
     #--
@@ -154,8 +159,9 @@ module WLAPI
     def sentences(word, limit = 10)
       arg1 = ['Wort', word]
       arg2 = ['Limit', limit]
-      answer = query(@cl_Sentences, @services['Sentences'], arg1, arg2)
-      return get_answer(answer)
+      answer = query(@cl_Sentences, arg1, arg2)
+      
+      get_answer(answer)
     end
     
     # For a given input word, returns statistically significant left neighbours
@@ -166,8 +172,9 @@ module WLAPI
     def left_neighbours(word, limit = 10)
       arg1 = ['Wort', word]
       arg2 = ['Limit', limit]
-      answer = query(@cl_LeftNeighbours, @services['LeftNeighbours'], arg1, arg2)
-      return get_answer(answer)
+      answer = query(@cl_LeftNeighbours, arg1, arg2)
+      
+      get_answer(answer)
     end
     
     # For a given input word, returns statistically significant right neighbours
@@ -178,12 +185,14 @@ module WLAPI
     def right_neighbours(word, limit = 10)
       arg1 = ['Wort', word]
       arg2 = ['Limit', limit]
-      answer = query(@cl_RightNeighbours, @services['RightNeighbours'], arg1, arg2)
-      return get_answer(answer)
+      answer = query(@cl_RightNeighbours, arg1, arg2)
+      
+      get_answer(answer)
     end
     
     
-    # Returns automatically computed contextually similar words of the input word.
+    # Returns automatically computed contextually similar words
+    # of the input word.
     # Such similar words may be antonyms, hyperonyms, synonyms,
     # cohyponyms or other.
     # Note that due to the huge amount of data any query to this services
@@ -192,8 +201,9 @@ module WLAPI
     def similarity(word, limit = 10)
       arg1 = ['Wort', word]
       arg2 = ['Limit', limit]
-      answer = query(@cl_Similarity, @services['Similarity'], arg1, arg2)
-      return get_answer(answer)
+      answer = query(@cl_Similarity, arg1, arg2)
+      
+      get_answer(answer)
     end
     
     # This service delivers an experimental synonyms request for internal tests.
@@ -202,12 +212,13 @@ module WLAPI
     def experimental_synonyms(word, limit = 10)
       arg1 = ['Wort', word]
       arg2 = ['Limit', limit]
-      answer = query(@cl_ExperimentalSynonyms, @services['ExperimentalSynonyms'], arg1, arg2)
-      return get_answer(answer)
+      answer = query(@cl_ExperimentalSynonyms, arg1, arg2)
+      
+      get_answer(answer)
     end
     
     ## Three parameter methods.
-    ##############################################################################
+    #############################################################################
     
     # Attempts to find linguistic collocations that occur to the right
     # of the given input word.
@@ -215,13 +226,15 @@ module WLAPI
     # which stand for adjective, verb, noun and stopword respectively.
     # The parameter restricts the type of words found.
     # It returns an array:
-    #   api.right_collocation_finder("Auto", "V", 10) => ["Auto", "abfackeln", "V", ...]
+    #   api.right_collocation_finder("Auto", "V", 10) =>
+    #   ["Auto", "abfackeln", "V", ...]
     def right_collocation_finder(word, pos, limit = 10)
       arg1 = ['Wort', word]
       arg2 = ['Wortart', pos]
       arg3 = ['Limit', limit]
-      answer = query(@cl_RightCollocationFinder, @services['RightCollocationFinder'], arg1, arg2, arg3)
-      return get_answer(answer)
+      answer = query(@cl_RightCollocationFinder, arg1, arg2, arg3)
+      
+      get_answer(answer)
     end
     
     # Attempts to find linguistic collocations that occur to the left
@@ -230,14 +243,15 @@ module WLAPI
     # which stand for adjective, verb, noun and stopword respectively.
     # The parameter restricts the type of words found.
     # It returns an array:
-    #   api.left_collocation_finder("Stuhl", "A", 10) => ["apostolisch", "A", "Stuhl", ...]
+    #   api.left_collocation_finder("Stuhl", "A", 10) =>
+    #   ["apostolisch", "A", "Stuhl", ...]
     def left_collocation_finder(word, pos, limit = 10)
       arg1 = ['Wort', word]
       arg2 = ['Wortart', pos]
       arg3 = ['Limit', limit]
-      answer = query(@cl_LeftCollocationFinder,
-                     @services['LeftCollocationFinder'], arg1, arg2, arg3)
-      return get_answer(answer)
+      answer = query(@cl_LeftCollocationFinder, arg1, arg2, arg3)
+      
+      get_answer(answer)
     end
     
     # Returns statistically significant co-occurrences of the input word.
@@ -277,83 +291,73 @@ module WLAPI
     private
     
     # Main query method, it invokes the soap engine.
-    # This method combines all the data to one SOAP request and gets the answer.
-    # It is not compatible with one and three parameter methods yet.
-    # args contains an array [[key1, value1], [key2, value2], [key3, value3]]
-    # with keys and values for the soap query
-    def query(cl, namespace, *args)
-      
-      # Calling the action with ! (disables the wsdl query).
-      # wsdl is disabled since calling the server for wsdl can last too long.
-      resp = cl.execute! do |soap|
-        
-        # adding a namespace, wsdl is disabled
-        soap.namespace = namespace
-
-        soap.namespaces['xmlns:soapenv'] = "http://schemas.xmlsoap.org/soap/envelope/"
+    # It combines all the data to one SOAP request and gets the answer.
+    # <args> contains an array [[key1, value1], [key2, value2], [key3, value3]]
+    # 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'] = "urn:#{namespace.sub(/.+ces\//, '')}"
-        
-        soap.namespaces['xmlns:dat'] = "http://datatypes.webservice.wortschatz.uni_leipzig.de"
+        soap.namespaces['xmlns:urn'] = cl.wsdl.namespace
         
+        soap.namespaces['xmlns:dat'] =
+          "http://datatypes.webservice.wortschatz.uni_leipzig.de"
 
-        body = "<urn:objRequestParameters>"
-        body << "<urn:corpus>de</urn:corpus>"
-        body << "<urn:parameters>"
+        v = []
+        body = {
+          'urn:objRequestParameters' => {
+            'urn:corpus' => 'de',
+            'urn:parameters' => {
+              'urn:dataVectors' => v
+            }
+          }
+        }
 
-        # setting the first argument (usually 'Wort')
-        if args[0]
-        body << "<urn:dataVectors><dat:dataRow>#{args[0][0]}</dat:dataRow><dat:dataRow>#{args[0][1]}</dat:dataRow></urn:dataVectors>"
-        end
+        # 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]
 
-        # setting the second argument (usually 'Limit')
-        if args[1]
-          body << "<urn:dataVectors><dat:dataRow>#{args[1][0]}</dat:dataRow><dat:dataRow>#{args[1][1]}</dat:dataRow></urn:dataVectors>"
-        end
-
-        # setting setting the third argument (no common value)
-        if args[2]
-          body << "<urn:dataVectors><dat:dataRow>#{args[2][0]}</dat:dataRow><dat:dataRow>#{args[2][1]}</dat:dataRow></urn:dataVectors>"
-        end
-        body << "</urn:parameters>"
-        body << "</urn:objRequestParameters>"
-        
         soap.body = body
-        
-
-
-        STDERR.puts soap.to_xml if $DEBUG
+        warn(soap.to_xml) if $DEBUG
 
       end
 
       doc = Document.new(resp.to_xml)
+      warn(doc) if $DEBUG
       
-      STDERR.puts doc if $DEBUG
-      
-      return doc
-      
+      doc      
     end
     
     # This method extracts valuable data from the XML structure
     # of the soap response. It returns an array with extracted xml text nodes
     # or nil, if the service provided no answer.
-    # The same collection is printed to stderr in the DEBUG mode.
-    #--
-    # TODO: what if the answer is empty?
     def get_answer(doc, mod='')
       result = []
       # The path seems to be weird, because the namespaces change incrementally
       # in the output, so I don't want to treat it here.
       # A modifier needed because synonyms service provides duplicate values.
-      XPath.each(doc, "//result/*/*#{mod}") {|el| STDERR.puts el.text} if $DEBUG
-      XPath.each(doc, "//result/*/*#{mod}") {|el| result << el.text}
-
-      if result.empty?
-        return nil
+      XPath.each(doc, "//result/*/*#{mod}") do |el|
+        warn(el.text) if $DEBUG
+        result << el.text
       end
-      
-      return result
+
+      result.any? ? result : nil
     end
 
   end # class

data/lib/wlapi/version.rb

@@ -1,3 +1,3 @@
 module WLAPI
-  VERSION = '0.7.4'
+  VERSION = '0.8.0'
 end

data/test/data/soap_request.txt

@@ -0,0 +1 @@
+<?xml version="1.0" encoding="UTF-8"?><env:Envelope xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dat="http://datatypes.webservice.wortschatz.uni_leipzig.de" xmlns:urn="http://wortschatz.uni-leipzig.de/axis/services/Thesaurus" xmlns:env="http://schemas.xmlsoap.org/soap/envelope/"><env:Body><urn:execute><urn:objRequestParameters><urn:parameters><urn:dataVectors><dat:dataRow>Wort</dat:dataRow><dat:dataRow>Haus</dat:dataRow></urn:dataVectors><urn:dataVectors><dat:dataRow>Limit</dat:dataRow><dat:dataRow>10</dat:dataRow></urn:dataVectors></urn:parameters><urn:corpus>de</urn:corpus></urn:objRequestParameters></urn:execute></env:Body></env:Envelope>

data/test/test_api.rb

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 require 'test/unit'
+require 'fakeweb'
 require 'wlapi'
 
 
@@ -15,9 +16,23 @@ class TestApi < Test::Unit::TestCase
   
   # test constants
   def test_constants
-    assert(WLAPI::VERSION.is_a?(String) && ! WLAPI::VERSION.empty?)
-  end
-  
+    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)
+  end
+=end
   # one parameter
   def test_frequencies
     assert_respond_to(@api, :frequencies)
@@ -227,11 +242,4 @@ class TestApi < Test::Unit::TestCase
       @api.intersection(@word, @word, 10)
     end
   end
-
-  # private methods
-  def test_query
-  end
-
-  def test_get_answer
-  end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: wlapi
 version: !ruby/object:Gem::Version 
-  hash: 11
+  hash: 63
   prerelease: 
   segments: 
   - 0
-  - 7
-  - 4
-  version: 0.7.4
+  - 8
+  - 0
+  version: 0.8.0
 platform: ruby
 authors: 
 - Andrei Beliankou
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-08-11 00:00:00 Z
+date: 2011-08-19 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: savon
@@ -23,14 +23,12 @@ dependencies:
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - "="
+    - - ">="
       - !ruby/object:Gem::Version 
-        hash: 17
+        hash: 3
         segments: 
         - 0
-        - 7
-        - 9
-        version: 0.7.9
+        version: "0"
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -50,7 +48,7 @@ dependencies:
   type: :development
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: fakeweb
+  name: yard
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
@@ -63,7 +61,21 @@ dependencies:
         version: "0"
   type: :development
   version_requirements: *id003
-description: WLAPI is a programmatic API for web services provided by the project Wortschatz, University of Leipzig.
+- !ruby/object:Gem::Dependency 
+  name: fakeweb
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+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: []
 
@@ -82,6 +94,7 @@ files:
 - CHANGELOG
 - .yardopts
 - test/test_api.rb
+- test/data/soap_request.txt
 homepage: http://www.uni-trier.de/index.php?id=34451
 licenses: []
 
@@ -120,3 +133,4 @@ 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.
 test_files: 
 - test/test_api.rb
+- test/data/soap_request.txt