string_utility_belt 0.3.0 → 0.3.1

data/lib/string_utility_belt.rb

@@ -1,6 +1,6 @@
 require 'string_utility_belt/version'
 
-require 'string_utility_belt/regex_me_to_search'
+require 'string_utility_belt/regex_me'
 require 'string_utility_belt/general'
 require 'string_utility_belt/match_rank'
 require 'string_utility_belt/tags'

data/lib/string_utility_belt/general.rb

@@ -1,41 +1,48 @@
-require 'string_utility_belt/regex_me_to_search'
+require 'string_utility_belt/regex_me'
 
 module StringUtilityBelt
   module General
     class GENERAL
       CASE_INSENSITIVE_OPT = {:case_insensitive => true}
 
-      def have_this_words?(string, words_to_match, options)
-        @string    = string
+      def initialize(string)
+        @string = string
+      end
+
+      def have_this_words?(words_to_match, options)
         @arguments = options
 
         for word in words_to_match
-          return false if string_does_not_match_with_this_word_pattern?(word)
+          return false if not word_is_found_in_the_string?(word)
         end
 
         return true
       end
 
       private
-      def string_does_not_match_with_this_word_pattern?(word)
-        @string !~ word.regex_me_to_search_ruby(arguments)
+      def word_is_found_in_the_string?(word)
+        @string =~ word.regex_me_to_search_ruby(arguments)
       end
 
       def arguments
-        if is_boolean?
+        if args_is_nil? or args_is_boolean?
           CASE_INSENSITIVE_OPT.merge({:exact_word => @arguments})
-        elsif is_hash?
+        elsif args_is_hash?
           @arguments.merge(CASE_INSENSITIVE_OPT)
         end
       end
 
-      def is_boolean?
+      def args_is_boolean?
         @arguments.instance_of?(FalseClass) || @arguments.instance_of?(TrueClass)
       end
 
-      def is_hash?
+      def args_is_hash?
         @arguments.instance_of?(Hash)
       end
+
+      def args_is_nil?
+        @arguments.nil?
+      end
     end
 
     WORD_PATTERN      = /\w[\w\'\-]*/
@@ -55,14 +62,14 @@ module StringUtilityBelt
       self.gsub!(ANY_SPACE_PATTERN, SIMPLE_SPACE)
     end
 
-    def have_this_words?(words_to_match, options = false)
-      i = GENERAL.new
-      i.have_this_words?(self, words_to_match, options)
+    def have_this_words?(words_to_match, options = nil)
+      i = GENERAL.new(self)
+      i.have_this_words?(words_to_match, options)
     end
 
-    def not_have_this_words?(words_to_match, options = false)
-      i = GENERAL.new
-      !i.have_this_words?(self, words_to_match, options)
+    def not_have_this_words?(words_to_match, options = nil)
+      i = GENERAL.new(self)
+      !i.have_this_words?(words_to_match, options)
     end
   end
 end

data/lib/string_utility_belt/match_rank.rb

@@ -1,46 +1,103 @@
-require 'string_utility_belt/regex_me_to_search'
+require 'string_utility_belt/regex_me'
 
 module StringUtilityBelt
   module MatchRank
+    class MATCHRANK
+      TOTAL_TEMPLATE = {:exact => 0, :matched => 0}
+      SCORE_TEMPLATE = TOTAL_TEMPLATE.merge({:precision => 0})
 
-    def total_frequency_by words_to_match
-      frequency_by(words_to_match, 0, 0) do |freq, word_to_match, word|
-        freq[:exact]   += 1 if word =~ word_to_match.regex_me_to_search_ruby(:exact_word => true  , :case_insensitive => true)
-        freq[:matched] += 1 if word =~ word_to_match.regex_me_to_search_ruby(:exact_word => false , :case_insensitive => true)
+      def initialize(string)
+        @text = string
       end
-    end
 
-    def words_frequency_by words_to_match
-      frequency_by(words_to_match, Hash.new(0), Hash.new(0)) do |freq, word_to_match, word|
-        freq[:exact][word_to_match]   += 1 if word =~ word_to_match.regex_me_to_search_ruby(:exact_word => true  , :case_insensitive => true)
-        freq[:matched][word_to_match] += 1 if word =~ word_to_match.regex_me_to_search_ruby(:exact_word => false , :case_insensitive => true)
+      def frequency(options)
+        @options = options
+        @result  = result_template
+
+        for @search_word in search_words
+          for @text_word in @text.words
+            count_exact_matches
+            count_fragmet_matches
+          end
+        end
+
+        calculate_the_precision if @options[:template] == :precision
+
+        return @result
       end
-    end
 
-    def match_and_score_by words_to_match
-      freq = self.total_frequency_by words_to_match
-      statistic = {:exact => freq[:exact].to_f, :matched => freq[:matched].to_f, :precision => 0.0}
+      private
+
+      def search_words
+        words = @options[:search_words]
+        words.instance_of?(Array) ? words : words.to_s.words
+      end
 
-      statistic[:precision] = (statistic[:exact] / statistic[:matched]) * 100
+      def count_exact_matches
+        incr_result(:exact) if find_the_wanted_word(:with_precision => true)
+      end
 
-      return statistic
-    end
+      def count_fragmet_matches
+        incr_result(:matched) if find_the_wanted_word(:with_precision => false)
+      end
 
-    private
+      def calculate_the_precision
+        @result[:precision] = (@result[:exact].to_f / @result[:matched].to_f) * 100
+      end
+
+      def find_the_wanted_word(option)
+        @text_word =~ matcher(option[:with_precision])
+      end
 
-    def frequency_by words_to_match, frequency_object_a, frequency_object_b
-      self_words = self.words
-      freq = {:exact => frequency_object_a, :matched => frequency_object_b}
+      def matcher(precision)
+        @search_word.regex_me_to_search_ruby(:exact_word => precision,
+                                             :case_insensitive => true)
+      end
 
-      for word_to_match in words_to_match
-        for word in self_words
-          yield freq, word_to_match, word
+      def incr_result(key)
+        case @options[:template]
+        when :grouped_words
+          begin
+            @result[key][@search_word] += 1
+          rescue
+            @result[key][@search_word] = 0
+            @result[key][@search_word] += 1
+          end
+        else
+          @result[key] += 1
         end
       end
 
-      return freq
+      def result_template
+        templates.fetch(@options[:template]).clone
+      end
+
+      def templates
+        {
+         :total => TOTAL_TEMPLATE,
+         :precision => SCORE_TEMPLATE,
+         :grouped_words => {:exact => {}, :matched => {}}
+        }
+      end
+    end
+
+    def total_frequency_by(words)
+      measure.frequency(:template => :total, :search_words => words)
     end
 
+    def words_frequency_by(words)
+      measure.frequency(:template => :grouped_words, :search_words => words)
+    end
+
+    def match_and_score_by(words)
+      measure.frequency(:template => :precision, :search_words => words)
+    end
+
+    private
+
+    def measure
+      MATCHRANK.new(self)
+    end
   end
 end
 

data/lib/string_utility_belt/regex_me.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/regex_me/regex_me'

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

@@ -0,0 +1,99 @@
+require File.dirname(__FILE__) + '/configurations'
+require File.dirname(__FILE__) + '/helpers'
+
+module RegexMe
+  module Builders
+    include RegexMe::Configurations::Builder
+
+    def regex_me_to_search_ruby(options = {})
+      regex_me_to_search(:ruby, options)
+    end
+
+    def regex_me_to_search_mysql(options = {})
+      regex_me_to_search(:mysql, options)
+    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 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}
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+module RegexMe
+  module Configurations
+    module Builder
+      EMPTYs = {:ruby => //, :mysql => ''}
+      WORDS_INTERVAL_PATTERN_FOR_EXACT_PHRASES = '[^0-9a-zA-Z\_]+'
+    end
+  end
+end
+
+

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

@@ -0,0 +1,102 @@
+# 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

data/lib/string_utility_belt/regex_me/regex_me.rb

@@ -0,0 +1,5 @@
+require File.dirname(__FILE__) + '/lib/builders.rb'
+
+class String
+  include RegexMe::Builders
+end

data/lib/string_utility_belt/version.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: string_utility_belt
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 17
   prerelease: 
   segments: 
   - 0
   - 3
-  - 0
-  version: 0.3.0
+  - 1
+  version: 0.3.1
 platform: ruby
 authors: 
 - Rodrigo Serradura
@@ -15,10 +15,25 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-07 00:00:00 Z
-dependencies: []
-
-description: Adiciona novas funcionalidades para strings
+date: 2011-07-12 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: htmlentities
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 51
+        segments: 
+        - 4
+        - 3
+        - 0
+        version: 4.3.0
+  type: :runtime
+  version_requirements: *id001
+description: Adds new features for String objects.
 email: 
 - rserradura@gmail.com
 executables: []
@@ -37,8 +52,11 @@ files:
 - 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/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/regex_me.rb
 - lib/string_utility_belt/tags.rb
 - lib/string_utility_belt/version.rb
 - test/string_utility_belt/entities_test.rb
@@ -80,6 +98,6 @@ rubyforge_project: string_utility_belt
 rubygems_version: 1.8.2
 signing_key: 
 specification_version: 3
-summary: Metodos uteis para strings
+summary: Useful methods to handle strings
 test_files: []
 

data/lib/string_utility_belt/regex_me_helper.rb

@@ -1,100 +0,0 @@
-# coding: utf-8
-
-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
-
-class String
-  include RegexMe::Helper
-end

data/lib/string_utility_belt/regex_me_to_search.rb

@@ -1,107 +0,0 @@
-require 'string_utility_belt/regex_me_helper'
-
-module StringUtilityBelt
-  module RegexMe
-    EMPTYs = {:ruby => //, :mysql => ''}
-    WORDS_INTERVAL_PATTERN_FOR_EXACT_PHRASES = '[^0-9a-zA-Z\_]+'
-
-    module To
-      module Search
-        def regex_me_to_search_ruby(options = {})
-          regex_me_to_search(:ruby, options)
-        end
-
-        def regex_me_to_search_mysql(options = {})
-          regex_me_to_search(:mysql, options)
-        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 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}
-        end
-      end
-    end
-  end
-end
-
-class String
-  include StringUtilityBelt::RegexMe::To::Search
-end