facets 1.8.8 → 1.8.20

data/lib/facets/core/nilclass/op_cmp.rb

@@ -5,7 +5,8 @@ class NilClass
   # except for nil itself which returns 0.
 
   def <=>( other )
-    other.nil? 0 : -1
+    other.nil? ? 0 : -1
   end
 
 end
+

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

@@ -0,0 +1,30 @@
+# CREDIT Richard Laugesen
+
+class String
+  
+  # Capitalize all words (or other patterned divisions) of a string.
+  #
+  #   "this is a test".capitalize_all  #=> "This Is A Test"
+
+  def capitalize_all( pattern=$;, *limit )
+    split(pattern, *limit).select{ |w| w.capitalize! || w }.join(" ")
+  end
+
+end
+
+
+=begin test
+
+  require 'test/unit'
+
+  class TestCapitalizeAll < Test::Unit::TestCase
+    def test_01
+      r = "try this out".capitalize_all
+      x = "Try This Out"
+      assert_equal(x,r)
+    end
+  end
+
+=end
+
+

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

@@ -1,3 +1,4 @@
+# CREDIT Phil Tomson
 
 class String
 
@@ -6,10 +7,7 @@ class String
   #   "THIS".capitalized?  #=> true
   #   "This".capitalized?  #=> true
   #   "this".capitalized?  #=> false
-  #
-  #--
-  # Credit goes to Phil Tomson.
-  #++
+
   def capitalized?
     self =~ /^[A-Z]/
   end

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

@@ -0,0 +1,66 @@
+
+class String
+
+  def cleave(threshold=nil, len=nil)
+    l = (len || size / 2) 
+    t = threshold || size
+
+    h1 = self[0...l]
+    h2 = self[l..-1]
+
+    i1 = h1.rindex(/\s/) || 0
+    d1 = (i1 - l).abs
+
+    d2 = h2.index(/\s/) || l
+    i2 = d2 + l
+
+    d1 = (i1-l).abs
+    d2 = (i2-l).abs
+
+    if [d1, d2].min > t
+      i = t
+    elsif d1 < d2
+      i = i1
+    else
+      i = i2
+    end
+
+    #dup.insert(l, "\n").gsub(/^\s+|\s+$/, '')
+    return self[0..i].to_s.strip, self[i+1..-1].to_s.strip
+  end 
+
+end
+
+
+
+=begin test
+
+   require 'test/unit'
+   
+  class StringCleaveTest < Test::Unit::TestCase
+     def test_nospaces
+       assert_equal [ 'whole', '' ], 'whole'.cleave
+       assert_equal [ 'Supercalifragilisticexpialidocious', '' ],
+                    'Supercalifragilisticexpialidocious'.cleave
+     end
+     def test_exact_middle
+       assert_equal [ 'fancy', 'split' ], 'fancy split'.cleave
+       assert_equal [ 'All good Rubyists', 'know how to party' ],
+                    'All good Rubyists know how to party'.cleave
+     end
+     def test_closer_to_start
+       assert_equal [ 'short', 'splitter' ], 'short splitter'.cleave
+       assert_equal [ 'Four score and', 'seven years ago...' ],
+                    'Four score and seven years ago...'.cleave
+       assert_equal [ 'abc def', 'ghijklm nop' ],
+                    'abc def ghijklm nop'.cleave
+     end
+     def test_closer_to_end
+       assert_equal [ 'extended', 'split' ], 'extended split'.cleave
+       assert_equal [ 'abc defghi', 'jklm nop' ],
+                    'abc defghi jklm nop'.cleave
+     end
+   end
+
+=end
+

data/lib/facets/core/symbol/self/generate.rb

@@ -5,13 +5,14 @@ class Symbol
   #
   #   Symbol.generate => :<1>
   #
-  # If +for+ is given the new symbol will be suffixed with it.
+  # If +suffix+ is given the new symbol will be suffixed with it.
   #
   #   Symbol.generate(:this) => :<2>this
   #
-  def self.generate(for=nil)
-    @generate_count ||= 0
-    ("<%X>#{for}" % @generate_count += 1).to_sym
+
+  def self.generate(suffix=nil)
+    @symbol_generate_counter ||= 0
+    ("<%X>#{suffix}" % @symbol_generate_counter += 1).to_sym
   end
 
 end

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

@@ -1,9 +1,11 @@
+# CHANGE transami@gmail.com - removed #freeze from #id2name
+
 class Symbol
 
   # Same functionality as before, just a touch more efficient.
 
   def to_s
-    @to_s || (@to_s = id2name.freeze)
+    @to_s || (@to_s = id2name)
   end
 
 end

data/lib/facets/more/aspects.rb

@@ -19,7 +19,7 @@
 # Copyright:: Copyright (c) 2005 George Moschovitis
 # License::   Ruby License
 
-require 'facet/inheritor'
+require 'facets/more/inheritor'
 
 # = Aspect
 #
@@ -76,15 +76,11 @@ module Aspects
     include_advice_modules(target)
 
     for m in [methods].flatten
-      args = []
-      target.instance_method(m).arity.times { |i| args << "a#{i}" }
-      args = args.join(',')
-
       target.module_eval <<-end_eval, __FILE__, __LINE__ 
         alias_method :__unwrapped_#{m}, :#{m}
-        def #{m}(#{args})  
+        def #{m}(*args,&block)  
           #{gen_advice_code(m, target.advices, :pre)}
-          __unwrapped_#{m}(#{args})
+          __unwrapped_#{m}(*args,&block)
           #{gen_advice_code(m, target.advices, :post)}
         end
       end_eval
@@ -162,7 +158,7 @@ module Aspects
             code << "#{advice}.#{m}(self); "
           end
         else
-          # Module, allready handled.
+          # Module, already handled.
         end
       else
         if m = o[join] and advice.methods.include?(m.to_s)

data/lib/facets/more/expirable.rb

@@ -1,6 +1,6 @@
 # = expirable.rb
 #
-# == Copyright (c) 2004 Navel
+# == Copyright (c) 2004 George Moschovitis
 #
 #   Ruby License
 #
@@ -16,7 +16,7 @@
 # * George Moschovitis
 
 # Author::    George Moschovitis
-# Copyright:: Copyright (c) 2004 Navel
+# Copyright:: Copyright (c) 2004 George Moschovitis
 # License::   Ruby License
 
 # = Expirable

data/lib/facets/more/lrucache.rb

@@ -1,173 +1,173 @@
-# = lrucache.rb
-#
-# == Copyright (c) 2004 Navel
-#
-#   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.
-#
-# == Author(s)
-#
-# * George Moschovitis
-
-# Author::    George Moschovitis, Anastasios Koutoumanos
-# Copyright:: Copyright (c) 2005 Navel
-# License::   Ruby License
-
-# = LRUCache
-#
-# A cache utilizing a simple LRU (Least Recently Used) policy.
-# The items managed by this cache must respond to the #key method.
-# Attempts to optimize reads rather than inserts!
-#
-# LRU semantics are enforced by inserting the items in a queue.
-# The lru item is always at the tail. Two special sentinels
-# (head, tail) are used to simplify (?) the code.
-
-class LRUCache < Hash
-
-  # Mix this in your class to make LRU-managable.
-
-  module Item
-    attr_accessor :lru_key, :lru_prev, :lru_next
-  end
-
-  # head-tail sentinels
-
-  class Sentinel; include Item; end
-
-  # the maximum number of items in the cache.
-
-  attr_accessor :max_items
-
-  # the head sentinel and the tail sentinel, tail.prev points to the lru item.
-
-  attr_reader :head, :tail
-
-  def initialize(max_items)
-    @max_items = max_items
-    lru_clear()
-  end
-
-  # Lookup an item in the cache.
-
-  def [](key)
-    if item = super
-      return lru_touch(item)
-    end
-  end
-
-  # The inserted item is considered mru!
-
-  def []=(key, item)
-    item = super
-    item.lru_key = key
-    lru_insert(item)
-  end
-
-  # Delete an item from the cache.
-
-  def delete(key)
-    if item = super
-      lru_delete(item)
-    end
-  end
-
-  # Clear the cache.
-
-  def clear
-    super
-    lru_clear()
-  end
-
-  # The first (mru) element in the cache.
-
-  def first
-    @head.lru_next
-  end
-
-  # The last (lru) element in the cache.
-
-  def last
-    @tail.lru_prev
-  end
-  alias_method :lru, :last
-
-  private
-
-  # Delete an item from the lru list.
-
-  def lru_delete(item)
-    lru_join(item.lru_prev, item.lru_next)
-    return item
-  end
-
-  # Join two items in the lru list.
-  # Return y to allow for chaining.
-
-  def lru_join(x, y)
-    x.lru_next = y
-    y.lru_prev = x
-    return y
-  end
-
-  # Append a child item to a parent item in the lru list
-  # (Re)inserts the child in the list.
-
-  def lru_append(parent, child)
-    lru_join(child, parent.lru_next)
-    lru_join(parent, child)
-  end
-
-  # Insert an item
-
-  def lru_insert(item)
-    delete(last.lru_key) if size() > @max_items
-    lru_append(@head, item)
-  end
-
-  # Touch an item, make mru!
-  # Returns the item.
-
-  def lru_touch(item)
-    lru_append(@head, lru_delete(item))
-  end
-
-  # Clear the lru.
-
-  def lru_clear
-    @head = Sentinel.new
-    @tail = Sentinel.new
-    lru_join(@head, @tail)
-  end
-
-end
-
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-
-# TODO
-
-=begin testing
-
-  require 'test/unit'
-
-  class TC_LRUCache < Test::Unit::TestCase
-
-    def test_01
-    end
-
-  end
-
-=end
+# = lrucache.rb
+#
+# = Copyright 2004 George Moschovitis
+#
+#   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.
+#
+# == Author(s)
+#
+# * George Moschovitis
+
+# Author::    George Moschovitis, Anastasios Koutoumanos
+# Copyright:: Copyright (c) 2005 George Moschovitis
+# License::   Ruby License
+
+# = LRUCache
+#
+# A cache utilizing a simple LRU (Least Recently Used) policy.
+# The items managed by this cache must respond to the #key method.
+# Attempts to optimize reads rather than inserts!
+#
+# LRU semantics are enforced by inserting the items in a queue.
+# The lru item is always at the tail. Two special sentinels
+# (head, tail) are used to simplify (?) the code.
+
+class LRUCache < Hash
+
+  # Mix this in your class to make LRU-managable.
+
+  module Item
+    attr_accessor :lru_key, :lru_prev, :lru_next
+  end
+
+  # head-tail sentinels
+
+  class Sentinel; include Item; end
+
+  # the maximum number of items in the cache.
+
+  attr_accessor :max_items
+
+  # the head sentinel and the tail sentinel, tail.prev points to the lru item.
+
+  attr_reader :head, :tail
+
+  def initialize(max_items)
+    @max_items = max_items
+    lru_clear()
+  end
+
+  # Lookup an item in the cache.
+
+  def [](key)
+    if item = super
+      return lru_touch(item)
+    end
+  end
+
+  # The inserted item is considered mru!
+
+  def []=(key, item)
+    item = super
+    item.lru_key = key
+    lru_insert(item)
+  end
+
+  # Delete an item from the cache.
+
+  def delete(key)
+    if item = super
+      lru_delete(item)
+    end
+  end
+
+  # Clear the cache.
+
+  def clear
+    super
+    lru_clear()
+  end
+
+  # The first (mru) element in the cache.
+
+  def first
+    @head.lru_next
+  end
+
+  # The last (lru) element in the cache.
+
+  def last
+    @tail.lru_prev
+  end
+  alias_method :lru, :last
+
+  private
+
+  # Delete an item from the lru list.
+
+  def lru_delete(item)
+    lru_join(item.lru_prev, item.lru_next)
+    return item
+  end
+
+  # Join two items in the lru list.
+  # Return y to allow for chaining.
+
+  def lru_join(x, y)
+    x.lru_next = y
+    y.lru_prev = x
+    return y
+  end
+
+  # Append a child item to a parent item in the lru list
+  # (Re)inserts the child in the list.
+
+  def lru_append(parent, child)
+    lru_join(child, parent.lru_next)
+    lru_join(parent, child)
+  end
+
+  # Insert an item
+
+  def lru_insert(item)
+    delete(last.lru_key) if size() > @max_items
+    lru_append(@head, item)
+  end
+
+  # Touch an item, make mru!
+  # Returns the item.
+
+  def lru_touch(item)
+    lru_append(@head, lru_delete(item))
+  end
+
+  # Clear the lru.
+
+  def lru_clear
+    @head = Sentinel.new
+    @tail = Sentinel.new
+    lru_join(@head, @tail)
+  end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+# TODO
+
+=begin testing
+
+  require 'test/unit'
+
+  class TC_LRUCache < Test::Unit::TestCase
+
+    def test_01
+    end
+
+  end
+
+=end