facets 2.7.0 → 2.8.0

data/lib/core/facets/kernel/meta_def.rb

@@ -0,0 +1,18 @@
+module Kernel
+
+  # Add method to a meta-class --i.e. a singleton method.
+  #
+  #   class X; end
+  #   X.meta_def(:x){"x"}
+  #   X.x  #=> "x"
+  #
+  # CREDIT: WhyTheLuckyStiff
+
+  def meta_def( name, &block )
+    meta_class do
+      define_method( name, &block )
+    end
+  end
+
+end
+

data/lib/core/facets/kernel/meta_eval.rb

@@ -0,0 +1,18 @@
+module Kernel
+
+
+  # Evaluate code in a metaclass. This is equivalent to
+  # 'meta_class.instance_eval'.
+  #
+  # CREDIT: WhyTheLuckyStiff
+
+  def meta_eval(str=nil, &blk)
+    if str
+      meta_class.instance_eval(str)
+    else
+      meta_class.instance_eval(&blk)
+    end
+  end
+
+end
+

data/lib/core/facets/kernel/object_hexid.rb

@@ -1,12 +1,27 @@
 module Kernel
 
-  # Returns the object id as a string in hexideciaml,
-  # which is how Ruby reports them with inspect.
-  #
-  #   "ABC".object_hexid  #=> "0x402d359c"
+  if RUBY_VERSION < "1.8.7"
+
+    # Returns the object id as a string in hexideciaml,
+    # which is how Ruby reports them with inspect.
+    #
+    #   "ABC".object_hexid  #=> "0x402d359c"
+
+    def object_hexid
+      return "0x" << (('%.x' % (2*self.__id__))[1..-1])
+    end
+
+  else
+
+    # Returns the object id as a string in hexideciaml,
+    # which is how Ruby reports them with inspect.
+    #
+    #   "ABC".object_hexid  #=> "0x402d359c"
+
+    def object_hexid
+      return "0x" << ('%.x' % (2*self.__id__))  #[1..-1]
+    end
 
-  def object_hexid
-    return "0x" << ('%.x' % (2*self.__id__))  #[1..-1]
   end
 
 end

data/lib/core/facets/kernel/object_state.rb

@@ -1,5 +1,7 @@
 class Object
-  # Get state of object.
+  # Get or set state of object.
+  #
+  # TODO: Would #instance_state be a more appropriate name?
   def object_state(data=nil)
     if data
       instance_variables.each do |iv|
@@ -12,7 +14,7 @@ class Object
         name = iv.to_s.sub(/^[@]/, '').to_sym
         data[name] = instance_variable_get(iv)
       end
-      snap
+      data
     end
   end
 

data/lib/core/facets/kernel/populate.rb

@@ -18,7 +18,9 @@ module Kernel
   # order of assignemnt.
   #
   # Using a hash or array will not raise an error if the
-  # accessor does not exits --it will simply be skipped.
+  # accessor does not exits -- it will simply be skipped.
+  #
+  # (See also: instance_vars.update, which sets instance variables directly, bypassing accessor method.)
   #
   # TODO: Better name, #set_with ?
 

data/lib/core/facets/kernel/with.rb

@@ -1,6 +1,6 @@
 module Kernel
 
-  # Like returning but exectures the block
+  # Like returning but exectues the block
   # via instance_eval.
   #
   #   def foo

data/lib/core/facets/metaid.rb

@@ -1,94 +1,7 @@
-module Kernel
-
-  # Alias a method defined in the metaclass (ie. singleton class).
-  #
-  #   def X.y?; "y?" ; end
-  #   X.meta_alias "ynot?", "y?"
-  #   X.ynot?  #=> y?
-  #
-  # CREDIT: Trans
-
-  def meta_alias(*args)
-    meta_class do
-      alias_method(*args)
-    end
-  end
-
-  # Evaluate code in a metaclass. This is equivalent to
-  # 'meta_class.instance_eval'.
-  #
-  # CREDIT: WhyTheLuckyStiff
-
-  def meta_eval(str=nil, &blk)
-    if str
-      meta_class.instance_eval(str)
-    else
-      meta_class.instance_eval(&blk)
-    end
-  end
-
-  # Add method to a meta-class --i.e. a singleton method.
-  #
-  #   class X; end
-  #   X.meta_def(:x){"x"}
-  #   X.x  #=> "x"
-  #
-  # CREDIT: WhyTheLuckyStiff
-
-  def meta_def( name, &block )
-    meta_class do
-      define_method( name, &block )
-    end
-  end
-
-  # Easy access to an object's "special" class,
-  # otherwise known as it's metaclass or singleton class.
-
-  def meta_class(&block)
-    if block_given?
-      (class << self; self; end).class_eval(&block)
-    else
-      (class << self; self; end)
-    end
-  end
-
-  alias_method :metaclass, :meta_class
-
-  # During this trying time when no one can get their
-  # techie catchwords to stick to the refrigerator no
-  # matter how hard they slap it # with the enchanted
-  # magnetic spatula, it’s good to know that the
-  # contrived phrases really do fly, graceful and
-  # unclasped and bearing north toward chilled shrimp.
-  # I know what my Hallowe’en pumpkin is going to say.
-  #
-  #                       -- why the lucky stiff
-  #
-  # CREDIT: WhyTheLuckyStiff
-
-  def eigenclass
-    (class << self; self; end)
-  end
-
-end
-
-
-class Module
-
-  # Defines an instance method within a class.
-  #
-  # CREDIT: WhyTheLuckyStiff
-
-  def class_def name, &blk
-    class_eval { define_method name, &blk }
-  end
-
-  protected :attr
-  protected :attr_reader
-  protected :attr_writer
-  protected :attr_accessor
-  protected :remove_method
-  protected :undef_method
-
-end
+require 'facets/kernel/meta_alias'
+require 'facets/kernel/meta_class'
+require 'facets/kernel/meta_def'
+require 'facets/kernel/meta_eval'
+require 'facets/kernel/eigenclass'
+require 'facets/module/class_def'
 

data/lib/core/facets/module/class_def.rb

@@ -0,0 +1,2 @@
+require 'facets/module/module_def'
+

data/lib/core/facets/module/extend.rb

@@ -1,11 +1,10 @@
-class Module
-
-  alias_method :_extend, :extend
-
-  def extend(*mod, &blk)
-    _extend *mod unless mod.empty?
-    _extend Module.new(&blk) if blk
-  end
-
-end
-
+#class Module
+#
+#  alias_method :_extend, :extend
+#
+#  def extend(*mod, &blk)
+#    _extend *mod unless mod.empty?
+#    _extend Module.new(&blk) if blk
+#  end
+#
+#end

data/lib/core/facets/module/is.rb

@@ -6,12 +6,12 @@ class Module
   #  class X ; end
   #  class Y < X ; end
   #
-  #   Y.is?(X)  #=> true
+  #  Y.is?(X)  #=> true
   #
   # CREDIT: Trans
 
   def is?(base)
-    ancestors.slice(1..-1).include?(base)
+    Module===base && ancestors.slice(1..-1).include?(base)
   end
 
   # An alias for #include.
@@ -22,8 +22,6 @@ class Module
   #
   # CREDIT: Trans
 
-  #alias_method :is, :include
-
   def is(*mods)
     mods.each do |mod|
       if mod.const_defined?(:Self)
@@ -38,9 +36,11 @@ class Module
     include(*mods)
   end
 
+  #alias_method :is, :include
+
   # Expirmental idea for #is.
   #
-  # If the module has #append_function_function
+  # If the module has #append_feature_function
   # defined, this will use that instead of #include.
   #
   #   def is(*modules)

data/lib/core/facets/module/module_def.rb

@@ -0,0 +1,31 @@
+class Module
+
+  # Defines an instance method within a class/module.
+  #
+  # CREDIT: WhyTheLuckyStiff
+
+  def class_def name, &blk
+    class_eval { define_method name, &blk }
+  end
+
+  # Defines an instance method within a class/module.
+  #
+  # CREDIT: WhyTheLuckyStiff
+
+  def module_def name, &blk
+    module_eval { define_method name, &blk }
+  end
+
+  #--
+  # TODO: Why are we making these protected,
+  # and where should these really go in Facets?
+  #++
+  protected :attr
+  protected :attr_reader
+  protected :attr_writer
+  protected :attr_accessor
+  protected :remove_method
+  protected :undef_method
+
+end
+

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

@@ -16,18 +16,20 @@ class String
   #   "Camel_case".camelcase(false)      #=> "camelCase"
   #
   # TODO: Is this the best approach? Should lowerCamelCase be default instead?
-  def camelcase(first_letter=nil)
-    case first_letter
-    when :upper, true
-      upper_camelcase
-    when :lower, false
-      lower_camelcase
-    else
-      str = dup
-      str.gsub!(/\/(.?)/){ "::#{$1.upcase}" }  # NOT SO SURE ABOUT THIS
-      str.gsub!(/(?:_+|-+)([a-z])/){ $1.upcase }
-      #str.gsub!(/(\A|\s)([a-z])/){ $1 + $2.upcase }
-      str
+  unless method_defined?(:camelcase)
+    def camelcase(first_letter=nil)
+      case first_letter
+      when :upper, true
+        upper_camelcase
+      when :lower, false
+        lower_camelcase
+      else
+        str = dup
+        str.gsub!(/\/(.?)/){ "::#{$1.upcase}" }  # NOT SO SURE ABOUT THIS
+        str.gsub!(/(?:_+|-+)([a-z])/){ $1.upcase }
+        #str.gsub!(/(\A|\s)([a-z])/){ $1 + $2.upcase }
+        str
+      end
     end
   end
 

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

@@ -0,0 +1,35 @@
+require "facets/enumerator"
+
+class String
+
+  # Returns an Enumerator for iterating over each
+  # line of the string, stripped of whitespace on
+  # either side.
+  #
+  def cleanlines(&block)
+    if block
+      scan(/^.*?$/) do |line|
+        block.call(line.strip)
+      end
+    else
+      Enumerator.new(self) do |output|
+        scan(/^.*?$/) do |line|
+          output.yield(line.strip)
+        end
+      end
+    end
+  end
+
+end
+
+=begin test
+
+  "a \n b \n c".newlines.class.must == Enumerator
+  "a \n b \n c".newlines.to_a.must == %w{a b c}
+
+  a = []
+  "a \n b \n c".newlines{|nl| a << nl}
+  a.must == %w{a b c}
+
+=end
+

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

@@ -0,0 +1,62 @@
+class String
+
+  # Levenshtein distance algorithm implementation for Ruby, with UTF-8 support.
+  #
+  # The Levenshtein distance is a measure of how similar two strings s and t are,
+  # calculated as the number of deletions/insertions/substitutions needed to
+  # transform s into t. The greater the distance, the more the strings differ.
+  #
+  # The Levenshtein distance is also sometimes referred to as the
+  # easier-to-pronounce-and-spell 'edit distance'.
+  #
+  # Calculate the Levenshtein distance between two strings +self+ and +str2+.
+  # +self+ and +str2+ should be ASCII, UTF-8, or a one-byte-per character encoding
+  # such as ISO-8859-*.
+  #
+  # The strings will be treated as UTF-8 if $KCODE is set appropriately (i.e. 'u').
+  # Otherwise, the comparison will be performed byte-by-byte. There is no specific support
+  # for Shift-JIS or EUC strings.
+  #
+  # When using Unicode text, be aware that this algorithm does not perform normalisation.
+  # If there is a possibility of different normalised forms being used, normalisation
+  # should be performed beforehand.
+  #
+  # CREDIT: Paul Battley
+  #
+  def edit_distance(str2)
+    str1 = self
+    if $KCODE =~ /^U/i
+      unpack_rule = 'U*'
+    else
+      unpack_rule = 'C*'
+    end
+    s = str1.unpack(unpack_rule)
+    t = str2.unpack(unpack_rule)
+    n = s.length
+    m = t.length
+    return m if (0 == n)
+    return n if (0 == m)
+
+    d = (0..m).to_a
+    x = nil
+
+    (0...n).each do |i|
+      e = i+1
+      (0...m).each do |j|
+        cost = (s[i] == t[j]) ? 0 : 1
+        x = [
+          d[j+1] + 1, # insertion
+          e + 1,      # deletion
+          d[j] + cost # substitution
+        ].min
+        d[j] = e
+        e = x
+      end
+      d[m] = x
+    end
+
+    return x
+  end
+
+end
+

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

@@ -3,13 +3,13 @@ class String
   # Indent left or right by n spaces.
   # (This used to be called #tab and aliased as #indent.)
   #
-  # CREDIT: Gavin Sinclair, Trans
+  # CREDIT: Gavin Sinclair, Trans, Tyler Rick
 
-  def indent(n)
+  def indent(n, c=' ')
     if n >= 0
-      gsub(/^/, ' ' * n)
+      gsub(/^/, c * n)
     else
-      gsub(/^ {0,#{-n}}/, "")
+      gsub(/^#{Regexp.escape(c)}{0,#{-n}}/, "")
     end
   end
 
@@ -23,3 +23,85 @@ class String
 
 end
 
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+
+class TC_String_Indent < Test::Unit::TestCase
+
+  def test_positive_indent
+    assert_equal '    xyz', "xyz".  indent(4)
+    assert_equal '    xyz', "  xyz".indent(2)
+  end
+
+  def test_multi_line_positive_indent
+    assert_equal  "  abc\n" +
+                  "  xyz"   ,
+                 ("abc\n"   +
+                  "xyz"     ).indent(2)
+  end
+
+  def test_0_indent
+    assert_equal 'xyz', 'xyz'.indent(0)
+  end
+
+  def test_negative_indent
+    assert_equal '  xyz', '    xyz'.indent(-2)
+    assert_equal 'xyz',   '  xyz'.  indent(-2)
+  end
+
+  def test_multi_line_negative_indent
+    assert_equal  "  abc\n" +
+                  "  xyz"   ,
+                 ("    abc\n"   +
+                  "    xyz"     ).indent(-2)
+  end
+
+  def test_outdent_is_alias_for_negative_indent
+    assert_equal 'xyz', '  xyz'.outdent(2)
+  end
+
+  def test_negative_indent_more_than_is_possible
+    assert_equal 'xyz', '  xyz'.indent(-3)
+  end
+
+  #-----------------------------------
+  # Using a character other than space
+
+  def test_nonspace_positive__indent
+    assert_equal '----xyz', "xyz".indent(4, '-')
+  end
+
+  def test_nonspace_0_indent
+    assert_equal 'xyz', 'xyz'.indent(0, '-')
+  end
+
+  def test_nonspace_negative_indent_nonmatching_character
+    assert_equal '    xyz', '    xyz'.indent(-2, '-')
+    assert_equal '  xyz',   '  xyz'.  indent(-2, '-')
+  end
+
+  def test_nonspace_negative_indent
+    assert_equal '--xyz', '----xyz'.indent(-2, '-')
+    assert_equal 'xyz',   '--xyz'.indent(-2, '-')
+  end
+
+  def test_special_regexp_characters_are_escaped
+    # make sure . is treated as a literal '.' and not an "any character" wildcard
+    assert_equal '  xyz', '  xyz'.indent(-2, '.')
+    assert_equal 'xyz',   '..xyz'.indent(-2, '.')
+
+    assert_equal '  xyz', '  xyz'.indent(-2, '^')
+    assert_equal 'xyz',   '^^xyz'.indent(-2, '^')
+
+    assert_equal '  xyz', '  xyz'.indent(-2, '*')
+    assert_equal 'xyz',   '**xyz'.indent(-2, '*')
+  end
+end
+=end