facets 2.7.0 → 2.8.0

data/lib/core/facets/string/index_all.rb

@@ -0,0 +1,24 @@
+class String
+
+  # Like index but returns an array of all index locations.
+  # The reuse flag allows the trailing portion of a match to be
+  # reused for subsquent matches.
+  #
+  #   "abcabcabc".index_all('a')  #=> [0,3,6]
+  #
+  #   "bbb".index_all('bb', false)  #=> [0]
+  #   "bbb".index_all('bb', true)   #=> [0,1]
+  #
+  # TODO: Culd probably be defined for Indexable in general too.
+
+  def index_all(s, reuse=false)
+    s = Regexp.new(Regexp.escape(s)) unless Regexp===s
+    ia = []; i = 0
+    while (i = index(s,i))
+      ia << i
+      i += (reuse ? 1 : $~[0].size)
+    end
+    ia
+  end
+
+end

data/lib/core/facets/string/lines.rb

@@ -4,16 +4,13 @@ class String
 
     # Returns an array of characters.
     #
-    #   "abc\n123".lines  #=> ["abc","123"]
-    #
-    # Note, this is not 100% compatible with 1.8.7+
-    # which returns an enumerator instead of an array.
+    #   "abc\n123".lines  #=> ["abc\n","123"]
     #
     def lines(&blk)
       if block_given?
-        self.split(/\n/).each(&blk)
+        each_line(&blk) #scan(/$.*?\n/).each(&blk)
       else
-        self.split(/\n/)
+        Enumerator.new(self, :lines) #.split(/\n/)
       end
     end
 

data/lib/core/facets/string/margin.rb

@@ -8,9 +8,10 @@ class String
   #         |     margin controlled!
   #         }.margin
   #
-  #
   # NOTE: This may still need a bit of tweaking.
   #
+  # TODO: describe its limits and caveats and edge cases
+  #
   # CREDIT: Trans
 
   def margin(n=0)

data/lib/core/facets/string/newlines.rb

@@ -0,0 +1,35 @@
+require "facets/enumerator"
+
+class String
+
+  # Returns an Enumerator for iterating over each
+  # line of the string, void of the termining newline
+  # character, in contrast to #lines which retains it.
+  #
+  def newlines(&block)
+    if block
+      scan(/^.*?$/) do |line|
+        block.call(line.chomp)
+      end
+    else
+      Enumerator.new(self) do |output|
+        scan(/^.*?$/) do |line|
+          output.yield(line.chomp)
+        end
+      end
+    end
+  end
+
+end
+
+=begin test
+
+  "a\nb\nc".newlines.class.must == Enumerator
+  "a\nb\nc".newlines.to_a.must == %w{a b c}
+
+  a = []
+  "a\nb\nc".newlines{|nl| a << nl}
+  a.must == %w{a b c}
+
+=end
+

data/lib/core/facets/string/op_div.rb

@@ -0,0 +1,14 @@
+class String
+
+  # Treats +self+ and +path+ as representations
+  # of pathnames, joining thme together as a
+  # single path.
+  #
+  #   'home'/'trans' #=> 'home/trans'
+  #
+  def /(path)
+    File.join(self, path)
+  end
+
+end
+

data/lib/core/facets/string/range.rb

@@ -45,32 +45,12 @@ class String
 
   def range_of_line
     offset=0; charmap = []
-    self.each do |line|
+    each_line do |line|
       charmap << (offset..(offset + line.length - 1))
       offset += line.length
     end
     charmap
   end
 
-  # Like index but returns an array of all index locations.
-  # The reuse flag allows the trailing portion of a match to be
-  # reused for subsquent matches.
-  #
-  #   "abcabcabc".index_all('a')  #=> [0,3,6]
-  #
-  #   "bbb".index_all('bb', false)  #=> [0]
-  #   "bbb".index_all('bb', true)   #=> [0,1]
-  #
-  # TODO: Culd probably be defined for Indexable in general too.
-
-  def index_all(s, reuse=false)
-    s = Regexp.new(Regexp.escape(s)) unless Regexp===s
-    ia = []; i = 0
-    while (i = index(s,i))
-      ia << i
-      i += (reuse ? 1 : $~[0].size)
-    end
-    ia
-  end
-
 end
+

data/lib/core/facets/string/range_all.rb

@@ -0,0 +1 @@
+require 'facets/string/range'

data/lib/core/facets/string/range_of_line.rb

@@ -0,0 +1 @@
+require 'facets/string/range'

data/lib/core/facets/string/similarity.rb

@@ -0,0 +1,92 @@
+#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.
+  #
+  # Still a bit rough. Any suggestions for improvement are welcome.
+  #
+  # CREDIT: Derek Lewis.
+  #
+  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
+
+  # DEPRECATED alias
+  #alias_method :fuzzy_match, :similarity
+
+end
+

data/lib/core/facets/string/start_with.rb

@@ -2,10 +2,10 @@ class String
 
   unless method_defined?(:start_with?) # 1.8.7+
 
-    # Does a string start with the given prefix.
+    # Does a string start with the given prefix?
     #
-    #   "hello".starts_with?("he")    #=> true
-    #   "hello".starts_with?("to")    #=> false
+    #   "hello".start_with?("he")    #=> true
+    #   "hello".start_with?("to")    #=> false
     #
     # CREDIT: Lucas Carlson, Blaine Cook
 
@@ -19,8 +19,8 @@ class String
 
     # Does a string end with the given suffix?
     #
-    #   "hello".ends_with?("lo")    #=> true
-    #   "hello".ends_with?("to")    #=> false
+    #   "hello".end_with?("lo")    #=> true
+    #   "hello".end_with?("to")    #=> false
     #
     # CREDIT: Lucas Carlson, Blaine Cook
 
@@ -31,7 +31,7 @@ class String
   end
 
   alias_method :starts_with?, :start_with?
-  alias_method :ends_with?  , :ends_with?
+  alias_method :ends_with?  , :end_with?
 
 end
 

data/lib/core/facets/string/titlecase.rb

@@ -8,7 +8,7 @@ class String
   # CREDIT: Eliazar Parra
 
   def titlecase
-    gsub(/\b\w/){$&.upcase}
+    gsub(/\b\w/){ $`[-1,1] == "'" ? $& : $&.upcase }
   end
 
 end

data/lib/more/facets/basicobject.rb

@@ -15,20 +15,29 @@ unless defined? BasicObject  # just in case it already exists!
   # depend upon <tt>method_missing</tt> (e.g. dynamic proxies).
   class BasicObject
     class << self
-
       # Hide the method named +name+ in the BlankSlate class.  Don't
       # hide +instance_eval+ or any method beginning with "__".
+      #
+      # According to 1.9.1 it should have only these methods:
+      #
+      # * #__send__
+      # * #instance_eval
+      # * #instance_exec
+      # * #equal?
+      # * #==
+      # * #!
+      # * #!=
+      #
+      # Seems to me it should have #__id__ too.
       def hide(name)
         undef_method name if
-        instance_methods.include?(name.to_s) and
-        name !~ /^(__|instance_eval)/
+          instance_methods.include?(name.to_s) and
+          name !~ /^(__|instance_eval$|instance_exec$|equal\?$|\=\=$)/
       end
     end
-
     instance_methods.each { |m| hide(m) }
   end
 
-
   # Since Ruby is very dynamic, methods added to the ancestors of
   # BlankSlate <em>after BlankSlate is defined</em> will show up in the
   # list of available BlankSlate methods.  We handle this by defining a
@@ -42,7 +51,7 @@ unless defined? BasicObject  # just in case it already exists!
       def method_added(name)
         blank_slate_method_added(name)
         return if self != Kernel
-        BlankSlate.hide(name)
+        BasicObject.hide(name)
       end
     end
   end
@@ -56,18 +65,10 @@ unless defined? BasicObject  # just in case it already exists!
       def method_added(name)
         blank_slate_method_added(name)
         return if self != Object
-        BlankSlate.hide(name)
+        BasicObject.hide(name)
       end
     end
   end
 
 end
 
-unless defined? BlankSlate
-
-  # ActiveSupport compatiable version of BasicObject
-  # if not Ruby 1.9+ uses Jim Weirich's BlankSlate.
-  BlankSlate = BasicObject
-
-end
-

data/lib/more/facets/blankslate.rb

@@ -1,2 +1,10 @@
 warn "Use BasicObject instead of BlankSlate for future versions."
 require 'facets/basicobject'
+
+
+unless defined? BlankSlate
+  # ActiveSupport compatiable version of BasicObject
+  # if not Ruby 1.9+ uses Jim Weirich's BlankSlate.
+  BlankSlate = ::BasicObject
+end
+

data/lib/more/facets/class_extend.rb

@@ -1 +1,126 @@
-require 'facets/module/class_extend'
+# = Class Extension
+#
+# Normally when including modules, class/module methods are not
+# extended. To achieve this behavior requires some clever
+# Ruby Karate. Instead class_extension provides an easy to use
+# and clean solution. Simply place the extending class methods
+# in a block of the special module method #class_extension.
+#
+#   module Mix
+#     def inst_meth
+#       puts 'inst_meth'
+#     end
+#
+#     class_extend do
+#       def class_meth
+#         "Class Method!"
+#       end
+#     end
+#   end
+#
+#   class X
+#     include Mix
+#   end
+#
+#   X.class_meth  #=> "Class Method!"
+#
+# == History
+#
+# Thanks to Trans, Nobu and Ulysses for their original on this concept.
+#
+# == Authors
+#
+# * Daniel Schierbeck
+# * Thomas Sawyer
+# * Nobu Nakada
+# * Ulysses
+#
+# == Copying
+#
+# Copyright (c) 2006 Daniel Schierbeck
+#
+# Ruby License
+#
+# This module is free software. You may use, modify, and/or redistribute this
+# software under the same terms as Ruby.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.
+
+#
+class Module
+
+  alias_method :append_features_without_class_extension, :append_features
+
+  # Normally when including modules, class/module methods are not
+  # extended. To achieve this behavior requires some clever
+  # Ruby Karate. Instead #class_extend provides an easy to use
+  # and clean solution. Simply place the extending class methods
+  # in a block of the special module method #class_extend.
+  #
+  #   module Mix
+  #     def inst_meth
+  #       puts 'inst_meth'
+  #     end
+  #
+  #     class_extend do
+  #       def class_meth
+  #         "Class Method!"
+  #       end
+  #     end
+  #   end
+  #
+  #   class X
+  #     include Mix
+  #   end
+  #
+  #   X.class_meth  #=> "Class Method!"
+  #
+  # NOTE: This old #class_extension version of this method
+  # did not extend the containing class automatically --it had
+  # to be done by hand. With #class_extend, that is no longer
+  # the case.
+  #
+  def class_extend(*mods, &block)
+    @class_extension ||= Module.new do
+      def self.append_features(mod)
+        append_features_without_class_extension(mod)
+      end
+    end
+    @class_extension.__send__(:include, *mods)
+    @class_extension.module_eval(&block) if block_given?
+    extend(@class_extension)  # extend this module too
+    @class_extension
+  end
+
+  # TODO: DEPRECATE
+  alias_method :class_extension, :class_extend
+
+  #private :class_extend
+
+  # Override +append_features+ to handle class-inheritable extensions.
+  def append_features(mod)
+    append_features_without_class_extension(mod)
+    mod.extend(class_extend)
+    if mod.instance_of? Module
+      mod.__send__(:class_extend).__send__(:include, class_extend)
+    end
+  end
+
+end
+
+class Class
+  # For Class, #class_extend is the same as class_eval.
+  # The alternative is to "undef_method :class_extend",
+  # but this seems uneccessarily limited.
+  #
+  def class_extend(*mods, &block)
+    m = Module.new
+    m.__send__(:include, *mods)
+    m.module_eval(&block)
+    extend(m)
+    m
+  end
+end
+