text_parser 0.1.4 → 0.1.5

data/README.rdoc

@@ -5,7 +5,7 @@
   | :dictionary                     | Array  | nil           |
   | :order (:word | :hits)          | Symbol | :word         |
   | :order_direction (:asc | :desc) | Symbol | :asc          |
-  | :negative_dictionary            | Array  | []            |
+  | :negative_dictionary            | Array  | nil           |
   +---------------------------------+--------+---------------+
 
 

data/lib/text_parser.rb

@@ -1,4 +1,3 @@
-require 'iconv'  
 module TextParser
   # Returns a parsed text with the words and its occurrences.
   # @param [Hash] [args]
@@ -29,7 +28,7 @@ module TextParser
   
   def process_text
     text = self.gsub(/\s{2,}/," ")
-    text = text.gsub(/[^\w\s\-]/, "")
+    text = text.gsub(/[^\w\s\-]/u, "")
   end
 end
 

data/lib/text_parser/version.rb

@@ -2,7 +2,7 @@ module TextParser
   module Version
     MAJOR = 0
     MINOR = 1
-    PATCH = 4
+    PATCH = 5
     STRING = "#{MAJOR}.#{MINOR}.#{PATCH}"
   end
-end
+end

data/test/text_parser_test.rb

@@ -2,28 +2,29 @@ require "test/unit"
 require "text_parser"
 
 class TextParserTest < Test::Unit::TestCase
+
   def test_should_have_method_parse
     assert "some text".methods.select{|a| a == "parse"}.count > 0
   end
   
   def test_should_parse
     text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque pretium consectetur."
-    assert_equal text.parse(:dictionary => ["dolor", "consectetur"]), [{:word => "consectetur", :hits => 2}, {:word => "dolor", :hits => 1}]
+    assert_equal [{:word => "consectetur",  :hits => 2},
+                  {:word => "dolor",        :hits => 1}],
+                  text.parse(:dictionary => ["dolor", "consectetur"])
   end
   
   def test_should_parse_without_dictionary
-    text = "test test"
-    assert_equal text.parse, [{:word => "test", :hits => 2}]
+    assert_equal [{:word => "test", :hits => 2}], "test test".parse
   end
   
   def test_should_remove_some_characters
     text = "Test? Test. Yes, test!"
-    assert_equal text.parse, [{:word => "test", :hits => 3}, {:word => "yes", :hits => 1}]
+    assert_equal [{:word => "test", :hits => 3}, {:word => "yes", :hits => 1}], text.parse
   end
   
   def test_should_return_an_empty_array
-    text = "test"
-    assert_equal text.parse(:dictionary => ['abc']), []
+    assert_equal "test".parse(:dictionary => ['abc']), []
   end
 
   def test_should_order_by_word_asc
@@ -32,13 +33,14 @@ class TextParserTest < Test::Unit::TestCase
               {:word => "beta",   :hits => 1},
               {:word => "gamma",  :hits => 2},
               {:word => "omega",  :hits => 1}]
-    assert_equal text.parse, result
-    assert_equal text.parse(:order => :word), result
-    assert_equal text.parse(:order => :word, :order_direction => :asc), result
+    assert_equal result, text.parse
+    assert_equal result, text.parse(:order => :word)
+    assert_equal result, text.parse(:order => :word, :order_direction => :asc)
   end
   
   def test_should_order_by_word_desc
-    assert_equal "aaa zzz".parse(:order => :word, :order_direction => :desc), [{:word => "zzz",  :hits => 1}, {:word => "aaa",  :hits => 1}]
+    assert_equal [{:word => "zzz",  :hits => 1},
+                  {:word => "aaa",  :hits => 1}], "aaa zzz".parse(:order => :word, :order_direction => :desc)
   end
  
   def test_should_order_by_hits_asc
@@ -46,47 +48,58 @@ class TextParserTest < Test::Unit::TestCase
     result = [{:word => "beta",  :hits => 1},
               {:word => "alpha", :hits => 2},
               {:word => "gamma", :hits => 3}]
-    assert_equal text.parse(:order => :hits), result
-    assert_equal text.parse(:order => :hits, :order_direction => :asc), result
+    assert_equal result, text.parse(:order => :hits)
+    assert_equal result, text.parse(:order => :hits, :order_direction => :asc)
   end
   
   def test_should_order_by_hits_desc
     text = "gamma alpha gamma beta alpha gamma"
-    assert_equal text.parse(:order => :hits, :order_direction => :desc), [{:word => "gamma",  :hits => 3},
-                                                                          {:word => "alpha",  :hits => 2},
-                                                                          {:word => "beta",   :hits => 1}]
+    assert_equal [{:word => "gamma",  :hits => 3},
+                  {:word => "alpha",  :hits => 2},
+                  {:word => "beta",   :hits => 1}],
+                  text.parse(:order => :hits, :order_direction => :desc)
   end
   
   def test_should_ignore_negative_dictionary
-    assert_equal "This is good".parse(:negative_dictionary => ["is", "this"]), [{:word => "good",  :hits => 1}]
+    assert_equal [{:word => "good",  :hits => 1}], "This is good".parse(:negative_dictionary => ["is", "this"])
   end
 
   def test_should_works_with_special_characters
-    assert_equal "'/[.](\")".parse, []
+    assert_equal [], "'/[.](\")".parse
   end
   
   def test_should_works_hifen
-    assert_equal "self-service".parse, [{:word => "self-service", :hits => 1}]
+    assert_equal [{:word => "self-service", :hits => 1}], "self-service".parse
   end
   
   def test_should_return_double_words
-    assert_equal "I like the movie Forrest Gump.".parse(:dictionary => ["Forrest Gump"]), [{:word => "forrest gump", :hits => 1}]
+    assert_equal [{:word => "forrest gump", :hits => 1}],
+                 "I like the movie Forrest Gump.".parse(:dictionary => ["Forrest Gump"])
   end
 
   def test_should_manage_null_args
     args = {:dictionary=>nil, :negative_dictionary=>nil, :order=>nil, :order_direction=>nil}
-    assert_equal "text".parse(args), [{:word => "text", :hits => 1}]
+    assert_equal [{:word => "text", :hits => 1}], "text".parse(args)
   end
 
   def test_should_work_with_many_spaces
     text = "e se    eu     encher      de    espacos"
-    assert_equal [{:word => "de",  :hits => 1},
-                              {:word => "e", :hits => 1},
-                              {:word => "encher", :hits => 1},
-                              {:word => "espacos", :hits => 1},
-                              {:word => "eu", :hits => 1},
-                              {:word => "se", :hits => 1}], text.parse
+    assert_equal [{:word => "de",     :hits => 1},
+                  {:word => "e",      :hits => 1},
+                  {:word => "encher", :hits => 1},
+                  {:word => "espacos",:hits => 1},
+                  {:word => "eu",     :hits => 1},
+                  {:word => "se",     :hits => 1}], text.parse
   end   
+  
+  def test_should_keep_some_special_character
+    assert_equal [{:word => "espaço", :hits => 1},
+                  {:word => "sideral",:hits => 1}], "Espaço sideral".parse
+    assert_equal [{:word => "açúcar", :hits => 1},
+                  {:word => "bom",    :hits => 1},
+                  {:word => "de",     :hits => 1},
+                  {:word => "pão",    :hits => 1}], "Pão de açúcar é bom.".parse
+  end
 end
 
 

data/test/version_test.rb

@@ -0,0 +1,23 @@
+require "test/unit"
+require "text_parser/version"
+
+class TextParserTest < Test::Unit::TestCase
+  def test_version
+    assert_equal TextParser::Version.const_get("STRING"), "0.1.5" 
+  end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

data/text_parser.gemspec

@@ -1,10 +1,12 @@
+require "lib/text_parser/version"
+
 Gem::Specification.new do |s|
   s.name        = "text_parser"
-  s.version     = "0.1.4"
+  s.version     = TextParser::Version.const_get("STRING")
   s.author      = "Frederico de Paula"
   s.email       = "fpaula@gmail.com"
-  s.summary     = "A easy way to parse text."
+  s.summary     = "A easy way to parse a text."
   s.description = "Using method parse in the String object you can parse any text"
   s.files       = Dir["{lib/**/*.rb,README.rdoc,test/**/*.rb,Rakefile,*.gemspec,doc/**/*}"]
-  s.homepage    = "https://github.com/fpaula/text_parser/"
-end
+  s.homepage    = "http://textparser.heroku.com/"
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: text_parser
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 17
   prerelease: 
   segments: 
   - 0
   - 1
-  - 4
-  version: 0.1.4
+  - 5
+  version: 0.1.5
 platform: ruby
 authors: 
 - Frederico de Paula
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-12-08 00:00:00 -02:00
+date: 2011-12-09 00:00:00 -02:00
 default_executable: 
 dependencies: []
 
@@ -32,6 +32,7 @@ files:
 - lib/text_parser.rb
 - README.rdoc
 - test/text_parser_test.rb
+- test/version_test.rb
 - Rakefile
 - text_parser.gemspec
 - doc/_index.html
@@ -52,7 +53,7 @@ files:
 - doc/TextParser.html
 - doc/top-level-namespace.html
 has_rdoc: true
-homepage: https://github.com/fpaula/text_parser/
+homepage: http://textparser.heroku.com/
 licenses: []
 
 post_install_message: 
@@ -84,6 +85,6 @@ rubyforge_project:
 rubygems_version: 1.4.2
 signing_key: 
 specification_version: 3
-summary: A easy way to parse text.
+summary: A easy way to parse a text.
 test_files: []