poliqarpr 0.0.5

data/README.txt

@@ -0,0 +1,107 @@
+= poliqarpr
+
+* http://github.com/apohllo/poliqarpr
+
+== DESCRIPTION:
+
+Poliqarpr is Ruby client for Poliqarp server.
+
+
+== FEATURES/PROBLEMS:
+
+* built-in pagination of query results
+* support for lemmatization 
+* asynchronous communication might be not stable (100% CPU ussage)
+* only partial implementation of server protocol:
+** PING, VERSION
+** MAKE-SESSION, CLOSE-SESSION
+** OPEN (corpus), CLOSE (corpus)
+** CORPUS-STATS, GET-TAGSET
+** STATUS, CANCEL (used internally)
+** MAKE-QUERY, RUN-QUERY, BUFFER-STATE (used internally)
+** GET-RESULTS, GET-CONTEXT, METADATA
+** SET: lemmata, tags 
+
+== SYNOPSIS:
+
+Poliqarpr is Ruby client for Poliqarp corpus server (see
+http://poliqarp.sourceforge.net/), which is used to store large texts used in
+Natural Language Processing.
+ 
+
+== REQUIREMENTS:
+
+Poliqarp server (only C implementation http://poliqarp.sourceforge.net/)
+
+== INSTALL:
+ 
+You need RubyGems v. 1.2 
+
+* gem -v 
+* 1.2.0 #=> ok
+
+You need the gemcutter.org repository to be added to your sources list:
+
+* gem sources -a http://gemcutter.org
+
+Then you can type:
+
+* sudo gem install poliqarpr
+
+You can install the optional default corpus (warning: it is distributed under
+different license!):
+
+* sudo gem install poliqarpr-corpus
+
+== BASIC USAGE: 
+
+(You need the poliqarpr-corpus to be installed for this to work. See the last
+step of installation process).
+
+Require the gem:
+
+  require 'poliaqarpr'
+
+Create the server client and open default corpus
+
+  client = Poliqarp::Client.new
+  client.open_corpus :default
+
+Query the corpus for given segment
+  
+  result = client.find("kot")
+  result[0].to_s 
+
+Remember to close the client on exit
+  
+  client.close
+
+
+== LICENSE:
+ 
+(The MIT License)
+
+Copyright (c) 2008-2009 Aleksander Pohl
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+== FEEDBACK
+
+* mailto:apohllo@o2.pl

data/Rakefile

@@ -0,0 +1,23 @@
+task :default => [:install]
+
+$gem_name = "poliqarpr"
+
+desc "Build the gem"
+task :build do
+  sh "gem build #$gem_name.gemspec"
+end
+
+desc "Install the library at local machnie"
+task :install => :build do 
+  sh "sudo gem install #$gem_name"
+end
+
+desc "Uninstall the library from local machnie"
+task :uninstall do
+  sh "sudo gem uninstall #$gem_name"
+end
+
+desc "Clean"
+task :clean do
+  sh "rm #$gem_name*.gem" 
+end

data/changelog.txt

@@ -0,0 +1,37 @@
+0.0.5
+- Bugfix: making parallel query might lead to silent thread death
+- Support for Ruby 1.9 encoding
+- Require path improvments
+- Copyright year correction
+- Documentation now points to gemcutter instead of github
+
+0.0.4
+- ping/pong diagnostics 
+- server version
+- corpus statistics 
+- implementation of asynchronous protocol (not stable)
+
+
+0.0.3
+- the license of the corpus included
+- client rdoc documentation 
+- support for lemmata retrieval 
+- excerpt now contains segments instead of strings
+- buffer size setter
+- default corpus moved to separate plugin (sudo gem install apohllo-poliqarpr-corpus)
+
+0.0.2
+- query result is full blown class
+- source divided into client, excerpt and query resutl
+- specs for client, excerpt and query result
+- namespace changed to POLIQARP
+- default corpus included
+- singular results properly fatched
+- valid result for queries containing many words
+- same queries which are run in sequence are called only once
+- README.txt included in gem
+- specs included in gem
+
+0.0.1 
+- initiali implementation
+- synchorous querying for terms

data/lib/poliqarpr/client.rb

@@ -0,0 +1,452 @@
+# vim:encoding=utf-8
+module Poliqarp
+  # Author:: Aleksander Pohl (mailto:apohllo@o2.pl)
+  # License:: MIT License
+  #
+  # This class is the implementation of the Poliqarp server client. 
+  class Client
+    GROUPS = [:left_context, :left_match, :right_match, :right_context]
+
+    # If debug is turned on, the communication between server and client 
+    # is logged to standard output.
+    attr_writer :debug
+
+    # The size of the buffer is the maximum number of excerpts which
+    # are returned for single query.
+    attr_writer :buffer_size
+
+    # Creates new poliqarp server client. 
+    # 
+    # Parameters:
+    # * +session_name+ the name of the client session. Defaults to "RUBY".
+    # * +debug+ if set to true, all messages sent and received from server
+    #   are printed to standard output. Defaults to false.
+    def initialize(session_name="RUBY", debug=false)
+      @session_name = session_name
+      @left_context = 5
+      @right_context = 5
+      @debug = debug
+      @buffer_size = 500000
+      @connector = Connector.new(debug)
+      @answer_queue = Queue.new
+      new_session
+    end
+
+    # A hint about installation of default corpus gem
+    def self.const_missing(const)
+      if const.to_s =~ /DEFAULT_CORPUS/ 
+        raise "You need to install 'apohllo-poliqarpr-corpus' to use the default corpus"
+      end
+      super
+    end
+
+    # Creates new session for the client with the name given in constructor. 
+    # If the session was already opened, it is closed. 
+    #
+    # Parameters: 
+    # * +port+ - the port on which the poliqarpd server is accepting connections (defaults to 4567)
+    def new_session(port=4567)
+      close if @session
+      @connector.open("localhost",port)
+      talk("MAKE-SESSION #{@session_name}")
+      talk("BUFFER-RESIZE #{@buffer_size}")
+      @session = true
+      self.tags = {}
+      self.lemmata = {}
+    end
+
+    # Closes the opened session.
+    def close
+      talk "CLOSE-SESSION" 
+      @session = false
+    end
+
+    # Closes the opened corpus.
+    def close_corpus
+      talk "CLOSE"
+    end
+
+    # Sets the size of the left short context. It must be > 0
+    #
+    # The size of the left short context is the number 
+    # of segments displayed in the found excerpts left to the
+    # matched segment(s).
+    def left_context=(value)
+      if correct_context_value?(value) 
+        result = talk("SET left-context-width #{value}")
+        @left_context = value if result =~ /^R OK/
+      else
+        raise "Invalid argument: #{value}. It must be fixnum greater than 0."
+      end
+    end
+
+    # Sets the size of the right short context. It must be > 0
+    #
+    # The size of the right short context is the number 
+    # of segments displayed in the found excerpts right to the
+    # matched segment(s).
+    def right_context=(value)
+      if correct_context_value?(value)
+        result = talk("SET right-context-width #{value}")
+        @right_context = value if result =~ /^R OK/
+      else
+        raise "Invalid argument: #{value}. It must be fixnum greater than 0."
+      end
+    end
+
+    # Sets the tags' flags. There are four groups of segments 
+    # which the flags apply for:
+    # * +left_context+
+    # * +left_match+
+    # * +right_match+
+    # * +right_context+
+    #
+    # If the flag for given group is set to true, all segments 
+    # in the group are annotated with grammatical tags. E.g.:
+    #  c.find("kot")
+    #  ...
+    #  "kot" tags: "subst:sg:nom:m2"
+    #
+    # You can pass :all to turn on flags for all groups
+    def tags=(options={})
+      options = set_all_flags if options == :all
+      @tag_flags = options
+      flags = ""
+      GROUPS.each do |flag|
+        flags << (options[flag] ? "1" : "0")
+        end
+      talk("SET retrieve-tags #{flags}")
+    end
+
+    # Sets the lemmatas' flags. There are four groups of segments 
+    # which the flags apply for:
+    # * +left_context+
+    # * +left_match+
+    # * +right_match+
+    # * +right_context+
+    #
+    # If the flag for given group is set to true, all segments 
+    # in the group are returned with the base form of the lemmata. E.g.:
+    #  c.find("kotu")
+    #  ...
+    #  "kotu" base_form: "kot"
+    #
+    # You can pass :all to turn on flags for all groups
+    def lemmata=(options={})
+      options = set_all_flags if options == :all
+      @lemmata_flags = options
+      flags = ""
+      GROUPS.each do |flag|
+        flags << (options[flag] ? "1" : "0")
+        end
+      talk("SET retrieve-lemmata #{flags}")
+    end
+
+    # *Asynchronous* Opens the corpus given as +path+. To open the default
+    # corpus pass +:default+ as the argument. 
+    # 
+    # If you don't want to wait until the call is finished, you
+    # have to provide +handler+ for the asynchronous answer.
+    def open_corpus(path, &handler)
+      if path == :default
+        open_corpus(DEFAULT_CORPUS, &handler)
+      else
+        real_handler = handler || lambda{|msg| @answer_queue.push msg }
+        talk("OPEN #{path}", :async, &real_handler)
+        do_wait if handler.nil?
+      end
+    end
+
+    # Server diagnostics -- the result should be :pong
+    def ping 
+      :pong if talk("PING") =~ /PONG/
+    end
+
+    # Returns server version
+    def version 
+      talk("VERSION")
+    end
+
+    # Returns corpus statistics:
+    # * +:segment_tokens+ the number of segments in the corpus 
+    #   (two segments which look exactly the same are counted separately)
+    # * +:segment_types+ the number of segment types in the corpus
+    #   (two segments which look exactly the same are counted as one type)
+    # * +:lemmata+ the number of lemmata (lexemes) types
+    #   (all forms of inflected word, e.g. 'kot', 'kotu', ... 
+    #   are treated as one "word" -- lemmata)
+    # * +:tags+ the number of different grammar tags (each combination
+    #   of atomic tags is treated as different "tag")
+    def stats
+      stats = {}
+      talk("CORPUS-STATS").split.each_with_index do |value, index|
+        case index
+        when 1 
+          stats[:segment_tokens] = value.to_i
+        when 2
+          stats[:segment_types] = value.to_i
+        when 3
+          stats[:lemmata] = value.to_i
+        when 4
+          stats[:tags] = value.to_i
+        end
+      end
+      stats
+    end
+
+    # TODO
+    def metadata_types
+      raise "Not implemented"
+    end
+
+    # Returns the tag-set used in the corpus.
+    # It is divided into two groups:
+    # * +:categories+ enlists tags belonging to grammatical categories
+    #   (each category has a list of its tags, eg. gender: m1 m2 m3 f n,
+    #   means that there are 5 genders: masculine(1,2,3), feminine and neuter)
+    # * +:classes+ enlists grammatical tags used to describe it
+    #   (each class has a list of tags used to describe it, eg. adj: degree 
+    #   gender case number, means that adjectives are described in terms
+    #   of degree, gender, case and number)
+    def tagset
+      answer = talk("GET-TAGSET")
+      counters = answer.split
+      result = {}
+      [:categories, :classes].each_with_index do |type, type_index|
+        result[type] = {}
+        counters[type_index+1].to_i.times do |index|
+          values = read_word.split
+          result[type][values[0].to_sym] = values[1..-1].map{|v| v.to_sym}
+        end
+      end
+      result
+    end
+
+    # Send the query to the opened corpus.
+    #
+    # Options:
+    # * +index+ the index of the (only one) result to be returned. The index is relative
+    #   to the beginning of the query result. In normal case you should query the 
+    #   corpus without specifying the index, to see what results are returned.
+    #   Then you can use the index and the same query to retrieve one result. 
+    #   The pair (query, index) is a kind of unique identifier of the excerpt.
+    # * +page_size+ the size of the page of results. If the page size is 0, then
+    #   all results are returned on one page. It is ignored if the +index+ option
+    #   is present. Defaults to 0.
+    # * +page_index+ the index of the page of results (the first page has index 1, not 0). 
+    #   It is ignored if the +index+ option is present. Defaults to 1.
+    def find(query,options={})
+      if options[:index]
+        find_one(query, options[:index])
+      else
+        find_many(query, options)
+      end
+    end
+
+    alias query find 
+
+    # Returns the number of results for given query.
+    def count(query)
+      count_results(make_query(query)) 
+    end
+
+    # Returns the long context of the excerpt which is identified by
+    # given (query, index) pair.
+    def context(query,index)
+      make_query(query)
+      result = []
+      talk "GET-CONTEXT #{index}"
+      # 1st part
+      result << read_word 
+      # 2nd part
+      result << read_word 
+      # 3rd part
+      result << read_word 
+      # 4th part
+      result << read_word 
+      result
+    end
+
+    # Returns the metadata of the excerpt which is identified by
+    # given (query, index) pair.
+    def metadata(query, index)
+      make_query(query)
+      result = {}
+      answer = talk("METADATA #{index}")
+      count = answer.split(" ")[1].to_i
+      count.times do |index|
+        type = read_word.gsub(/[^a-zA-Z]/,"").to_sym
+        value = read_word[2..-1]
+        unless value.nil?
+          result[type] ||= []
+          result[type] << value
+        end
+      end
+      result
+    end
+
+protected
+    # Sends a message directly to the server
+    # * +msg+ the message to send
+    # * +mode+ if set to :sync, the method block untli the message
+    #   is received. If :async the method returns immediately.
+    #   Default: :sync
+    # * +handler+ the handler of the assynchronous message. 
+    #   It is ignored when the mode is set to :sync.
+    def talk(msg, mode = :sync, &handler)
+      puts msg if @debug
+      @connector.send(msg, mode, &handler)
+    end
+
+    # Make query and retrieve many results. 
+    # * +query+ the query to be sent to the server.
+    # * +options+ see find
+    def find_many(query, options)
+      page_size = (options[:page_size] || 0)
+      page_index = (options[:page_index] || 1)
+
+      answer_offset = page_size * (page_index - 1)
+      if page_size > 0
+        result_count = make_async_query(query,answer_offset)
+        answers_limit = answer_offset + page_size > result_count ?  
+          result_count - answer_offset : page_size
+      else
+        # all answers needed -- the call must be synchronous
+        result_count = count_results(make_query(query))
+        answers_limit = result_count
+      end
+
+      page_count = page_size <= 0 ? 1 :
+        result_count / page_size + (result_count % page_size > 0 ? 1 : 0)
+
+      result = QueryResult.new(page_index, page_count,page_size,self,query)
+      if answers_limit > 0
+        talk("GET-RESULTS #{answer_offset} #{answer_offset + answers_limit - 1}") 
+        answers_limit.times do |answer_index|
+          result << fetch_result(answer_offset + answer_index, query)
+        end
+      end
+      result 
+    end
+
+    # Make query and retrieve only one result
+    # * +query+ the query to be sent to the server
+    # * +index+ the index of the answer to be retrieved
+    def find_one(query,index)
+      make_async_query(query,index)
+      talk("GET-RESULTS #{index} #{index}") 
+      fetch_result(index,query) 
+    end
+
+    # Fetches one result of the query
+    #
+    # MAKE-QUERY and GET-RESULTS must be sent to the server before 
+    # this method is called
+    def fetch_result(index, query)
+      result = Excerpt.new(index, self, query)
+      result << read_segments(:left_context)
+      result << read_segments(:left_match)
+      # XXX
+      #result << read_segments(:right_match)
+      result << read_segments(:right_context)
+      result
+    end
+
+    def read_segments(group)
+      size = read_number()
+      segments = []
+      size.times do |segment_index|
+        segment = Segment.new(read_word)
+        segments << segment 
+        if @lemmata_flags[group] || @tag_flags[group]
+          lemmata_size = read_number()
+          lemmata_size.times do |lemmata_index| 
+            lemmata = Lemmata.new()
+            if @lemmata_flags[group]
+              lemmata.base_form = read_word
+            end
+            if @tag_flags[group]
+              read_word
+            end
+            segment.lemmata << lemmata
+          end
+        end
+      end
+      segments
+    end
+
+    # Reads number stored in the message received from the server.
+    def read_number
+      @connector.read_message.match(/\d+/)[0].to_i
+    end
+
+    # Counts number of results for given answer
+    def count_results(answer)
+      answer.split(" ")[1].to_i
+    end
+
+    # *Asynchronous* Sends the query to the server
+    # * +query+ query to send
+    # * +handler+ if given, the method returns immediately, 
+    #   and the answer is sent to the handler. In this case
+    #   the result returned by make_query should be IGNORED!
+    def make_query(query, &handler)
+      if @last_query != query
+        @last_query = query
+        if handler.nil?
+          real_handler = lambda { |msg| @answer_queue.push msg }
+        else
+          real_handler = handler
+        end
+        begin
+          talk("MAKE-QUERY #{query}")
+        rescue JobInProgress
+          talk("CANCEL") rescue nil
+          talk("MAKE-QUERY #{query}")
+        end
+        talk("RUN-QUERY #{@buffer_size}", :async, &real_handler) 
+        @last_result = do_wait if handler.nil?
+      end
+      @last_result
+    end
+
+    # Reads string stored in the last message received from server
+    def read_word
+      @connector.read_message
+    end
+
+private 
+    def do_wait
+      loop {
+        status = talk("STATUS") rescue break
+        puts "STATUS: #{status}" if @debug
+        sleep 0.3
+      }
+      @answer_queue.shift
+    end
+
+    def set_all_flags
+      options = {}
+      GROUPS.each{|g| options[g] = true}
+      options
+    end
+    
+    def correct_context_value?(value)
+      value.is_a?(Fixnum) && value > 0
+    end
+
+    def make_async_query(query,answer_offset) 
+      # the handler is empty, since we access the result count through 
+      # BUFFER-STATE call
+      make_query(query){|msg| }
+      result_count = 0 
+      begin 
+        # the result count might be not exact!
+        result_count = talk("BUFFER-STATE").split(" ")[2].to_i
+        talk("STATUS") rescue break
+      end while result_count < answer_offset
+      @last_result = "OK #{result_count}"
+      result_count
+    end
+  end 
+end

data/lib/poliqarpr/connector.rb

@@ -0,0 +1,140 @@
+# vim:encoding=utf-8
+require 'socket'
+require 'thread'
+require File.join(File.dirname(__FILE__),'util')
+
+module Poliqarp
+  # Author:: Aleksander Pohl (mailto:apohllo@o2.pl)
+  # License:: MIT License
+  #
+  # This class hold the TCP connection to the server and is responsible
+  # for dispatching synchronous and asynchronous queries and answers.
+  class Connector
+    include Ruby19
+
+    # Error messages assigned to error codes
+    # (taken from poliqarpd implementation)
+    ERRORS = {
+      1 =>   "Incorrect number of arguments",
+      3 =>   "No session opened",
+      4 =>   "Cannot create a session for a connection that",
+      5 =>   "Not enough memory",
+      6 =>   "Invalid session ID",
+      7 =>   "Session with this ID is already bound",
+      8 =>   "Session user ID does not match the argument",
+      10 =>   "Session already has an open corpus",
+      12 =>   "System error while opening the corpus",
+      13 =>   "No corpus opened",
+      14 =>   "Invalid job ID",
+      15 =>   "A job is already in progress",
+      16 =>   "Incorrect query",
+      17 =>   "Invalid result range",
+      18 =>   "Incorrect session option",
+      19 =>   "Invalid session option value",
+      20 =>   "Invalid sorting criteria"
+    }
+
+    UTF8 = "utf-8"
+
+    # Creates new connector
+    def initialize(debug)
+      @message_queue = Queue.new
+      @socket_mutex = Mutex.new
+      @loop_mutex = Mutex.new
+      @debug = debug
+    end
+
+    # Opens connection with poliqarp server which runs 
+    # on given +host+ and +port+.
+    def open(host,port)
+      @socket_mutex.synchronize {
+        @socket = TCPSocket.new(host,port) if @socket.nil?
+      }
+      running = nil
+      @loop_mutex.synchronize {
+        running = @loop_running
+      }
+      main_loop unless running
+      @loop_mutex.synchronize {
+        @loop_running = true
+      }
+    end
+
+    # Sends message to the poliqarp server. Returns the first synchronous 
+    # answer of the server.
+    # * +message+ the message to send
+    # * +mode+ synchronous (+:sync:) or asynchronous (+:async+)
+    # * +handler+ the handler of the asynchronous message
+    def send(message, mode, &handler)
+      puts "send #{mode} #{message}" if @debug
+      if ruby19?
+        massage = message.encode(UTF8)
+      end
+      @socket.puts(message)
+      if mode == :async
+        @handler = handler
+      end
+      read_message
+    end
+
+    # Retrives one message from the server.
+    # If the message indicates an error, new runtime error 
+    # containing the error description is returned.
+    def read_message
+      message = @message_queue.shift
+      if message =~ /^ERR/
+        code = message.match(/\d+/)[0].to_i
+        raise JobInProgress.new() if code == 15
+        raise RuntimeError.new("Poliqarp Error: "+ERRORS[code])
+      else
+        message
+      end
+    end
+
+private
+    def main_loop
+      @loop = Thread.new { 
+        loop {
+          receive
+          # XXX ??? needed
+          #sleep 0.001
+        }
+      }
+    end
+
+    def receive
+      result = read_line
+      if ruby19?
+        result.force_encoding(UTF8)
+      end
+      msg = result[2..-2]
+      if result =~ /^M/
+        receive_async(msg)
+      elsif result
+        receive_sync(msg)
+      end
+      # if nil, nothing was received
+    end
+
+    def receive_sync(message)
+      puts "receive sync: #{message}" if @debug
+      @message_queue << message
+    end
+
+    def receive_async(message)
+      puts "receive async: #{message}" if @debug
+      Thread.new{ 
+        @handler.call(message) 
+      }
+    end
+
+    def read_line
+      line = ""
+      begin
+        chars = @socket.recvfrom(1)
+        line << chars[0]
+      end while chars[0] != "\n"
+      line
+    end
+  end
+end

data/lib/poliqarpr/exceptions.rb

@@ -0,0 +1,9 @@
+module Poliqarp
+  # Author:: Aleksander Pohl (mailto:apohllo@o2.pl)
+  # License:: MIT License
+
+  # The JobInProgress exception is raised if there was asynchronous call 
+  # to the server which haven't finished, which is interrupted by another
+  # asynchronous call.
+  class JobInProgress < Exception; end
+end

data/lib/poliqarpr/excerpt.rb

@@ -0,0 +1,63 @@
+module Poliqarp
+  # Author:: Aleksander Pohl
+  # License:: MIT License
+  #
+  # The excerpt class is used to store single result of the query, 
+  # i.e. the excerpt of the corpus which contains the words which
+  # the corpus was queried for. 
+  #
+  # The excerpt is divided into groups, which contain segments,
+  # which the texts in the corpus were divided for. 
+  # The first group is the left context, the second -- the matched 
+  # query, and the last -- the right context.
+  class Excerpt
+    attr_reader :index, :base_form, :short_context
+
+    def initialize(index, client, base_form)
+      @index = index
+      @client = client
+      @base_form = base_form
+      @short_context = []
+    end
+
+    # Adds segment group to the excerpt
+    def <<(value)
+      @short_context << value
+    end
+
+
+    # Returns the matched query as string 
+    def word
+      #@short_context[0].split(/\s+/)[-1]
+      @short_context[1].to_s
+    end
+
+    alias inflected_form word
+
+    # The string representation of the excerpt is the shord
+    # context of the query.
+    def to_s
+      @short_context.join("")
+    end
+
+    # Returns the long context of the query. 
+    def context
+      return @context unless @context.nil?
+      @context = @client.context(@base_form, @index)
+    end
+
+    { :medium => :medium, :style => :styl, :date => :data_wydania,
+      :city => :miejsce_wydania, :publisher => :wydawca, :title => :tytu,
+      :author => :autor}.each do |method, keyword|
+      define_method method do 
+        self.metadata[keyword]
+      end
+      end
+
+    protected
+    def metadata
+      return @metadata unless @metadata.nil?
+      @metadata = @client.metadata(@base_form, @index)
+    end
+  end
+end

data/lib/poliqarpr/lemmata.rb

@@ -0,0 +1,11 @@
+module Poliqarp
+  # Author:: Aleksander Pohl (mailto:apohllo@o2.pl)
+  # License:: MIT License
+  #
+  # The lemmata contains the base form of the segment
+  class Lemmata
+    attr_accessor :base_form
+    def initialize()
+    end
+  end
+end

data/lib/poliqarpr/query_result.rb

@@ -0,0 +1,73 @@
+module Poliqarp
+  # Author:: Aleksander Pohl (mailto:apohllo@o2.pl)
+  # License:: MIT License
+  #
+  # The query result class is used to paginate results of the 
+  # query. Each query result has information about its context
+  # (the next and previous page). 
+  class QueryResult
+    include Enumerable
+
+    attr_accessor :page, :page_count, :query, :page_size
+
+    def initialize(page, page_count, page_size, client, query)
+      @page = page
+      @page_count = page_count
+      @page_size = page_size
+      @client = client
+      @query = query
+      @excerpts = []
+    end
+
+    # Adds excerpt to the query result
+    def <<(excerpt)
+      @excerpts << excerpt
+    end
+
+    # Allows to iterate over the results stored in the result
+    def each
+      @excerpts.each{|e| yield e}
+    end
+
+    [:first, :last, :empty?].each do |method|
+      define_method method do
+        @excerpts.send(method)
+      end
+    end
+
+    # Returns excerpt with given index.
+    def [](index)
+      @excerpts[index]
+    end
+
+    # Two excerpts are equal iff their page number, page count,
+    # query and page size are equal.
+    def ==(other)
+      return false unless other.is_a? QueryResult
+      @page == other.page && @page_count == other.page_count &&
+        @query == other.query && @page_size == other.page_size
+    end
+
+    # Returns the previous page of the query result
+    def previous_page
+      if @page > 1
+        @client.find(@query, :page_size => @page_size, 
+                     :page_index => @page - 1) 
+      end
+    end
+
+    # Return the next page of the query result
+    def next_page
+      if @page < @page_count
+        @client.find(@query, :page_size => @page_size, 
+                     :page_index => @page + 1) 
+      end
+    end
+
+    # Returns the number of excerpts stored in this page (query result)
+    def size
+      @excerpts.size
+    end
+
+  end
+end

data/lib/poliqarpr/segment.rb

@@ -0,0 +1,23 @@
+module Poliqarp 
+  # Author:: Aleksander Pohl (mailto:apohllo@o2.pl)
+  # License:: MIT LICENSE
+  #
+  # The segment is the smallest meaningful part of the text.  
+  # It may contain many lemmata, since the segments are sometimes 
+  # not disambiguated. 
+  class Segment
+    attr_reader :literal, :lemmata
+
+    # Creates new segment. The specified argument is the literal 
+    # (as found in the text) representation of the segment. 
+    def initialize(literal)
+      @literal = literal
+      @lemmata = []
+    end
+
+    # Returns the segment literal
+    def to_s 
+      @literal
+    end
+  end
+end

data/lib/poliqarpr/util.rb

@@ -0,0 +1,9 @@
+#vim:encoding=utf-8
+module Poliqarp #:nodoc:
+  module Ruby19
+    # Returns true if the Ruby version is at least 1.9.0
+    def ruby19?
+      RUBY_VERSION.split(".")[0..1].join(".").to_f >= 1.9 
+    end
+  end
+end

data/lib/poliqarpr.rb

@@ -0,0 +1,9 @@
+begin
+  require 'poliqarpr-corpus' 
+rescue LoadError
+  # Do nothig, since the default corpus is optional
+end
+
+$LOAD_PATH.unshift File.dirname(__FILE__)
+Dir.glob(File.join(File.dirname(__FILE__), 'poliqarpr/**.rb')).each { |f| require f }
+

data/poliqarpr.gemspec

@@ -0,0 +1,17 @@
+Gem::Specification.new do |s|
+  s.name = "poliqarpr"
+  s.version = "0.0.5"
+  s.date = "2009-12-10"
+  s.summary = "Ruby client for Poliqarp"
+  s.email = "apohllo@o2.pl"
+  s.homepage = "http://www.github.com/apohllo/poliqarpr"
+  s.description = "Ruby client for Poliqarp (NLP corpus server)"
+  s.authors = ['Aleksander Pohl']
+  s.files = ["Rakefile", "poliqarpr.gemspec", 
+    "changelog.txt", "README.txt" ] + Dir.glob("lib/**/*")
+  s.test_files = Dir.glob("test/**/*")
+  s.rdoc_options = ["--main", "README.txt"]
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README.txt"]
+end
+

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+name: poliqarpr
+version: !ruby/object:Gem::Version 
+  version: 0.0.5
+platform: ruby
+authors: 
+- Aleksander Pohl
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-10 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: Ruby client for Poliqarp (NLP corpus server)
+email: apohllo@o2.pl
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.txt
+files: 
+- Rakefile
+- poliqarpr.gemspec
+- changelog.txt
+- README.txt
+- lib/poliqarpr.rb
+- lib/poliqarpr/exceptions.rb
+- lib/poliqarpr/lemmata.rb
+- lib/poliqarpr/query_result.rb
+- lib/poliqarpr/excerpt.rb
+- lib/poliqarpr/segment.rb
+- lib/poliqarpr/client.rb
+- lib/poliqarpr/util.rb
+- lib/poliqarpr/connector.rb
+has_rdoc: true
+homepage: http://www.github.com/apohllo/poliqarpr
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Ruby client for Poliqarp
+test_files: []
+