facets 1.7.46 → 1.8.0

data/lib/facets/core/proc/to_h.rb

@@ -0,0 +1,27 @@
+require 'facets/more/functor'
+require 'facets/core/symbol/chomp'
+
+class Proc
+
+  # Build a hash out of a Proc.
+  #
+  #   l = lambda { |s|
+  #     s.a = 1
+  #     s.b = 2
+  #     s.c = 3
+  #   }
+  #   l.to_h  #=> {:a=>1, :b=>2, :c=>3}
+  #
+
+  def to_h
+    h = {}
+    f = Functor.new{ |op, arg| h[op.chomp('=')] = arg }
+    call( f )
+    h
+  end
+
+end
+
+
+
+# TODO Write test for Proc#to_h.

data/lib/facets/core/proc/to_method.rb

@@ -1,36 +1,22 @@
-#--
-# Credit goes to Forian Gross (flgr) and Mauricio Fernandez.
-#--
+# CREDIT Forian Gross
+# CREDIT Mauricio Fernandez
+# CREDIT Thomas Sawyer
 
-require 'thread'
-
-class Object
-  module  TemporaryMethods; end
-  include TemporaryMethods
-end
+require 'facets/core/proc/bind'
 
 class Proc
 
-  # Creates a local method based on a Proc.
-  def to_method(name=nil, recv=nil)
-    recv ||= eval("self", self)
-    klass = name ? recv.class : TemporaryMethods
-    begin
-      old, Thread.critical = Thread.critical, true
-      unless name
-        n = 0
-        n += 1 while klass.method_defined?(name = "__to_method_#{n}")
-        #n += 1 while recv.respond_to?(name = "__to_method_#{n}")
-      end
-      klass.send(:define_method, name, &self)
-      recv.method(name) #if klass == TemporaryMethods
-    ensure
-      if klass == TemporaryMethods
-        klass.send(:remove_method, name) #rescue nil
-        #klass.send(:undef_method, name) #rescue nil
-      end
-      Thread.critical = old
+  def to_method(name=nil, object=nil)
+    return bind unless name
+
+    object = object || eval("self", self)
+    klass  = object.class
+    block  = self
+
+    klass.class_eval do
+      define_method name, &block
     end
+    object.method(name)
   end
 
 end
@@ -66,7 +52,7 @@ end
         tmethod = tproc.to_method
         assert_equal( 3, tmethod.call(1) )
       }
-      meths = Symbol.all_symbols.select { |s| s.to_s =~ /^__to_method/ }
+      meths = Symbol.all_symbols.select { |s| s.to_s =~ /^_bind_/ }
       assert_equal( 1, meths.size )
     end
 

data/lib/facets/core/proc/update.rb

@@ -0,0 +1,11 @@
+#--
+# CREDIT Tim Pease
+#++
+
+class Proc
+
+  # Use a Proc as an observable.
+
+  alias :update :call
+
+end

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

@@ -1,7 +1,7 @@
 
 class String
 
-  # Scramble the inner characters of words leaving the text still readable 
+  # 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:

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

@@ -0,0 +1,34 @@
+
+class String
+
+  # Apply a set of rules (regular expression matches) to the
+  # string.
+  #
+  # === Requirements:
+  # The rules must be applied in order! So we cannot use a
+  # hash because the ordering is not guaranteed! we use an
+  # array instead.
+  #
+  # === Input:
+  # The array containing rule-pairs (match, write).
+  #
+  # === Output:
+  # The rewritten string.
+
+  def rewrite(string, rules)
+    return nil unless string
+
+    # gmosx: helps to find bugs
+    raise ArgumentError.new('The rules parameter is nil') unless rules
+
+    rewritten_string = string.dup
+
+    rules.each do |match,write|
+      rewritten_string.gsub!(match,write)
+    end
+
+    return (rewritten_string or string)
+  end
+
+end
+

data/lib/facets/core/symbol/chomp.rb

@@ -0,0 +1,9 @@
+class Symbol
+
+  # Just like String#chomp.
+
+  def chomp(seperator=nil)
+    to_s.chomp(seperator).to_sym
+  end
+
+end

data/lib/facets/core/time/stamp.rb

@@ -1,21 +1,28 @@
+#--
+# CHANGE 2006-12-10 <transfire@gmail.com>
+# * Added FORMAT constant to make more flexible. 
+#++
 
 class Time
 
+  FORMAT = {
+    :db      => "%Y-%m-%d %H:%M:%S",
+    :dbase   => "%Y-%m-%d %H:%M:%S",
+    :datbase => "%Y-%m-%d %H:%M:%S",
+    :utc     => "%Y-%m-%d %H:%M:%S",
+    :short   => "%d %b %H:%M",
+    :long    => "%B %d, %Y %H:%M",
+    :day1st  => "%d-%m-%Y %H:%M",
+    :dmYHM   => "%d-%m-%Y %H:%M",
+    :rfc822  => "%a, %d %b %Y %H:%M:%S %z",
+    nil      => "%a %b %d %H:%M:%S %Z %Y"
+  }
+
   def stamp( fmt = nil )
-    case fmt
-    when :db, :dbase, :database, :utc
-      strftime("%Y-%m-%d %H:%M:%S")
-    when :short
-      strftime("%e %b %H:%M")
-    when :long
-      strftime("%B %e, %Y %H:%M")
-    when :day1st, :dmYHM  # TODO generalize
-      strftime("%d-%m-%Y %H:%M")
-    when String
-      strftime( fmt ).strip
-    else
-      strftime("%a %b %d %H:%M:%S %Z %Y")
+    unless String === fmt
+      fmt = FORMAT[fmt]
     end
+    strftime(fmt).strip
   end
 
   def self.stamp(*args)
@@ -39,13 +46,22 @@ end
   class TCTime < Test::Unit::TestCase
 
     def setup
-      @t = Time.parse('4/20/2005 15:37')
+      @t = Time.parse('4/02/2005 15:37')
+    end
+
+    def test_001
+      assert_equal( "Sat Apr 02 15:37:00 EST 2005", @t.stamp )
     end
 
-    def test_stamp
-      assert_equal( "Wed Apr 20 15:37:00 EDT 2005", @t.stamp )
+    def test_002
+      assert_equal( "April 02, 2005 15:37", @t.stamp(:long) )
+    end
+
+    def test_003
+      assert_equal( "02 Apr 15:37", @t.stamp(:short) )
     end
 
   end
 
 =end
+

data/lib/facets/more/ann.rb

@@ -0,0 +1,249 @@
+# = annotation.rb
+#
+# == Copyright (c) 2005 Thomas Sawyer
+#
+#   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.
+#
+# == History
+#
+# LOG 2006-11-07 trans  Created this ultra-concise version of annotations.
+#
+# == Notes
+#
+# TODO Might be nice to have a default object of annotation, eg. the next
+# method defined, like how +desc+ annotates a rake +task+.
+#
+# TODO The ann(x).name notation is kind of nice. Would like to add that
+# back-in if reasonable. Basically this require heritage to be an OpenHash
+# rather than just a hash.
+#
+# == Authors & Contributors
+#
+# * Thomas Sawyer
+
+# Author::    Thomas Sawyer
+# Copyright:: Copyright (c) 2005 Thomas Sawyer
+# License::   Ruby License
+
+require 'facets/core/hash/to_h'
+require 'facets/core/hash/symbolize_keys'
+require 'facets/core/hash/op_add'
+
+# = Annotation
+#
+# Annotations allows you to annontate objects, including methods with arbitrary
+# "metadata". These annotations don't do anything in themselves. They are
+# merely comments. But you can put them to use. For instance an attribute
+# validator might check for an annotation called :valid and test against it.
+#
+# Annotation is an OpenObject, and is used across the board for keeping annotations.
+#
+# Annotation class serves for both simple and inherited cases depending on whether
+# a base class is given.
+#
+# == Synopsis
+#
+#   class X
+#     attr :a
+#     ann :@a, :valid => lambda{ |x| x.is_a?(Integer) }
+#
+#     def validate
+#       instance_variables.each { |iv|
+#         if validator = self.class.ann(iv)[:valid]
+#           value = instance_variable_get(iv)
+#           unless validator.call(vale)
+#             raise "Invalid value #{value} for #{iv}"
+#           end
+#         end
+#       }
+#     end
+#
+#   end
+
+#--
+# By using a global veriable rather the definining a class instance variable
+# for each class/module, it is possible to quicky scan all annotations for the
+# entire system. To do the same without this would require scanning through
+# the ObjectSpace. (Still which is better?)
+#
+#$annotations = Hash.new { |h,k| h[k] = {} }
+#++
+
+class Module
+
+  def annotations
+    #$annotations[self]
+    @annotations ||= {}
+  end
+
+  def heritage(ref)
+    ref = ref.to_sym
+    ancestors.inject({}) { |memo, ancestor|
+      ancestor.annotations[ref] ||= {}
+      ancestor.annotations[ref] + memo
+    }
+  end
+
+  # Set or read annotations.
+
+  def ann( ref, keys_or_class=nil, keys=nil )
+    return heritage(ref) unless keys_or_class or keys
+
+    if Class === keys_or_class
+      keys ||= {}
+      keys[:class] = keys_or_class
+    else
+      keys = keys_or_class
+    end
+
+    if Hash === keys
+      ref = ref.to_sym
+      annotations[ref] ||= {}
+      annotations[ref].update(keys.symbolize_keys)
+    else
+      key = keys.to_sym
+      heritage(ref)[key]
+    end
+  end
+
+  # To change an annotation's value in place for a given class or module
+  # it first must be duplicated, otherwise the change may effect annotations
+  # in the class or module's ancestors.
+
+  def ann!( ref, keys_or_class=nil, keys=nil )
+    return heritage(ref) unless keys_or_class or keys
+
+    if Class === keys_or_class
+      keys ||= {}
+      keys[:class] = keys_or_class
+    else
+      keys = keys_or_class
+    end
+
+    if Hash === keys
+      ref = ref.to_sym
+      annotations[ref] ||= {}
+      annotations[ref].update(keys.symbolize_keys)
+    else
+      key = keys.to_sym
+      annotations[ref][key] = heritage(ref)[key].dup
+    end
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+=begin test
+
+  require 'test/unit'
+
+  class TestAnnotation1 < Test::Unit::TestCase
+    class X
+      def x1 ; end
+      ann :x1, :a=>1
+      ann :x1, :b=>2
+    end
+
+    def test_1_01
+      assert_equal( X.ann(:x1,:a), X.ann(:x1,:a) )
+      assert_equal( X.ann(:x1,:a).object_id, X.ann(:x1,:a).object_id )
+    end
+    def test_1_02
+      X.ann :x1, :a => 2
+      assert_equal( 2, X.ann(:x1,:a) )
+    end
+  end
+
+  class TestAnnotation2 < Test::Unit::TestCase
+    class X
+      def x1 ; end
+      ann :x1, :a=>1
+      ann :x1, :b=>2
+    end
+    class Y < X ; end
+
+    def test_2_01
+      assert_equal( Y.ann(:x1,:a), Y.ann(:x1,:a) )
+      assert_equal( Y.ann(:x1,:a).object_id, Y.ann(:x1,:a).object_id )
+    end
+    def test_2_02
+      assert_equal( 1, Y.ann(:x1,:a) )
+      assert_equal( 2, Y.ann(:x1,:b) )
+    end
+    def test_2_03
+      Y.ann :x1,:a => 2
+      assert_equal( 2, Y.ann(:x1,:a) )
+      assert_equal( 2, Y.ann(:x1,:b) )
+    end
+  end
+
+  class TestAnnotation3 < Test::Unit::TestCase
+    class X
+      ann :foo, Integer
+    end
+    class Y < X
+      ann :foo, String
+    end
+
+    def test_3_01
+      assert_equal( Integer, X.ann(:foo, :class) )
+    end
+    def test_3_02
+      assert_equal( String, Y.ann(:foo, :class) )
+    end
+  end
+
+  class TestAnnotation4 < Test::Unit::TestCase
+    class X
+      ann :foo, :doc => "hello"
+      ann :foo, :bar => []
+    end
+    class Y < X
+      ann :foo, :class => String, :doc => "bye"
+    end
+
+    def test_4_01
+      assert_equal( "hello", X.ann(:foo,:doc) )
+    end
+    def test_4_02
+      assert_equal( X.ann(:foo), { :doc => "hello", :bar => [] } )
+    end
+    def test_4_03
+      X.ann(:foo,:bar) << "1"
+      assert_equal( ["1"], X.ann(:foo,:bar) )
+    end
+    def test_4_04
+      assert_equal( "bye", Y.ann(:foo,:doc) )
+    end
+    def test_4_05
+      #assert_equal( nil, Y.ann(:foo,:bar) )
+      assert_equal( ["1"], Y.ann(:foo,:bar) )
+    end
+    def test_4_06
+      Y.ann(:foo, :doc => "cap")
+      assert_equal( "cap", Y.ann(:foo, :doc)  )
+    end
+    def test_4_07
+      Y.ann!(:foo,:bar) << "2"
+      assert_equal( ["1", "2"], Y.ann(:foo,:bar) )
+      assert_equal( ["1", "2"], Y.ann(:foo,:bar) )
+      assert_equal( ["1"], X.ann(:foo,:bar) )
+    end
+  end
+
+=end
+