wlapi 0.0.6 → 0.7.1

data/lib/wlapi.rb

@@ -1,267 +1 @@
-# 2010-, Andrei Beliankou
-# Version: 0.0.4
-# :title: Ruby based API for Wortschatz Leipzig web services
-
-
-# SAVON is a SOAP client.
-require 'savon'
-
-# REXML is fast enough for our task.
-require 'rexml/document'
-include REXML
-
-# Top level namespace wrapper for WLAPI
-module WLAPI
-
-  # This class represents an interface to the linguistic web services
-# provided by the University of Leipzig.
-  #
-  # See the project 'Wortschatz Leipzig' for more details.
-  class API
-    
-    # At the creation point clients for all services are being instantiated.
-    # You can also set the login and the password (it defaults to 'anonymous').
-    def initialize(login = 'anonymous', pass = 'anonymous')
-      # This hash contains the URLs to the single services.
-      @services = {
-        'Thesaurus' => 'http://wortschatz.uni-leipzig.de/axis/services/Thesaurus',
-        'Baseform' => 'http://wortschatz.uni-leipzig.de/axis/services/Baseform',
-        'Similarity' => 'http://wortschatz.uni-leipzig.de/axis/services/Similarity',
-        'Synonyms' => 'http://wortschatz.uni-leipzig.de/axis/services/Synonyms',
-        'Sachgebiet' => 'http://wortschatz.uni-leipzig.de/axis/services/Sachgebiet',
-        'Frequencies' => 'http://wortschatz.uni-leipzig.de/axis/services/Frequencies',
-        'Kookurrenzschnitt' => 'http://wortschatz.uni-leipzig.de/axis/services/Kookkurrenzschnitt',
-        'ExperimentalSynonyms' => 'http://wortschatz.uni-leipzig.de/axis/services/ExperimentalSynonyms',
-        'RightCollocationFinder' => 'http://wortschatz.uni-leipzig.de/axis/services/RightCollocationFinder',
-        'LeftCollocationFinder' => 'http://wortschatz.uni-leipzig.de/axis/services/LeftCollocationFinder',
-        'Wordforms' => 'http://wortschatz.uni-leipzig.de/axis/services/Wordforms',
-        'CooccurrencesAll' => 'http://wortschatz.uni-leipzig.de/axis/services/CooccurrencesAll',
-        'LeftNeighbours' => 'http://wortschatz.uni-leipzig.de/axis/services/LeftNeighbours',
-        'RightNeighbours' => 'http://wortschatz.uni-leipzig.de/axis/services/RightNeighbours',
-        'Sentences' => 'http://wortschatz.uni-leipzig.de/axis/services/Sentences',
-        'Cooccurrences' => 'http://wortschatz.uni-leipzig.de/axis/services/Cooccurrences'
-        # no MARSService and Kreuzwortrraetsel
-      }
-      
-      # cl short for client.
-      # Dynamically create all the clients and set access credentials.
-      # It can be a very bad idea to instantiate all the clients at once,
-      # 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)")
-      end
-      
-      # Savon creates very verbose logs, switching off.
-      Savon::Request.log = false unless $DEBUG
-    end
-    
-    # Main methods to access different services.
-    #
-    # 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.
-    ##############################################################################
-    
-    ## One parameter methods.
-    ##############################################################################
-    
-    # Returns the frequency and frequency class of the input word.
-    # Frequency class is computed in relation to the most frequent word
-    # in the corpus. The higher the class, the rarer the word.
-    def frequencies
-      raise 'Not implemented yet!'
-    end
-    
-    # This method gets the baseform (whatever it is :) not lemma).
-    # Returns the lemmatized (base) form of the input word.
-    def baseform
-      raise 'Not implemented yet!'
-    end
-    
-    # Returns categories for a given input word.
-    # --
-    # Is it a good name? all names are in English, but here..
-    # let's call it domain, not sachgebiet
-    def domain
-      raise 'Not implemented yet!'
-    end
-    
-    ## Two parameter methods.
-    ##############################################################################
-    
-    # Returns all other word forms of the same lemma for a given word form .
-    # --
-    # malformed soap, investigate!!!
-    # doesn't function
-    def wordforms(word, limit)
-      raise 'Not implemented yet!' # remove later
-      answer = query(word, limit, @cl_Wordforms, @services['Wordforms'])
-      return get_answer(answer)
-    end
-    
-    # As the Synonyms service returns synonyms of the given input word.
-    # However, this first builds a lemma of the input word
-    # and thus returns more synonyms.
-    def thesaurus(word, limit = 10)
-      answer = query(word, limit, @cl_Thesaurus, @services['Thesaurus'])
-      return get_answer(answer)
-    end
-    
-    # This method searches for synonyms.
-    # Returns synonyms of the input word. In other words, this is a thesaurus.
-    def synonyms(word, limit = 10)
-      answer = query(word, limit, @cl_Synonyms, @services['Synonyms'])
-      # Synonym service provide multiple values, so we take only odd. 
-      return get_answer(answer, '[position() mod 2 = 1 ]')
-    end
-    
-    # ok, but results should be filtered
-    # Returns sample sentences containing the input word.
-    def sentences(word, limit)
-      answer = query(word, limit, @cl_Sentences, @services['Sentences'])
-      return get_answer(answer)
-    end
-    
-    # For a given input word, returns statistically significant left neighbours
-    # (words co-occurring immediately to the left of the input word).
-    # --
-    # ok, but results should be filtered
-    def left_neighbours(word, limit)
-      answer = query(word, limit, @cl_LeftNeighbours, @services['LeftNeighbours'])
-      return get_answer(answer)
-    end
-    
-    # For a given input word, returns statistically significant right neighbours
-    # (words co-occurring immediately to the right of the input word).
-    # --
-    # ok, but results should be filtered
-    def right_neighbours(word, limit)
-      answer = query(word, limit, @cl_RightNeighbours, @services['RightNeighbours'])
-      return get_answer(answer)
-    end
-    
-    
-    # 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
-    # may take a long time.
-    def similarity
-      raise 'Not implemented yet!'
-    end
-    
-    # This service delivers an experimental synonyms request for internal tests.
-    # --
-    # don't know, if we have to include this service...
-    def experimental_synonyms
-      raise 'Not implemented yet!'
-    end
-    
-    ## Three parameter methods.
-    ##############################################################################
-    
-    # Attempts to find linguistic collocations that occur to the right
-    # of the given input word.
-    # The parameter Wortart accepts four values A,V,N,S which stand for adjective,
-    # verb, noun and stopword, respectively.
-    # The parameter restricts the type of words found. 
-    def right_collocation_finder
-      raise 'Not implemented yet!'
-    end
-    
-    # Attempts to find linguistic collocations that occur to the left
-    # of the given input word.
-    # The parameter Wortart accepts four values A,V,N,S which stand for adjective,
-    # verb, noun and stopword, respectively.
-    # The parameter restricts the type of words found.
-    def left_collocation_finder
-      raise 'Not implemented yet!'
-    end
-    
-    # Returns statistically significant co-occurrences of the input word.
-    def cooccurrences
-      raise 'Not implemented yet!'
-    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,
-    # which means significantly longer wait times.
-    def cooccurrences_all
-      raise 'Not implemented yet!'
-    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,
-    # this make take some time.
-    # --
-    # let's call it intersection, not kookurrenzschnitt
-    def intersection
-      raise 'Not implemented yet!'
-    end
-    
-    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.
-    def query(word, limit, cl, namespace)
-      # 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
-        
-        body = <<EOF
-<urn:objRequestParameters>
-  <urn:corpus>de</urn:corpus>
-  <urn:parameters>
-    <urn:dataVectors>
-      <dat:dataRow>Wort</dat:dataRow>
-      <dat:dataRow>#{word}</dat:dataRow>
-    </urn:dataVectors>
-    <urn:dataVectors>
-      <dat:dataRow>Limit</dat:dataRow>
-      <dat:dataRow>#{limit}</dat:dataRow>
-    </urn:dataVectors>
-  </urn:parameters>
-</urn:objRequestParameters>
-EOF
-        
-        soap.body = body
-        
-        soap.namespaces['xmlns:soapenv'] = "http://schemas.xmlsoap.org/soap/envelope/"
-        # Every service has a different namespace, but it doesn't matter.
-        soap.namespaces['xmlns:urn'] = "urn:#{namespace.sub(/.+ces\//, '')}"
-        
-        soap.namespaces['xmlns:dat'] = "http://datatypes.webservice.wortschatz.uni_leipzig.de"
-      end
-      
-      doc = Document.new(resp.to_xml)
-      
-      STDERR.puts doc if $DEBUG
-      
-      return doc
-      
-    end
-    
-    # This method extracts valuable data from the XML structure
-    # of the soap response. It returns an array with extracted xml text nodes
-    # and prints out the same collection in the DEBUG mode.
-    def get_answer(doc, mod='')
-      result = []
-      # The path seems to be weird, but 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}
-      return result
-    end
-  end
-end
+require 'wlapi/api'

data/test/test_api.rb

@@ -0,0 +1,233 @@
+# -*- coding: utf-8 -*-
+require 'rubygems'
+require 'test/unit'
+require 'wlapi'
+
+
+class TestApi < Test::Unit::TestCase
+
+  def setup
+    @api = WLAPI::API.new
+    @word = 'Stuhl'
+  end
+
+  def teardown
+  end
+
+  # one parameter
+  def test_frequencies
+    assert_respond_to(@api, :frequencies)
+    assert_raise(ArgumentError) do
+      @api.frequencies(@word, 5)
+    end
+    assert_raise(ArgumentError) do
+      @api.frequencies
+    end
+    response = @api.frequencies(@word)
+    assert_not_nil(response)
+    assert_instance_of(Array, response)
+    assert(!response.empty?)
+    assert_equal(2, response.size)
+    assert_match(/\d+/, response[0])
+    assert_match(/\d+/, response[1])
+  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?)
+    assert_equal(2, response.size)
+    assert_match(/\w+/, response[0])
+    assert_match(/[AVN]/, response[1])
+  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
+  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?)
+  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?)
+  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?)
+  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?)
+  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?)
+  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?)
+  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?)
+  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?)
+  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?)
+  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?)
+  end
+
+  def test_cooccurrences
+    assert_raise(RuntimeError) do
+      @api.cooccurrences(@word, 1, 10)
+    end
+  end
+
+  def test_cooccurrences_all
+    assert_raise(RuntimeError) do
+      @api.cooccurrences_all(@word, 1, 10)
+    end
+  end
+
+  def test_intersection
+    assert_raise(RuntimeError) do
+      @api.intersection(@word, @word, 10)
+    end
+  end
+
+  # private methods
+  def test_query
+  end
+
+  def test_get_answer
+  end
+end

data/wlapi.gemspec

@@ -1,17 +1,19 @@
 Gem::Specification.new do |s|
   s.name = "wlapi"
-  s.summary = "Use different web services provided by the Project Wortschatz."
-  s.description = "WLAPI is a programmatic API for web services provided by the project Wortschatz, University of Leipzig."
+  s.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." # it is the description for 'gem list -d'
+  s.description = "WLAPI is a programmatic API for web services provided by the project Wortschatz, University of Leipzig." # it appears on the RubyGems page
   s.rubyforge_project = "wlapi"
-  s.requirements = [ 'Using this gem requires understanding of the linguistic background behind the WL project.' ]
-  s.version = "0.0.6"
+  s.requirements = [ 'Using this gem requires understanding of the linguistic background behind the WL project.' ] # it isn't currently used
+  s.version = "0.7.1"
   s.author = "Andrei Beliankou"
   s.email = "a.belenkow@uni-trier.de"
   s.homepage = "http://www.uni-trier.de/index.php?id=34451"
+#  s.require_paths = 'lib' # it is the default value, why to use?
   s.add_dependency('savon')
-  s.rdoc_options = ["-m", "README"]
-  s.extra_rdoc_files = ["README", "example/example.rb", "LICENSE"]
+  s.rdoc_options = ["-m", "README.rdoc"]
+  s.extra_rdoc_files = ["README.rdoc", "LICENSE"]
   s.platform = Gem::Platform::RUBY
   s.required_ruby_version = '>=1.8.5'
-  s.files = Dir['**/**']
+  s.files = Dir['**/*']
+  s.test_files = ["test/test_api.rb"]
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: wlapi
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 1
   prerelease: false
   segments: 
   - 0
-  - 0
-  - 6
-  version: 0.0.6
+  - 7
+  - 1
+  version: 0.7.1
 platform: ruby
 authors: 
 - Andrei Beliankou
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-16 00:00:00 +01:00
+date: 2010-11-21 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -39,50 +39,17 @@ executables: []
 extensions: []
 
 extra_rdoc_files: 
-- README
-- example/example.rb
+- README.rdoc
 - LICENSE
 files: 
-- wlapi-0.0.6.gem
+- README.rdoc
 - wlapi.gemspec
-- doc/images/loadingAnimation.gif
-- doc/images/wrench.png
-- doc/images/brick.png
-- doc/images/page_white_text.png
-- doc/images/ruby.png
-- doc/images/plugin.png
-- doc/images/bug.png
-- doc/images/bullet_toggle_minus.png
-- doc/images/find.png
-- doc/images/zoom.png
-- doc/images/bullet_toggle_plus.png
-- doc/images/date.png
-- doc/images/page_white_width.png
-- doc/images/tag_green.png
-- doc/images/wrench_orange.png
-- doc/images/macFFBgHack.png
-- doc/images/package.png
-- doc/images/page_green.png
-- doc/images/brick_link.png
-- doc/images/bullet_black.png
-- doc/js/darkfish.js
-- doc/js/jquery.js
-- doc/js/quicksearch.js
-- doc/js/thickbox-compressed.js
-- doc/rdoc.css
-- doc/index.html
-- doc/README.html
-- doc/created.rid
-- doc/WLAPI.html
-- doc/INSTALL.html
-- doc/WLAPI/API.html
-- doc/example/example_rb.html
-- doc/LICENSE.html
-- doc/lib/wlapi_rb.html
 - INSTALL
+- test/test_api.rb
 - LICENSE
+- Rakefile
 - README
-- example/example.rb
+- lib/wlapi/api.rb
 - lib/wlapi.rb
 has_rdoc: true
 homepage: http://www.uni-trier.de/index.php?id=34451
@@ -91,7 +58,7 @@ licenses: []
 post_install_message: 
 rdoc_options: 
 - -m
-- README
+- README.rdoc
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -120,6 +87,6 @@ rubyforge_project: wlapi
 rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: Use different web services provided by the Project Wortschatz.
-test_files: []
-
+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