nlp 0.2.6 → 0.2.7

data/lib/rid_analyzer.rb

@@ -1,10 +0,0 @@
-module NLP
-
-  class  RIDAnalyzer < Analyzer
-
-    def initialize
-      @dictionary = Dictionary.new(:rid)
-    end
-
-  end
-end

data/lib/rid_category.rb

@@ -1,17 +0,0 @@
-module NLP
-  class RIDCategory < Category
-
-    def primary?
-      root == :PIERWOTNE
-    end
-
-    def secondary?
-      root == :WTORNE
-    end
-
-    def emotions?
-      root == :EMOCJE
-    end
-
-  end
-end

data/lib/sentence.rb

@@ -1,24 +0,0 @@
-module NLP
-  class Sentence
-
-    attr_reader :tokens
-
-    def initialize()
-      @tokens = []
-    end
-
-    def << tokens
-      if tokens.is_a? Array
-        @tokens.concat tokens
-      else
-        @tokens << tokens
-      end
-      self
-    end
-
-    def words_number
-      @tokens.count{|t| !t.interp?}
-    end
-
-  end
-end

data/lib/statistic.rb

@@ -1,55 +0,0 @@
-class Statistic
-
-  attr_accessor :total_words, :hash
-  attr_reader :cwords, :words, :total_words, :word_count
-  
-  def initialize
-    @word_count = 0
-    @total_words = 0
-    @scores = Hash.new { 0 }
-    @words = []
-    @cwords = Hash.new {nil}
-    @hash
-  end
-
-  def add(word,category)
-
-    @scores[category] += 1
-    @word_count += 1
-    @words.push word
-
-    category = category.name
-    if @cwords[category].nil?
-      @cwords[category] = []
-    end
-    @cwords[category].push word
-
-  end
-
-  def []=(key,value)
-    @hash[key] = value 
-  end
-
-  def [](key)
-    @hash[key]
-  end
-
-  def category_participation(categories)
-    sorted_scores = @scores.to_a.sort_by { |result| -result[1] }
-    r = {}
-    categories.each do |cat|
-      r[cat] = percentage_distribution(sorted_scores){|c| c.send(cat.to_s+'?')}
-    end
-    r
-  end
-
-  private
-  
-  def percentage_distribution scores, &block
-    sum = scores.select{|result| yield result[0]}.inject(0){|count,result| count + result[1]}
-    Float(sum)/@word_count 
-  end
-
-end
-
-

data/lib/stdlib/ext/string.rb

@@ -1,19 +0,0 @@
-class String
-    alias old_memeber []
-
-    def ordinary (index)
-        self.old_memeber index
-    end
-
-    def get(index)
-        self.scan(/./)[index]
-    end
-
-    def set(index,value)
-        arr = self.scan(/./)
-        arr[index] = value
-        self.replace(arr.join)
-        value
-    end
-end
-

data/lib/stree.rb

@@ -1,85 +0,0 @@
-
-module NLP
-  class SearchTree
-    ALPHABET = %w{* - a ą b c ć d e ę f g h i j k l ł m n ń o ó p r s ś t u w y z ź ż} 
-    SYMBOLS = %w{* - : - / ) (}
-    attr_accessor :value
-    attr_accessor :subtrees
-
-    # 0 -> *
-    # 1 -> -
-    # 2 -> a
-    # 33 -> ź
-    def initialize
-      @subtrees = Array.new(34, nil)
-      @value = []
-    end
-
-    def insert(s, value)
-      priv_insert(s.scan(/./), value)
-    end
-
-    def find(s)
-      priv_find(s.scan(/./))
-    end
-
-
-    protected
-    def key( chr )
-      unless chr 
-        raise ArgumentError,  "Argument chr is nil"
-      end
-      rval = ALPHABET.index(chr) || -1  
-      if rval > 35
-        rval = -1 # invalid character
-      end
-
-      rval 
-    end
-
-    def priv_insert( s, value )
-      if s.empty?
-        @value.push value
-      else
-        index = key( s.first )
-        subtree = if @subtrees[index] == nil
-                    @subtrees[index] = SearchTree.new
-                  else
-                    @subtrees[index]
-                  end
-
-        subtree.priv_insert( s.tail, value )
-      end
-    end
-
-    def priv_find( search )
-      if @subtrees[0]
-        @subtrees[0].value
-      else
-        if search.empty?
-          value
-        else
-          index = key( search.first )
-          if @subtrees[index]
-            @subtrees[index].priv_find( search.tail )
-          else
-            nil
-          end
-        end
-      end
-    end
-
-    public 
-    def traverse()
-      list = []
-      yield @value
-      list.concat @subrees if @subtrees  != nil
-      loop do
-        break if list.empty?
-        node = list.shift
-        yield node.value
-        list.concat node.subtrees if node.subtrees != nil
-      end
-    end
-  end
-end

data/lib/takipi_web_service.rb

@@ -1,51 +0,0 @@
-require 'rubygems'
-require 'savon'
-
-class TakipiWebService
-  URL = 'http://nlp.pwr.wroc.pl/clarin/ws/takipi/'
-  WSDL_URL = URL + 'takipi.wsdl'
-
-  def self.request(text)
-    client  = Savon::Client.new WSDL_URL, :soap_endpoint => URL
-
-    # Call remote service methods
-    response =  client.tag do |soap|
-      soap.body = "<text>#{text}</text><format>TXT</format><useGuesser>true</useGuesser>"
-    end
-
-    response =  response.to_hash
-    token =  response[:tag_response][:tag_response][:msg]
-    status = (response[:tag_response][:tag_response][:status]).to_i
-
-    #checking status   
-    timeout = 60
-    step = 5
-    count = 0
-    loop do 
-      break if count > timeout
-      if status == 1
-        break
-      elsif status == 2 or status == 3
-        count += 5
-        sleep(1)
-        r = client.get_status do |soap|
-          soap.body = "<token>#{token}</token>"
-        end.to_hash
-        status =  (r[:get_status_response][:status]).to_i   
-
-      end
-    end
-
-    #geting result
-
-    result = client.get_result do |soap|
-      soap.body="<token>#{token}</token>"
-    end
-
-    response_document = result.to_hash[:get_result_response][:tag_response][:msg]
-
-    #transforming response to well formed xml string
-    return "<xml><chunkList>#{response_document}</chunkList></xml>"
-  end 
-end
-

data/lib/text.rb

@@ -1,26 +0,0 @@
-module NLP
-  class Text
-    attr_reader :sentences
-
-    def initialize
-      @sentences = []
-    end
-
-    def << sentence
-      @sentences.push sentence
-    end
-
-
-    def words_per_sentence
-      @sentences.collect{|s| s.words_number}.mean
-    end
-
-
-    def flatten
-      flattened = []
-      @sentences.each{ |s| s.tokens.each{|t| flattened.push t } }
-      flattened
-    end
-
-  end
-end

data/lib/token.rb

@@ -1,37 +0,0 @@
-module NLP
-  class Token
-    
-    attr_reader :orth
-    attr_reader :tags
-
-    def initialize(orth,tags)
-      @orth = orth
-      @tags = tags
-    end
-
-    def symbol?
-      @tags.eql? "tsym"
-    end
-
-    def interp?
-      @tags.eql? "interp"
-    end
-
-    def word?
-      not interp? and not number?
-    end
-
-    def number?
-      @tags.include?("tnum")
-    end
-
-    def integer?
-      @tags.include?("tnum:integer")
-    end
-
-    def float?
-      @tags.include?("tnum:frac")
-    end
-
-  end
-end

data/lib/token_scanner.rb

@@ -1,60 +0,0 @@
-module NLP
-  class TokenScanner
-
-    attr_reader :text, :tokens
-
-    def initialize(text)
-      @text = text
-      @pos = 0
-      @tokens = @text.flatten
-    end
-
-    def next(type)
-      @pos+=1
-
-      case type
-      when :word
-        while @pos < @tokens.size and !@tokens[@pos].word?
-          @pos+= 1
-        end
-
-      when :interp
-        while @pos < @tokens.size and !@tokens[@pos].interp?
-          @pos+= 1
-        end
-
-      when :number
-        while @pos < @tokens.size and !@tokens[@pos].number?
-          @pos+= 1
-        end
-      when :alphanum
-        while @pos < @tokens.size and !@tokens[@pos].number? and !@tokens[@pos].word?
-          @pos+= 1
-        end
-      end
-    end
-
-
-    def current 
-      if @pos == @tokens.size
-        nil
-      else
-        @tokens[@pos]
-      end
-    end
-
-    def rewind
-      @pos = 0
-    end
-
-    def index
-      @pos
-    end
-
-    def end?
-      @pos == tokens.size
-    end
-
-    
-  end
-end

data/lib/word.rb

@@ -1,23 +0,0 @@
-require 'inflectable'
-require 'meaningable'
-
-module NLP
-  class Word < Token
-    
-    include Inflectable
-    include Meaningable
-
-    attr_reader :lemat
-    attr_accessor :category
-
-    def initialize(word, lemat, tags)
-      super(word,tags)
-      @lemat = lemat
-    end
-
-    def inflection
-      @tags
-    end
-
-  end
-end

data/test/analyzer_test.rb

@@ -1,25 +0,0 @@
-require '../lib/analyzer.rb'
-
-
-class AnalyzerTest < Test::Unit::TestCase
-
-  include NLP
-
-  def setup
-    sample = "Ja byłam wtedy bardzo szczęśliwa" 
-    @text = Lemmatizer.lemmatize(sample,:takipi,:local)
-    @scanner = TokenScanner.new(@text)
-    @rid_analyzer = Analyzer.new(:rid)
-    @liwc_analyzer = Analyzer.new(:liwc)
-  end
-
-  def test_analyze
-    stats = @rid_analyzer.analyze(@scanner) 
-    assert_kind_of Statistic, stats
-    assert_equal 5, stats.total_words
-    assert_equal 1, stats.word_count
-
-  end
-
-end
-