string_utility_belt 0.3.1 → 0.3.2

data/.gitignore

@@ -1,5 +1,3 @@
-*.gemspec
-
 pkg/**/*
 nbproject/**/*
 *.swp

data/lib/string_utility_belt/regex_me/lib/builders.rb

@@ -1,10 +1,7 @@
-require File.dirname(__FILE__) + '/configurations'
-require File.dirname(__FILE__) + '/helpers'
+require File.dirname(__FILE__) + '/helper'
 
 module RegexMe
   module Builders
-    include RegexMe::Configurations::Builder
-
     def regex_me_to_search_ruby(options = {})
       regex_me_to_search(:ruby, options)
     end
@@ -15,85 +12,10 @@ module RegexMe
 
     private
 
-    def options_handler(options)
-      handled = \
-        {:case_insensitive  => (options[:case_insensitive] ? Regexp::IGNORECASE : nil ),
-          :multiline  => (options[:multiline] ? Regexp::MULTILINE : nil ),
-          :or => (options[:or] == false ? false : true)}
-
-      return options.merge(handled)
-    end
-
     def regex_me_to_search(env, options)
       return EMPTYs[env] if self.strip.empty?
 
-      execute_builder(env, options)
-    end
-
-    def execute_builder(env, options)
-      opt_handled = options_handler(options)
-
-      builder_result = builder(env, opt_handled)
-
-      case env
-      when :ruby
-        options = [opt_handled[:case_insensitive], opt_handled[:multiline]].compact
-        Regexp.new(builder_result, *options)
-      when :mysql
-        builder_result
-      end
-    end
-
-    def builder(border_to, options)
-      string = self
-
-      lcv = options[:latin_chars_variations]
-
-      if options[:exact_phrase]
-        @regexp = \
-          string \
-          .strip.simple_space \
-          .regex_latin_ci_list \
-          .gsub(/\s/, WORDS_INTERVAL_PATTERN_FOR_EXACT_PHRASES) \
-          .regex_builder(:or => false,
-                         :border => {:to => border_to,
-                           :direction  => :both})
-      else
-        @regexp = '('
-
-        for word in string.strip.split
-          if options[:exact_word]
-            @regexp << word.regex_builder(:border => {:to => border_to, :direction => :both}, :latin_chars_variations => lcv, :or => true)
-          elsif have_the_any_char?(word)
-            @regexp << word.regex_builder(:any => true, :border => border(border_to, word) , :latin_chars_variations => lcv, :or => true)
-          else
-            @regexp << word.regex_builder(:latin_chars_variations => lcv, :or => true)
-          end
-        end
-
-        @regexp = (@regexp << ')').sub!(/\|\)/,')')
-      end
-
-      return @regexp
-    end
-
-    def have_the_any_char?(string)
-      string.include?('*')
-    end
-
-    def border(to, word)
-      direction = nil
-
-      case word
-      when/^\*/
-        direction = :right
-      when /\*$/
-        direction = :left
-      when /^.*\*.*$/
-        direction = :both
-      end
-
-      {:to => to, :direction => direction}
+      RegexMe::Helper.new(self).generate_for(env, options)
     end
   end
 end

data/lib/string_utility_belt/regex_me/lib/configurations.rb

@@ -4,6 +4,31 @@ module RegexMe
       EMPTYs = {:ruby => //, :mysql => ''}
       WORDS_INTERVAL_PATTERN_FOR_EXACT_PHRASES = '[^0-9a-zA-Z\_]+'
     end
+
+    module Variation
+      A_VARIATIONS = "(a|à|á|â|ã|ä)"
+      E_VARIATIONS = "(e|è|é|ê|ë)"
+      I_VARIATIONS = "(i|ì|í|î|ï)"
+      O_VARIATIONS = "(o|ò|ó|ô|õ|ö)"
+      U_VARIATIONS = "(u|ù|ú|û|ü)"
+      C_VARIATIONS = "(c|ç)"
+      N_VARIATIONS = "(n|ñ)"
+
+      LATIN_CHARS_VARIATIONS = [A_VARIATIONS,
+                                E_VARIATIONS,
+                                I_VARIATIONS,
+                                O_VARIATIONS,
+                                U_VARIATIONS,
+                                C_VARIATIONS,
+                                N_VARIATIONS]
+    end
+
+    module Border
+      BORDER_TO = {
+        :ruby  => {:left => '\b', :right => '\b' },
+        :mysql => {:left => '[[:<:]]', :right => '[[:>:]]' }
+      }
+    end
   end
 end
 

data/lib/string_utility_belt/regex_me/lib/helper.rb

@@ -0,0 +1,168 @@
+# coding: utf-8
+require File.dirname(__FILE__) + '/configurations'
+
+module RegexMe
+  class Helper
+    include RegexMe::Configurations::Builder
+    include RegexMe::Configurations::Variation
+    include RegexMe::Configurations::Border
+
+    attr_accessor :string
+
+    def initialize(string = "")
+      @string = string
+    end
+
+    def generate_for(env, options)
+      @env = env
+      @options = options_handler(options)
+
+      regexp = factory
+
+      case @env
+      when :ruby
+        options = [@options[:case_insensitive], @options[:multiline]].compact
+        return Regexp.new(regexp, *options)
+      when :mysql
+        return regexp
+      end
+    end
+
+    def set_latin_variations(string = nil)
+      memo = ""
+      text = string || @string
+
+      text.each_char do |char|
+        changed = false
+
+        for variations in LATIN_CHARS_VARIATIONS
+          variations_pattern = Regexp.new(variations, Regexp::IGNORECASE)
+
+          if char =~ variations_pattern
+            changed = true
+            memo.insert(-1, variations)
+            break
+          end
+        end
+
+        memo.insert(-1, char) unless changed
+      end
+
+      return text.replace(memo)
+    end
+
+    def builder(text, options)
+      @text = text
+
+      if options[:any]
+        replace_the_any_char_per_any_pattern
+      end
+
+      if options[:latin_chars_variations]
+        set_latin_variations(@text)
+      end
+
+      if options[:border]
+        insert_border(options[:border])
+      end
+
+      if options[:or]
+        insert_OR
+      end
+
+      return @text
+    end
+
+    private
+
+    def options_handler(options)
+      handled = \
+        {:case_insensitive  => (options[:case_insensitive] ? Regexp::IGNORECASE : nil ),
+          :multiline  => (options[:multiline] ? Regexp::MULTILINE : nil ),
+          :or => (options[:or] == false ? false : true)}
+
+      return options.merge(handled)
+    end
+
+    def factory
+      lcv = @options[:latin_chars_variations]
+
+      if @options[:exact_phrase]
+        regexp = \
+           set_latin_variations(@string.strip.simple_space) \
+          .gsub(/\s/, WORDS_INTERVAL_PATTERN_FOR_EXACT_PHRASES)
+
+        @regexp = \
+           builder(regexp, :or => false,
+                           :border => {:to => @env,
+                                       :direction  => :both})
+      else
+        @regexp = '('
+
+        for word in @string.strip.split
+          if @options[:exact_word]
+            @regexp << builder(word, :border => {:to => @env, :direction => :both},
+                                     :latin_chars_variations => lcv,
+                                     :or => true)
+
+          elsif have_the_any_char?(word)
+            @regexp << builder(word, :any => true,
+                                     :border => border(@env, word),
+                                     :latin_chars_variations => lcv,
+                                     :or => true)
+
+          else
+            @regexp << builder(word, :latin_chars_variations => lcv,
+                                     :or => true)
+          end
+        end
+
+        @regexp = (@regexp << ')').sub!(/\|\)/,')')
+      end
+
+      return @regexp
+    end
+
+    def have_the_any_char?(string)
+      string.include?('*')
+    end
+
+    def border(to, word)
+      direction = nil
+
+      case word
+      when/^\*/
+        direction = :right
+      when /\*$/
+        direction = :left
+      when /^.*\*.*$/
+        direction = :both
+      end
+
+      {:to => to, :direction => direction}
+    end
+
+    def replace_the_any_char_per_any_pattern
+      @text.gsub!(/\*/, '.*')
+    end
+
+    def insert_border(options)
+      border = BORDER_TO[options[:to]]
+
+      case options[:direction]
+      when :left
+        @text.insert(0, border[:left])
+      when :right
+        @text.insert(-1, border[:right])
+      when :both
+        @text.insert(0, border[:left]).insert(-1, border[:right])
+      else
+        @text
+      end
+    end
+
+    def insert_OR
+      @text.insert(-1, "|")
+    end
+  end
+end

data/lib/string_utility_belt/version.rb

@@ -1,3 +1,3 @@
 module StringUtilityBelt
-  VERSION = "0.3.1"
+  VERSION = "0.3.2"
 end

data/string_utility_belt.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "string_utility_belt/version"
+
+Gem::Specification.new do |s|
+  s.name        = "string_utility_belt"
+  s.version     = StringUtilityBelt::VERSION
+  s.authors     = ["Rodrigo Serradura"]
+  s.email       = ["rserradura@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Useful methods to handle strings}
+  s.description = %q{Adds new features for String objects.}
+
+  s.rubyforge_project = "string_utility_belt"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  s.add_dependency("htmlentities", "4.3.0")
+end

data/test/string_utility_belt/{regex_me_to_search_test.rb → regex_me/builders_test.rb}

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), '..', 'test_helper')
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
 
 class RegexMeToSearchTest < Test::Unit::TestCase
 

data/test/string_utility_belt/{regex_me_helper_test.rb → regex_me/helper_test.rb}

@@ -1,49 +1,62 @@
 # coding: utf-8
 
-require File.join(File.dirname(__FILE__), '..', 'test_helper')
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
 
 class RegexMeHelperTest < Test::Unit::TestCase
 
+  def setup
+    @rmh = RegexMe::Helper.new
+  end
+
   def test_should_create_a_string_with_the_latin_char_variations_for_the_letter_A
-    assert_equal("(a|à|á|â|ã|ä)", "a".regex_latin_ci_list)
+    @rmh.string = "a"
+    assert_equal("(a|à|á|â|ã|ä)", @rmh.set_latin_variations)
   end
 
   def test_should_create_a_string_with_the_latin_char_variations_for_the_letter_E
-    assert_equal("(e|è|é|ê|ë)", "e".regex_latin_ci_list)
+    @rmh.string = "e"
+    assert_equal("(e|è|é|ê|ë)", @rmh.set_latin_variations)
   end
 
   def test_should_create_a_string_with_the_latin_char_variations_for_the_letter_I
-    assert_equal("(i|ì|í|î|ï)", "i".regex_latin_ci_list)
+    @rmh.string = "i"
+    assert_equal("(i|ì|í|î|ï)", @rmh.set_latin_variations)
   end
 
   def test_should_create_a_string_with_the_latin_char_variations_for_the_letter_O
-    assert_equal("(o|ò|ó|ô|õ|ö)", "o".regex_latin_ci_list)
+    @rmh.string = "o"
+    assert_equal("(o|ò|ó|ô|õ|ö)", @rmh.set_latin_variations)
   end
 
   def test_should_create_a_string_with_the_latin_char_variations_for_the_letter_U
-    assert_equal("(u|ù|ú|û|ü)", "u".regex_latin_ci_list)
+    @rmh.string = "u"
+    assert_equal("(u|ù|ú|û|ü)", @rmh.set_latin_variations)
   end
 
   def test_should_create_a_string_with_the_latin_char_variations_for_the_letter_C
-    assert_equal("(c|ç)", "c".regex_latin_ci_list)
+    @rmh.string = "c"
+    assert_equal("(c|ç)", @rmh.set_latin_variations)
   end
 
   def test_should_create_a_string_with_the_latin_char_variations_for_the_letter_N
-    assert_equal("(n|ñ)", "n".regex_latin_ci_list)
+    @rmh.string = "n"
+    assert_equal("(n|ñ)", @rmh.set_latin_variations)
   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
+    @rmh.string = "regexp is powerfull"
+
+    assert_equal expected, @rmh.set_latin_variations
   end
 
   def test_should_returns_the_OR_metachar_if_or_options_was_passed
-    assert_equal "OR == |", "OR == ".regex_builder(:or => true)
+    assert_equal "OR == |", @rmh.builder("OR == ", :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)
+    assert_equal "without OR", @rmh.builder("without OR", :or => false)
   end
 
   def test_should_return_the_border_metachar_in_left_when_its_required_for_ruby
@@ -51,7 +64,7 @@ class RegexMeHelperTest < Test::Unit::TestCase
     expected = left + "string"
     border = {:to => :ruby, :direction => :left}
 
-    assert_equal expected, "string".regex_builder(:border => border)
+    assert_equal expected, @rmh.builder("string", :border => border)
   end
 
   def test_should_return_the_border_metachar_in_right_when_its_required_for_ruby
@@ -59,7 +72,7 @@ class RegexMeHelperTest < Test::Unit::TestCase
     expected = "string" + right
     border = {:to => :ruby, :direction => :right}
 
-    assert_equal expected, "string".regex_builder(:border => border)
+    assert_equal expected, @rmh.builder("string", :border => border)
   end
 
   def test_should_return_the_border_metachar_in_left_and_right_when_its_required_for_ruby
@@ -68,14 +81,14 @@ class RegexMeHelperTest < Test::Unit::TestCase
     expected = left + "string" + right
     border = {:to => :ruby, :direction => :both}
 
-    assert_equal expected, "string".regex_builder(:border => border)
+    assert_equal expected, @rmh.builder("string", :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)
+    assert_same text, @rmh.builder(text, :border => border)
   end
 
   def test_should_return_the_border_metachar_in_left_when_its_required_for_mysql
@@ -83,7 +96,7 @@ class RegexMeHelperTest < Test::Unit::TestCase
     expected = left + "string"
     border = {:to => :mysql, :direction => :left}
 
-    assert_equal expected, "string".regex_builder(:border => border)
+    assert_equal expected, @rmh.builder("string", :border => border)
   end
 
   def test_should_return_the_border_metachar_in_right_when_its_required_for_mysql
@@ -91,7 +104,7 @@ class RegexMeHelperTest < Test::Unit::TestCase
     expected = "string" + right
     border = {:to => :mysql, :direction => :right}
 
-    assert_equal expected, "string".regex_builder(:border => border)
+    assert_equal expected, @rmh.builder("string", :border => border)
   end
 
   def test_should_return_the_border_metachar_in_left_and_right_when_its_required_for_mysql
@@ -100,18 +113,18 @@ class RegexMeHelperTest < Test::Unit::TestCase
     expected = left + "string" + right
     border = {:to => :mysql, :direction => :both}
 
-    assert_equal expected, "string".regex_builder(:border => border)
+    assert_equal expected, @rmh.builder("string", :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)
+    assert_same text, @rmh.builder(text, :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)
+    assert_equal expected, @rmh.builder("f*o", :any => true, :latin_chars_variations => true)
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: string_utility_belt
 version: !ruby/object:Gem::Version 
-  hash: 17
+  hash: 23
   prerelease: 
   segments: 
   - 0
   - 3
-  - 1
-  version: 0.3.1
+  - 2
+  version: 0.3.2
 platform: ruby
 authors: 
 - Rodrigo Serradura
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-12 00:00:00 Z
+date: 2011-07-13 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: htmlentities
@@ -55,15 +55,16 @@ files:
 - lib/string_utility_belt/regex_me.rb
 - lib/string_utility_belt/regex_me/lib/builders.rb
 - lib/string_utility_belt/regex_me/lib/configurations.rb
-- lib/string_utility_belt/regex_me/lib/helpers.rb
+- lib/string_utility_belt/regex_me/lib/helper.rb
 - lib/string_utility_belt/regex_me/regex_me.rb
 - lib/string_utility_belt/tags.rb
 - lib/string_utility_belt/version.rb
+- string_utility_belt.gemspec
 - 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/regex_me/builders_test.rb
+- test/string_utility_belt/regex_me/helper_test.rb
 - test/string_utility_belt/tags_test.rb
 - test/test_helper.rb
 homepage: ""

data/lib/string_utility_belt/regex_me/lib/helpers.rb

@@ -1,102 +0,0 @@
-# coding: utf-8
-
-module StringUtilityBelt
-  module RegexMe
-    module Helper
-      A_VARIATIONS = "(a|à|á|â|ã|ä)"
-      E_VARIATIONS = "(e|è|é|ê|ë)"
-      I_VARIATIONS = "(i|ì|í|î|ï)"
-      O_VARIATIONS = "(o|ò|ó|ô|õ|ö)"
-      U_VARIATIONS = "(u|ù|ú|û|ü)"
-      C_VARIATIONS = "(c|ç)"
-      N_VARIATIONS = "(n|ñ)"
-
-      LATIN_CHARS_VARIATIONS = [A_VARIATIONS,
-        E_VARIATIONS,
-        I_VARIATIONS,
-        O_VARIATIONS,
-        U_VARIATIONS,
-        C_VARIATIONS,
-        N_VARIATIONS]
-
-        BORDER_TO = {
-          :ruby => {:left => '\b', :right => '\b' },
-          :mysql => {:left => '[[:<:]]', :right => '[[:>:]]' }
-        }
-
-        def regex_latin_ci_list
-          memo = ""
-
-          self.each_char do |char|
-            changed = false
-
-            for variations in LATIN_CHARS_VARIATIONS
-              variations_pattern = Regexp.new(variations, Regexp::IGNORECASE)
-
-              if char =~ variations_pattern
-                changed = true
-                memo.insert(-1, variations)
-                break
-              end
-            end
-
-            memo.insert(-1, char) unless changed
-          end
-
-          self.replace(memo)
-        end
-
-        def regex_builder(options)
-          if options[:any]
-            replace_the_any_char_per_any_pattern
-          end
-
-          if options[:latin_chars_variations]
-            replace_chars_includeds_in_latin_variation_list
-          end
-
-          if options[:border]
-            insert_border(options[:border])
-          end
-
-          if options[:or]
-            insert_OR
-          end
-
-          return self
-        end
-
-        private
-        def replace_the_any_char_per_any_pattern
-          self.gsub!(/\*/, '.*')
-        end
-
-        def replace_chars_includeds_in_latin_variation_list
-          self.regex_latin_ci_list
-        end
-
-        def insert_border(options)
-          border = BORDER_TO[options[:to]]
-
-          case options[: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])
-          else
-            self
-          end
-        end
-
-        def insert_OR
-          self.insert(-1, "|")
-        end
-    end
-  end
-end
-
-class String
-  include StringUtilityBelt::RegexMe::Helper
-end