mack-facets 0.8.1 → 0.8.2

data/lib/gems/english-0.3.1/lib/english/similarity.rb

@@ -0,0 +1,103 @@
+# TITLE:
+#
+#   String Comparison Extensions
+#
+# SUMMARY:
+#
+#   String comparison extensions.
+#
+# AUTHORS:
+#
+#   - Derek Lewis
+
+#require 'facets/string/cmp'
+#require 'facets/blank'
+#require 'facets/string/natcmp'
+
+class String
+
+  # A fuzzy matching mechanism. Returns a score from 0-1,
+  # based on the number of shared edges.
+  # To be effective, the strings must be of length 2 or greater.
+  #
+  #   "Alexsander".fuzzy_match( "Aleksander" )  #=> 0.9
+  #
+  # The way it works:
+  #
+  # * Converts each string into a "graph like" object, with edges
+  #     "alexsander" -> [ alexsander, alexsand, alexsan ... lexsand ... san ... an, etc ]
+  #     "aleksander" -> [ aleksander, aleksand ... etc. ]
+  # * Perform match, then remove any subsets from this matched set (i.e. a hit
+  #   on "san" is a subset of a hit on "sander")
+  #     Above example, once reduced -> [ ale, sander ]
+  # * See's how many of the matches remain, and calculates a score based
+  #   on how many matches, their length, and compare to the length of the
+  #   larger of the two words.
+  #--
+  # Credit goes to Derek Lewis. Thanks Derek!
+  # Still a bit rough. Any suggestions for improvement are welcome.
+  #++
+
+  def similarity( str_in )
+    return 0 if str_in == nil
+    return 1 if self == str_in
+
+    # Make a graph of each word (okay, so its not a true graph, but is similar)
+    graph_A = Array.new
+    graph_B = Array.new
+
+    # "graph" self
+    last = self.length
+    (0..last).each do |ff|
+      loc  = self.length
+      break if ff == last - 1
+      wordB = (1..(last-1)).to_a.reverse!
+      if (wordB != nil)
+        wordB.each do |ss|
+          break if ss == ff
+          graph_A.push( "#{self[ff..ss]}" )
+        end
+      end
+    end
+
+    # "graph" input string
+    last = str_in.length
+    (0..last).each{ |ff|
+      loc  = str_in.length
+      break if ff == last - 1
+      wordB = (1..(last-1)).to_a.reverse!
+      wordB.each do |ss|
+        break if ss == ff
+        graph_B.push( "#{str_in[ff..ss]}" )
+      end
+    }
+
+    # count how many of these "graph edges" we have that are the same
+    matches = graph_A & graph_B
+    #matches = Array.new
+    #graph_A.each do |aa|
+    #  matches.push( aa ) if( graph_B.include?( aa ) )
+    #end
+
+    # For eliminating subsets, we want to start with the smallest hits.
+    matches.sort!{|x,y| x.length <=> y.length}
+
+    # eliminate any subsets
+    mclone = matches.dup
+    mclone.each_index do |ii|
+      reg = Regexp.compile( Regexp.escape(mclone[ii]) )
+      count = 0.0
+      matches.each{|xx| count += 1 if xx =~ reg}
+      matches.delete(mclone[ii]) if count > 1
+    end
+
+    score = 0.0
+    matches.each{ |mm| score += mm.length }
+    self.length > str_in.length ? largest = self.length : largest = str_in.length
+    return score/largest
+  end
+
+  alias_method :fuzzy_match, :similarity
+
+end
+

data/lib/gems/english-0.3.1/lib/english/soundex.rb

@@ -0,0 +1,70 @@
+# = TITLE:
+#   Soundex
+#
+# = SYNOPSIS:
+#   Ruby implementation of the Soundex algorithm,
+#   as described by Knuth in volume 3 of The Art
+#   of Computer Programming.
+#
+# = AUTHOR:
+#   Michael Neumann (neumann@s-direktnet.de)
+
+module English # :nodoc:
+
+  # Ruby implementation of the Soundex algorithm,
+  # as described by Knuth in volume 3 of The Art
+  # of Computer Programming.
+
+  module Soundex
+
+    module_function
+
+    # Returns nil if the value couldn't be calculated b/c of
+    # empty-string or invalid character.
+    #
+    #   "Ruby".soundex  #=> "R100"
+
+    def soundex(str)
+      return nil if str.empty?
+
+      str = str.upcase
+      last_code = soundex_code(str[0,1])
+      soundex_code = str[0,1]
+
+      for index in 1...(str.size) do
+        return soundex_code if soundex_code.size == 4
+
+        code = soundex_code(str[index,1])
+
+        if code == "0" then
+          last_code = nil
+        elsif code == nil then
+          return nil
+        elsif code != last_code then
+          soundex_code += code
+          last_code = code
+        end
+      end
+
+      return soundex_code + "000"[0,4-soundex_code.size]
+    end
+
+    # Support function for String#soundex.
+    # Returns code for a single character.
+
+    def soundex_code(char)
+      char.tr! "AEIOUYWHBPFVCSKGJQXZDTLMNR", "00000000111122222222334556"
+    end
+
+  end # module Soundex
+
+end # module English
+
+
+class String
+
+  def soundex
+    English::Soundex.soundex(self)
+  end
+
+end

data/lib/gems/english-0.3.1/lib/english/string.rb

@@ -0,0 +1,210 @@
+module English
+
+  module String
+
+    # Returns an array of characters.
+    #
+    #   "abc 123".words  #=> ["abc","123"]
+    #
+    def words
+      self.split(/\s+/)
+    end
+
+    # Iterate through each word of a string.
+    #
+    #   "a string".each_word { |word, range| ... }
+    #
+    def each_word_with_range(&yld)
+      rest_of_string = self
+      wordfind = /([-'\w]+)/
+      arity = yld.arity
+      offset = 0
+      while wmatch = wordfind.match(rest_of_string)
+        word = wmatch[0]
+        range = offset+wmatch.begin(0) ... offset+wmatch.end(0)
+        rest_of_string = wmatch.post_match
+        if arity == 1
+          yld.call(word)
+        else
+          yld.call(word, range)
+        end
+        offset = self.length - rest_of_string.length
+      end
+    end
+
+    # Filters out words from a string based on block test.
+    #
+    #   "a string".word_filter { |word| word =~ /^a/ }  #=> "string"
+    #
+    #   CREDIT: George Moschovitis
+
+    def word_filter( &blk )
+      s = self.dup
+      s.word_filter!( &blk )
+    end
+
+    # In place version of #word_filter.
+    #
+    #   "a string".word_filter { |word| ... }
+    #
+    #   CREDIT: George Moschovitis
+
+    def word_filter! #:yield:
+      rest_of_string = self
+      wordfind = /(\w+)/
+      offset = 0
+      while wmatch = wordfind.match(rest_of_string)
+        word = wmatch[0]
+        range = offset+wmatch.begin(0) ... offset+wmatch.end(0)
+        rest_of_string = wmatch.post_match
+        self[range] = yield( word ).to_s
+        offset = self.length - rest_of_string.length
+      end
+      self
+    end
+
+    # TODO: This is alternateive from glue: worth providing?
+    #
+    # Enforces a maximum width of a string inside an
+    # html container. If the string exceeds this maximum width
+    # the string gets wraped.
+    #
+    # Not really useful, better use the CSS overflow: hidden
+    # functionality.
+    #
+    # === Input:
+    # the string to be wrapped
+    # the enforced width
+    # the separator used for wrapping
+    #
+    # === Output:
+    # the wrapped string
+    #
+    # === Example:
+    #  text = "1111111111111111111111111111111111111111111"
+    #  text = wrap(text, 10, " ")
+    #  p text # => "1111111111 1111111111 1111111111"
+    #
+    # See the test cases to better understand the behaviour!
+
+    #   def wrap(width = 20, separator = " ")
+    #     re = /([^#{separator}]{1,#{width}})/
+    #     scan(re).join(separator)
+    #   end
+
+    # Word wrap a string not exceeding max width.
+    #
+    #   puts "this is a test".word_wrap(4)
+    #
+    # _produces_
+    #
+    #   this
+    #   is a
+    #   test
+    #
+    #   CREDIT: Gavin Kistner
+    #   CREDIT: Dayne Broderson
+
+    def word_wrap( col_width=80 )
+      self.dup.word_wrap!( col_width )
+    end
+
+    # As with #word_wrap, but modifies the string in place.
+    #
+    #   CREDIT: Gavin Kistner
+    #   CREDIT: Dayne Broderson
+
+    def word_wrap!( col_width=80 )
+      self.gsub!( /(\S{#{col_width}})(?=\S)/, '\1 ' )
+      self.gsub!( /(.{1,#{col_width}})(?:\s+|$)/, "\\1\n" )
+      self
+    end
+
+    # old def
+
+    #def word_wrap(max=80)
+    #  c = dup
+    #  c.word_wrap!(max)
+    #  c
+    #end
+
+    #def word_wrap!(max=80)
+    #  raise ArgumentError, "Wrap margin too low: #{n}" if max <= 2
+    #  #gsub!( Regexp.new( "(.{1,#{max-1}}\\w)\\b\\s*" ), "\\1\n")
+    #  gsub!( /(.{1,#{max-1}}\S)([ ]|\n)/, "\\1\n")
+    #end
+
+    # Returns a new string with all new lines removed from
+    # adjacent lines of text.
+    #
+    #   s = "This is\na test.\n\nIt clumps\nlines of text."
+    #   s.fold
+    #
+    # _produces_
+    #
+    #   "This is a test.\n\nIt clumps lines of text. "
+    #
+    # One arguable flaw with this, that might need a fix:
+    # if the given string ends in a newline, it is replaced with
+    # a single space.
+    #
+    #   CREDIT: Trans
+
+    def fold(ignore_indented=false)
+      ns = ''
+      i = 0
+      br = self.scan(/(\n\s*\n|\Z)/m) do |m|
+        b = $~.begin(1)
+        e = $~.end(1)
+        nl = $&
+        tx = slice(i...b)
+        if ignore_indented and slice(i...b) =~ /^[ ]+/
+          ns << tx
+        else
+          ns << tx.gsub(/[ ]*\n+/,' ')
+        end
+        ns << nl
+        i = e
+      end
+      ns
+    end
+
+    # Returns short abstract of long strings; not exceeding +range+
+    # characters. If range is an integer then the minimum is 20%
+    # of the maximum. The string is chopped at the nearest word
+    # if possible, and appended by +ellipsis+, which defaults
+    # to '...'.
+    #
+    #   CREDIT: George Moschovitis
+    #   CREDIT: Trans
+    #
+    def brief(range=76, ellipsis="...")
+      if Range===range
+        min = range.first
+        max = range.last
+      else
+        max = range
+        min = max - (max/5).to_i
+        range = min..max
+      end
+
+      if size > max
+        cut_at = rindex(/\b/, max) || max
+        cut_at = max if cut_at < min
+        xstring = slice(0, cut_at)
+        xstring.chomp(" ") + ellipsis
+      else
+        self
+      end
+    end
+
+  end
+
+end
+
+
+class String #:nodoc:
+  include English::String
+end
+
+

data/lib/gems/english-0.3.1/lib/english/style.rb

@@ -0,0 +1,294 @@
+module English
+  #require 'english/inflect'
+
+  # The Style mixin provides a means of applying common alteration
+  # patterns to strings.
+  #
+  # This module is automatically mixed into the String class, but the
+  # Style mixin is designed in such a way that it can be mixed into
+  # any class that supports the #to_s method.
+  #
+  # Examples
+  #
+  #   "SuperMan".snakecase   #=> "super_man"
+  #   "super_man".dasherize  #=> "super-man"
+  #
+  #--
+  # TODO: Would like to provide a means for mixing into Symbol
+  #       so that Symbols are returned. Use #to_self(obj)?
+  #
+  # TODO: With #pathize, is downcasing really needed? After all paths
+  #       can have capitalize letters ;p
+  #
+  # TODO: With #methodize, is downcasing any but the first letter
+  #       really needed? Desipite Matz preference methods can have
+  #       capitalized letters.
+  #++
+  module Style
+
+    # Case Styles
+    # ______________________________________________________________
+
+    # Standard downcase style.
+    def downcase
+      to_s.downcase
+    end
+
+    # Same as downcase style.
+    def lowercase
+      to_s.downcase
+    end
+
+    # Standard upcase style.
+    def upcase
+      to_s.upcase
+    end
+
+    # Same as upcase style.
+    def uppercase
+      to_s.upcase
+    end
+
+    # Standard capitialize style.
+    #
+    # NOTE: I hate this definition and think it
+    #       should be as capitalcase, but Matz
+    #       doesn't agree.
+    def capitalize
+      to_s.capitalize
+    end
+
+    # Upcase first letter.
+    def capitalcase
+      str = to_s
+      str[0,1].upcase + str[1..-1]
+    end
+
+    # Downcase first letter.
+    def uncapitalize
+      str = to_s
+      str[0,1].downcase + str[1..-1]
+    end
+    alias_method :uncapitalcase, :uncapitalize
+
+    # Convert a phrase into a title.
+    #
+    #   "this is a string".titlecase
+    #   => "This Is A String"
+    #
+    def titlecase
+      to_s.gsub(/\b\w/){$&.upcase}
+    end
+
+    # The reverse of +camelize+. Converts a CamelCase word into an
+    # underscored form.
+    #
+    # This also changes '::' to '/', usefule for converting namespaces
+    # to pathnames.
+    #
+    # Examples
+    #   "ActiveRecord".underscore #=> "active_record"
+    #   "ActiveRecord::Errors".underscore #=> active_record/errors
+    #
+    def snakecase
+      to_s.
+      gsub(/::/, '/').
+      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      tr("-", "_").
+      downcase
+    end
+
+    # By default, camelize converts strings to UpperCamelCase. If the
+    # argument to camelize is set to ":lower" then camelize produces
+    # lowerCamelCase.
+    #
+    # camelize will also convert '/' to '::' which is useful for
+    # converting paths to namespaces
+    #
+    #   "active_record".camelcase               #=> "ActiveRecord"
+    #   "active_record/errors".camelcase        #=> "ActiveRecord::Errors"
+    #
+    def camelcase
+      to_s.gsub(/\/(.?)/){ "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/){ $1.upcase }
+    end
+
+    # Convert a snakecase phrase into a camelcase phrase, making
+    # the first letter uppercase.
+    #def upper_camelcase
+    #  to_s.gsub(/\/(.?)/){ "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/){ $1.upcase }
+    #end
+
+    # Convert a snakecase phrase into a camelcase phrase, but making
+    # the first letter lowercase.
+    #
+    #   "active_record".camelcase               #=> "activeRecord"
+    #   "active_record/errors".camelcase        #=> "activeRecord::Errors"
+    #
+    def subcamelcase
+      upper_camelcase.uncapitalize
+    end
+
+    # Numeral Styles
+    # ______________________________________________________________
+
+    # Ordinalize turns a number string into an ordinal string
+    # used to denote the position in an ordered sequence such
+    # as 1st, 2nd, 3rd, 4th.
+    #
+    #   '1'.ordinalize     # => "1st"
+    #   '2'.ordinalize     # => "2nd"
+    #   '1002'.ordinalize  # => "1002nd"
+    #   '1003'.ordinalize  # => "1003rd"
+    #
+    def ordinalize
+      number_string = to_s
+      if number_string =~ /\d{1,2}$/
+        number = $1.to_i     
+        if (11..13).include?(number.to_i % 100)
+          r = "#{number}th"
+        else
+          r = case number.to_i % 10
+            when 1; "#{number}st"
+            when 2; "#{number}nd"
+            when 3; "#{number}rd"
+            else    "#{number}th"
+          end
+        end
+        number_string.sub(/\d{1,2}$/, r)
+      else
+        number_string
+      end
+    end
+
+    #
+    # Obfuscation Styles
+    #______________________________________________________________
+
+    # Jumble string.
+    def jumble
+      j = ''
+      to_s.split(//).each_with_index{ |c,i| j << ( i % 2 == 0 ? c.downcase : c.upcase ) }
+      j
+    end
+
+    # Dresener Obfuscation.
+    #
+    # Scramble the inner characters of words leaving the text still readable
+    # (research at Cambridge University, code by KurtDresner).
+    #
+    # For example, the above text may result in:
+    #
+    #   Srblamce the iennr cchrteaars of wodrs lvenaig the txet stlil rbeaadle
+    #   (rreceash at Cbamigdre Uverintisy, cdoe by KrneruestDr?)
+    #
+    # :credit: Kurt Dresener
+    def dresner
+      to_s.gsub(/\B\w+\B/){$&.split(//).sort_by{rand}}
+    end
+
+    #
+    # Code Styles
+    # ______________________________________________________________
+
+    # Converts a module or method name into a unix pathname.
+    # This method is geared toward code reflection.
+    #
+    #   "MyModule::MyClass".pathize    #=> my_module/my_class
+    #   "my_module__my_class".pathize  #=> my_module/my_class
+    #
+    # TODO: Make sure that all scenarios return a valid unix path.
+    # TODO: Make sure it is revertible.
+    #
+    # See also #modulize, #methodize
+    def pathize
+      to_s.
+      gsub(/__/, '/').
+      gsub(/::/, '/').
+      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      tr("-", "_").
+      downcase
+    end
+
+    # Converts a module name into a valid method name.
+    # This method is geared toward code reflection.
+    #
+    # Examples
+    #   "SuperMan".methodize          #=> "super_man"
+    #   "SuperMan::Errors".methodize  #=> "super_man__errors
+    #   "MyModule::MyClass".methodize #=> "my_module__my_class"
+    #
+    # See also #modulize, #pathize
+    def methodize
+      to_s.
+      gsub(/\//, '__').
+      gsub(/::/, '__').
+      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      tr("-", "_").
+      downcase
+    end
+
+    # Converts a pathized or methodized string into a valid ruby
+    # class or module name. This method is geared toward code
+    # reflection.
+    #
+    #   "camel_case".modulize          #=> "CamelCase"
+    #   "camel/case".modulize          #=> "Camel::Case"
+    #   "my_module__my_path".modulize  #=> "MyModule::MyPath"
+    #
+    # See also #methodize, #pathize
+    def modulize
+      to_s.
+      gsub(/__(.?)/){ "::#{$1.upcase}" }.
+      gsub(/\/(.?)/){ "::#{$1.upcase}" }.
+      gsub(/(?:_+)([a-z])/){ $1.upcase }.
+      gsub(/(^|\s+)([a-z])/){ $1 + $2.upcase }
+    end
+
+    # Removes the module part from a modularized expression.
+    #
+    #   "English::Style".demodulize  #=> "Style"
+    #   "Style".demodulize           #=> "Style"
+    #
+    def demodulize
+      to_s.gsub(/^.*::/, '')
+    end
+
+  end
+
+  # TODO: Replace this will dynamic generate of inplace methods.
+  #       But only when the base defines #replace (?) Need to
+  #       think about this some more.
+  module Style::Replace
+    def downcase!      ; replace(downcase)      ; end
+    def lowercase!     ; replace(lowercase)     ; end
+    def upcase!        ; replace(upcase)        ; end
+    def uppercase!     ; replace(uppercase)     ; end
+    def capitalize!    ; replace(capitalize)    ; end
+    def capitalcase!   ; replace(capitalcase)   ; end
+    def uncapitalcase! ; replace(uncapitalcase) ; end
+    def titlecase!     ; replace(titlecase)     ; end
+    def snakecase!     ; replace(snakecase)     ; end
+    def camelcase!     ; replace(camelcase)     ; end
+    def subcamelcase!  ; replace(subcamelcase)  ; end
+
+    def ordinalize!    ; replace(ordinalize)    ; end
+
+    def jumble!        ; replace(jumble)        ; end
+    def dresner!       ; replace(dresner)       ; end
+
+    def pathize!       ; replace(pathize)       ; end
+    def methodize!     ; replace(methodize)     ; end
+    def modulize!      ; replace(modulize)      ; end
+    def demodulize!    ; replace(demodulize)    ; end
+  end
+
+end
+
+class String #:nodoc:
+  include English::Style
+  include English::Style::Replace
+end
+