string_utility_belt 0.2.5 → 0.3.0

data/lib/string_utility_belt.rb

@@ -1,18 +1,7 @@
+require 'string_utility_belt/version'
 
-require "general/general"
-require "html_and_aml/html_and_aml"
-require "match_rank/match_rank"
-require "regex_me/regex_me"
-
-module StringUtilityBelt
-
-  include RegexMe::To::Search
-  include MatchRank
-  include General
-  include HtmlAndAML
-
-end
-
-class String
-	include StringUtilityBelt
-end
+require 'string_utility_belt/regex_me_to_search'
+require 'string_utility_belt/general'
+require 'string_utility_belt/match_rank'
+require 'string_utility_belt/tags'
+require 'string_utility_belt/entities'

data/test/string_utility_belt/entities_test.rb

@@ -0,0 +1,17 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class EntitiesTest < Test::Unit::TestCase
+
+  def test_should_decode_entities
+    assert_equal "<TAG>", "&lt;TAG&gt;".decode_entities
+  end
+
+  def test_should_decode_entities_and_clean_up_the_tags
+    assert_equal "", "&lt;TAG&gt;".decode_entities_and_cleaner
+  end
+
+  def test_should_should_encode_anything_that_can_be_transformed_into_an_entity
+    assert_equal "&lt;TAG&gt;", "<TAG>".generate_entities
+  end
+
+end

data/test/string_utility_belt/general_test.rb

@@ -0,0 +1,73 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class GeneralTest < Test::Unit::TestCase
+
+  def setup
+    @spaces_and_some_text = "    \n \r   \t\r\n foo \t bar    "
+
+    @text = %q{Texto de teste!
+               Esta classe deverá fazer a busca por uma ou um grupo de palavras
+               em um texto e retornar um rank com a quantidade identificada.}
+  end
+
+  def test_should_return_a_single_word_in_array
+    assert_equal %w{Hello}, "Hello".words
+  end
+
+  def test_should_return_all_words_as_element_in_array
+    assert_equal ["foo-foo", "bar's", "bar"], "foo-foo, bar's. bar!".words
+  end
+
+  def test_should_replace_a_sequence_of_space_per_a_unique_space
+    assert_equal " foo bar ", @spaces_and_some_text.simple_space
+  end
+
+  def test_should_replace_the_left_spaces_by_only_one
+    assert_equal '   \o/!'.simple_space, ' \o/!'
+  end
+
+  def test_should_replace_the_right_spaces_by_only_one
+    assert_equal '\o/!     '.simple_space, '\o/! '
+  end
+
+  def test_should_be_the_same_result_after_calling_the_method
+    string = @spaces_and_some_text.dup
+    assert_equal string, "    \n \r   \t\r\n foo \t bar    "
+  end
+
+  def test_should_return_the_same_text_if_nothing_changed
+    assert_equal "Hello", "Hello".simple_space
+  end
+
+
+  #describe #simple_space!
+  def test_should_not_generate_a_new_object
+    @spaces_and_some_text.simple_space!
+
+    assert_not_same ' foo bar ', @spaces_and_some_text
+  end
+
+  def test_should_return_nil_if_nothing_changed
+    assert_nil "Hello".simple_space!
+  end
+
+
+  # describe #have_this_words?
+  def test_should_be_true_if_find_all_of_the_text_fragments
+    assert @text.have_this_words?("busca ran".words)
+  end
+
+  def test_should_be_false_because_not_exists_the_ran_word
+    assert_not_equal true, @text.have_this_words?("ran busca".words, true)
+  end
+
+  # describe #not_have_this_words?
+  def test_should_be_true_if_not_find_all_of_the_searched_words
+    assert_equal true, @text.not_have_this_words?("ran busc".words, true)
+  end
+
+  def test_should_match_even_if_there_are_characters_variations
+    text = "São páúlõ is a very nice city!"
+    assert text.have_this_words?("sao paulo".words, :latin_chars_variations => true)
+  end
+end

data/test/string_utility_belt/match_rank_test.rb

@@ -0,0 +1,64 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class MatchRankTest < Test::Unit::TestCase
+
+  def setup
+    @sequence = "a aa aaa aaaa aaaaa b bb bbb bbbb"
+  end
+
+  def test_should_return_a_hash_with_the_results_of_exact_and_inexact_matches
+    analysis = "".total_frequency_by('test')
+    expected = {:exact => 0, :matched => 0}
+    assert_equal(expected, analysis)
+  end
+
+  def test_should_return_how_many_times_a_text_pattern_was_matched
+    analysis = @sequence.total_frequency_by('bb')
+    matched = analysis[:matched]
+    assert_equal 3, matched
+  end
+
+  def test_should_return_how_many_exact_matches
+    analysis = @sequence.total_frequency_by('bb')
+    exact_matches = analysis[:exact]
+    assert_equal(1, exact_matches)
+  end
+
+  def test_should_return_an_analysis_of_all_received_words
+    analysis = @sequence.total_frequency_by('aa bb'.words)
+    expected = {:matched=> 7, :exact=> 2}
+    assert_equal(expected, analysis)
+  end
+
+  def test_should_return_the_analysis_of_total_frequency_by_method_and_precision
+    analysis = @sequence.match_and_score_by('aa bb'.words)
+    expected = {:exact=>2.0, :matched=>7.0, :precision=>28.5714285714286}
+    assert_in_delta(expected[:precision], analysis[:precision], 0.00001)
+  end
+
+
+  def test_should_return_a_hash_with_the_results_for_exact_and_inexact_per_word_criteria
+    analysis = "".words_frequency_by('test')
+    expected = {:exact => {}, :matched => {}}
+    assert_equal(expected, analysis)
+  end
+
+  def test_should_return_how_many_times_a_text_pattern_was_matched_per_word_criteria
+    analysis = @sequence.words_frequency_by('aa')
+    matched = analysis[:matched]
+    assert_equal({'aa' => 4}, matched)
+  end
+
+  def test_should_return_how_many_exact_matches_per_word_criteria
+    analysis = @sequence.words_frequency_by('aa')
+    exact_matches = analysis[:exact]
+    assert_equal({'aa' => 1}, exact_matches)
+  end
+
+  def test_should_return_an_analysis_of_all_received_words_per_words_criteria
+    analysis = @sequence.words_frequency_by('aa bb'.words)
+    expected = {:matched=>{"bb"=>3, "aa"=>4}, :exact=>{"bb"=>1, "aa"=>1}}
+    assert_equal(expected, analysis)
+  end
+
+end

data/test/string_utility_belt/regex_me_helper_test.rb

@@ -0,0 +1,117 @@
+# coding: utf-8
+
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class RegexMeHelperTest < Test::Unit::TestCase
+
+  def test_should_create_a_string_with_the_latin_char_variations_for_the_letter_A
+    assert_equal("(a|à|á|â|ã|ä)", "a".regex_latin_ci_list)
+  end
+
+  def test_should_create_a_string_with_the_latin_char_variations_for_the_letter_E
+    assert_equal("(e|è|é|ê|ë)", "e".regex_latin_ci_list)
+  end
+
+  def test_should_create_a_string_with_the_latin_char_variations_for_the_letter_I
+    assert_equal("(i|ì|í|î|ï)", "i".regex_latin_ci_list)
+  end
+
+  def test_should_create_a_string_with_the_latin_char_variations_for_the_letter_O
+    assert_equal("(o|ò|ó|ô|õ|ö)", "o".regex_latin_ci_list)
+  end
+
+  def test_should_create_a_string_with_the_latin_char_variations_for_the_letter_U
+    assert_equal("(u|ù|ú|û|ü)", "u".regex_latin_ci_list)
+  end
+
+  def test_should_create_a_string_with_the_latin_char_variations_for_the_letter_C
+    assert_equal("(c|ç)", "c".regex_latin_ci_list)
+  end
+
+  def test_should_create_a_string_with_the_latin_char_variations_for_the_letter_N
+    assert_equal("(n|ñ)", "n".regex_latin_ci_list)
+  end
+
+  def test_should_replace_all_chars_that_found_in_latin_variantion_list
+    expected = "r(e|è|é|ê|ë)g(e|è|é|ê|ë)xp (i|ì|í|î|ï)s p(o|ò|ó|ô|õ|ö)w(e|è|é|ê|ë)rf(u|ù|ú|û|ü)ll"
+
+    assert_equal expected, "regexp is powerfull".regex_latin_ci_list
+  end
+
+  def test_should_returns_the_OR_metachar_if_or_options_was_passed
+    assert_equal "OR == |", "OR == ".regex_builder(:or => true)
+  end
+
+  def test_should_not_return_OR_when_the_OR_options_is_false
+    assert_equal "without OR", "without OR".regex_builder(:or => false)
+  end
+
+  def test_should_return_the_border_metachar_in_left_when_its_required_for_ruby
+    left = '\b'
+    expected = left + "string"
+    border = {:to => :ruby, :direction => :left}
+
+    assert_equal expected, "string".regex_builder(:border => border)
+  end
+
+  def test_should_return_the_border_metachar_in_right_when_its_required_for_ruby
+    right = '\b'
+    expected = "string" + right
+    border = {:to => :ruby, :direction => :right}
+
+    assert_equal expected, "string".regex_builder(:border => border)
+  end
+
+  def test_should_return_the_border_metachar_in_left_and_right_when_its_required_for_ruby
+    left = '\b'
+    right = '\b'
+    expected = left + "string" + right
+    border = {:to => :ruby, :direction => :both}
+
+    assert_equal expected, "string".regex_builder(:border => border)
+  end
+
+  def test_for_ruby_should_return_the_same_text_if_the_border_to_direction_is_invalid
+    text = "string"
+    border = {:to => :ruby}
+
+    assert_same text, text.regex_builder(:border => border)
+  end
+
+  def test_should_return_the_border_metachar_in_left_when_its_required_for_mysql
+    left = '[[:<:]]'
+    expected = left + "string"
+    border = {:to => :mysql, :direction => :left}
+
+    assert_equal expected, "string".regex_builder(:border => border)
+  end
+
+  def test_should_return_the_border_metachar_in_right_when_its_required_for_mysql
+    right = '[[:>:]]'
+    expected = "string" + right
+    border = {:to => :mysql, :direction => :right}
+
+    assert_equal expected, "string".regex_builder(:border => border)
+  end
+
+  def test_should_return_the_border_metachar_in_left_and_right_when_its_required_for_mysql
+    left = '[[:<:]]'
+    right = '[[:>:]]'
+    expected = left + "string" + right
+    border = {:to => :mysql, :direction => :both}
+
+    assert_equal expected, "string".regex_builder(:border => border)
+  end
+
+  def test_for_mysql_should_return_the_same_text_if_the_border_to_direction_is_invalid
+    text = "string"
+    border = {:to => :mysql, :direction => nil}
+
+    assert_same text, text.regex_builder(:border => border)
+  end
+
+  def test_should_return_a_mix_of_regexp_options
+    expected = "f.*(o|ò|ó|ô|õ|ö)"
+    assert_equal expected, "f*o".regex_builder(:any => true, :latin_chars_variations => true)
+  end
+end

data/test/string_utility_belt/regex_me_to_search_test.rb

@@ -0,0 +1,106 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class RegexMeToSearchTest < Test::Unit::TestCase
+
+  def setup
+    @text = "ruby frameworks is so cool"
+  end
+
+  def test_should_return_a_regex_for_ruby
+    assert_equal(/(foo|bar)/, "foo bar".regex_me_to_search_ruby)
+  end
+
+  def test_should_return_a_regex_for_mysql
+    assert_equal("(foo|bar)", "foo bar".regex_me_to_search_mysql)
+  end
+
+  def test_should_match_the_phrase_for_ruby
+    regexp = "ruby frameworks".regex_me_to_search_ruby(:exact_phrase => true)
+    assert_match(regexp, @text)
+  end
+
+  def test_should_match_independent_of_the_non_word_chars_between_the_words_phrase_for_ruby
+    text  = "ruby - on - rails"
+    regexp = "ruby on rails".regex_me_to_search_ruby(:exact_phrase => true)
+    assert_match(regexp, text)
+  end
+
+  def test_should_match_the_text_fragments
+    regexp = "rub ool".regex_me_to_search_ruby(:exact_word => false)
+    assert_match(regexp, @text)
+  end
+
+  def test_should_not_match_the_text_fragments
+    regexp = "rub ool".regex_me_to_search_ruby(:exact_word => true)
+    assert_no_match(regexp, @text)
+  end
+
+  def test_should_just_match_exact_word
+    regexp = "ruby cool".regex_me_to_search_ruby(:exact_word => true)
+    assert_match(regexp, @text)
+  end
+
+  def test_should_match_because_the_word_finish_with_the_letter_A
+    text  = "sinatra"
+    regexp = "*a".regex_me_to_search_ruby
+    assert_match(regexp, text)
+  end
+
+  def test_should_match_because_the_word_begin_with_the_letter_A
+    text  = "assertions"
+    regexp = "a*".regex_me_to_search_ruby
+    assert_match(regexp, text)
+  end
+
+  def test_should_match_because_the_word_contain_all_required_letters
+    text  = "sinatraaa"
+    regexp = "s*n*t*a".regex_me_to_search_ruby
+    assert_match(regexp, text)
+  end
+
+  def test_should_return_the_matched_sentencest
+    sentences = ['I like banana!', 'Do you like bonono?', 'foo bar', 'Regexp is cool']
+    regexp = "b*n*n* *l".regex_me_to_search_ruby
+
+    expected_sentences = ['I like banana!', 'Do you like bonono?', 'Regexp is cool']
+    matched_sentences = sentences.select { |sentence| sentence =~ regexp }
+    assert_equal(expected_sentences, matched_sentences)
+  end
+
+  def test_should_not_match_when_case_is_sensitive
+    text  = "sinatra"
+    regexp = "SINATRA".regex_me_to_search_ruby(:case_insensitive => false)
+    assert_no_match(regexp, text)
+  end
+
+  def test_should_match_when_case_is_insensitive
+    text  = "sinatra"
+    regexp = "SINATRA".regex_me_to_search_ruby(:case_insensitive => true)
+    assert_match(regexp, text)
+  end
+
+  def test_should_not_match_when_the_text_have_multilines
+    text  = "d\na"
+    regexp = "d*a".regex_me_to_search_ruby(:multiline => false)
+    assert_no_match(regexp, text)
+  end
+
+  def test_should_match_when_the_text_have_multilines
+    text  = "d\na"
+    regexp = "d*a".regex_me_to_search_ruby(:multiline => true)
+    assert_match(regexp, text)
+  end
+
+  def test_should_return_a_regex_to_mysql_with_borders
+    expected  = "([[:<:]]foo[[:>:]])"
+    regexp = "foo".regex_me_to_search_mysql(:exact_word => true)
+    assert_equal(expected, regexp)
+  end
+
+  def test_should_return_a_exact_phrase_regex_to_mysql
+    expected  = '[[:<:]]f(o|ò|ó|ô|õ|ö)(o|ò|ó|ô|õ|ö)[^0-9a-zA-Z\_]+b(a|à|á|â|ã|ä)r[[:>:]]'
+    regexp = "foo bar".regex_me_to_search_mysql(:exact_phrase => true)
+    assert_equal(expected, regexp)
+  end
+
+end

data/test/string_utility_belt/tags_test.rb

@@ -0,0 +1,25 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class TagsTest < Test::Unit::TestCase
+
+  def test_should_cleaner_the_html_tag
+    assert_equal "", "<html>".html_tag_cleaner
+  end
+
+  def test_should_not_clean_up_if_is_not_a_html_tag
+    assert_equal "<serradura>", "<serradura>".html_tag_cleaner
+  end
+
+  def test_should_clean_up_all_tags_and_just_keep_the_text
+    assert_equal "Serradura Labs", "<a href='http://blog.serraduralabs.com'>Serradura Labs</a>".html_tag_cleaner
+  end
+
+  def test_should_clean_up_anything_resembling_a_tag
+    assert_equal "", "<a></b></serradura><></>".tag_cleaner
+  end
+
+  def test_should_only_clean_up_complete_tags_patterns
+    assert_equal "<\o/>", "<a><</b>\</serradura>o<>/></>".tag_cleaner
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,5 @@
+
+require 'rubygems' if RUBY_VERSION < "1.9"
+require 'test/unit'
+require 'ruby-debug'
+require 'string_utility_belt'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: string_utility_belt
 version: !ruby/object:Gem::Version 
-  hash: 29
-  prerelease: false
+  hash: 19
+  prerelease: 
   segments: 
   - 0
-  - 2
-  - 5
-  version: 0.2.5
+  - 3
+  - 0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Rodrigo Serradura
@@ -15,12 +15,12 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-28 00:00:00 -03:00
-default_executable: 
+date: 2011-07-07 00:00:00 Z
 dependencies: []
 
-description: Useful methods for strings!
+description: Adiciona novas funcionalidades para strings
 email: 
+- rserradura@gmail.com
 executables: []
 
 extensions: []
@@ -28,19 +28,27 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- lib/html_and_aml/helpers/tags.rb
-- lib/html_and_aml/helpers/entities.rb
-- lib/html_and_aml/html_and_aml.rb
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.markdown
+- Rakefile
 - lib/string_utility_belt.rb
-- lib/regex_me/regex_me.rb
-- lib/regex_me/helpers/string/regex_me.rb
-- lib/general/general.rb
-- lib/match_rank/match_rank.rb
+- lib/string_utility_belt/entities.rb
+- lib/string_utility_belt/general.rb
+- lib/string_utility_belt/match_rank.rb
+- lib/string_utility_belt/regex_me_helper.rb
+- lib/string_utility_belt/regex_me_to_search.rb
+- lib/string_utility_belt/tags.rb
 - lib/string_utility_belt/version.rb
-- Rakefile
-- string_utility_belt.gemspec
-has_rdoc: true
-homepage: 
+- test/string_utility_belt/entities_test.rb
+- test/string_utility_belt/general_test.rb
+- test/string_utility_belt/match_rank_test.rb
+- test/string_utility_belt/regex_me_helper_test.rb
+- test/string_utility_belt/regex_me_to_search_test.rb
+- test/string_utility_belt/tags_test.rb
+- test/test_helper.rb
+homepage: ""
 licenses: []
 
 post_install_message: 
@@ -68,10 +76,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: "0"
 requirements: []
 
-rubyforge_project: 
-rubygems_version: 1.3.7
+rubyforge_project: string_utility_belt
+rubygems_version: 1.8.2
 signing_key: 
 specification_version: 3
-summary: Useful methods for strings!
+summary: Metodos uteis para strings
 test_files: []
 

data/lib/general/general.rb

@@ -1,36 +0,0 @@
-
-module General
-
-  def words
-    self.scan(/\w[\w\'\-]*/)
-  end
-
-  def simple_space
-    self.strip.gsub(/\s+/, " ")
-  end
-
-  def simple_space!
-    self.strip.gsub!(/\s+/, " ")
-  end
-
-  def have_this_words? words_to_match, options = {}
-    helper_have_this_words? words_to_match, options do |string, word, options|
-      return false if (string !~ word.regex_me_to_search_ruby(:exact_word => options[:exact_word], :case_insensitive => options[:case_insensitive], :latin_chars_variation => options[:latin_chars_variation]))
-    end
-  end
-
-  def not_have_this_words? words_to_match, options = {}
-    helper_have_this_words? words_to_match, options do |string, word, options|
-      return false if (string =~ word.regex_me_to_search_ruby(:exact_word => options[:exact_word], :case_insensitive => options[:case_insensitive], :latin_chars_variation => options[:latin_chars_variation]))
-    end
-  end
-
-  private
-    def helper_have_this_words? words_to_match, options = {}
-      for word in words_to_match
-        yield self, word, options
-      end
-      return true
-    end
-
-end

data/lib/html_and_aml/helpers/entities.rb

@@ -1,16 +0,0 @@
-
-require "rubygems" if RUBY_VERSION < "1.9"
-require "htmlentities"
-
-module Entities
-
-  def decode_entities
-    coder = HTMLEntities.new
-    coder.decode(self)
-  end
-
-  def decode_entities_and_cleaner
-    decode_entities.tag_cleaner
-  end
-
-end

data/lib/html_and_aml/helpers/tags.rb

@@ -1,13 +0,0 @@
-
-module Tags
-
-  def tag_cleaner
-    self.gsub(/<\/?[^>]*>/, "")
-  end
-
-  def html_tag_cleaner
-    self.gsub(/<\/?(a|p|abbr|acronym|address|applet|area|b|base|basefont|bdo|big|blockquote|body|br|button|caption|center|cite|code|col|colgroup|dd|del|dfn|dir|div|dl|dt|em|fieldset|font|form|frame|frameset|h6|head|hr|html|i|iframe|img|input|ins|isindex|kbd|label|legend|li|link|map|menu|meta|noframes|noscript|object)[^>]+??>/im, "")
-    # TAGs disponíveis até 09/2010 - FONTE: http://www.w3schools.com/tags/default.asp
-  end
-
-end

data/lib/html_and_aml/html_and_aml.rb

@@ -1,10 +0,0 @@
-
-require File.join(File.dirname(__FILE__), "helpers/entities")
-require File.join(File.dirname(__FILE__), "helpers/tags")
-
-module HtmlAndAML # == HTML And Another Markup Language
-
-  include Entities
-  include Tags
-
-end

data/lib/regex_me/helpers/string/regex_me.rb

@@ -1,73 +0,0 @@
-
-class String
-  
-  LATIN_CHARS_VARIATION = ["[aàáâãä]", "[eèéêë]", "[iìíîï]", "[oòóôõö]", "[uùúûü]", "[cçÇ]", "[ñÑ]"]
-
-  def regex_latin_ci_list
-
-    memo = ""
-    self.each_char do |char|
-
-      variation_found = false
-
-      for char_variation in LATIN_CHARS_VARIATION
-
-        match = eval("/#{char_variation}/")
-
-        if (char =~ match)
-          memo.insert(-1, char_variation)
-          variation_found = true
-          break
-        end
-      end
-
-      memo.insert(-1, char) unless variation_found
-    end
-
-    self.replace(memo)
-  end
-
-  def regex_builder options={}
-    
-    self.gsub!(/\*/,'.*')                   if options[:any]
-
-    regex_latin_ci_list                     if options[:latin_chars_variation]
-
-    border_me(options[:border][:to],
-              options[:border][:direction]) if options[:border]
-
-    insert_OR_in_right                  unless options[:delete_or]
-
-    self
-  end
-
-  private
-    def insert_OR_in_right
-      self.insert(-1, "|")
-    end
-
-    def border_me border_to, direction
-      border = define_border_metachar(border_to)
-
-      case direction
-        when :left
-         self.insert(0, border[:left])
-        when :right
-         self.insert(-1, border[:right])
-        when :both
-         self.insert(0, border[:left]).insert(-1, border[:right])
-        when nil
-         self
-      end
-    end
-
-    def define_border_metachar border_to
-      case border_to
-        when :ruby
-          {:left => '\b'     , :right => '\b'}
-        when :mysql
-          {:left => '[[:<:]]', :right => '[[:>:]]'}
-      end
-    end
-
-end