mack-facets 0.8.1 → 0.8.2

data/lib/gems/facets-2.4.5/lib/core/facets/callstack.rb

@@ -0,0 +1,52 @@
+module Kernel
+
+  alias_method :pp_callstack, :caller
+
+  # Parse a caller string and break it into its components,
+  # returning an array. Returns:
+  # * file (String)
+  # * lineno (Integer)
+  # * method (Symbol)
+  #
+  # For example, from irb,
+  #
+  #   call_stack(1)
+  #
+  # _produces_
+  #
+  # [["(irb)", 2, :irb_binding],
+  #  ["/usr/lib/ruby/1.8/irb/workspace.rb", 52, :irb_binding],
+  #  ["/usr/lib/ruby/1.8/irb/workspace.rb", 52, nil]]
+  #
+  # Note: If the user decides to redefine caller() to output data
+  # in a different format, _prior_ to requiring this, then the
+  # results will be indeterminate.
+  #
+  #   CREDIT: Trans
+
+  def callstack( level = 1 )
+    call_str_array = pp_callstack(level)
+    stack = []
+    call_str_array.each{ |call_str|
+      file, lineno, method = call_str.split(':')
+      if method =~ /in `(.*)'/ then
+        method = $1.intern()
+      end
+      stack << [file, lineno.to_i, method]
+    }
+    stack
+  end
+
+end
+
+
+class Binding
+
+  # Returns the call stack, in array format.
+
+  def callstack(level=1)
+    eval( "callstack( #{level} )" )
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/cattr.rb

@@ -0,0 +1,2 @@
+# TO BE DEPRECATED
+require 'facets/class/cattr'

data/lib/gems/facets-2.4.5/lib/core/facets/class.rb

@@ -0,0 +1,6 @@
+dir, base = *File.split(__FILE__)
+base = base.chomp('.rb')
+Dir[File.join(dir, base, '*')].each do |lib|
+  require "facets/#{base}/#{File.basename(lib)}"
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/class/cattr.rb

@@ -0,0 +1,115 @@
+class Class
+
+  # Creates a class-variable attribute that can
+  # be accessed both on an instance and class level.
+  #
+  # NOTE This used to be a Module method. But turns out
+  # it does not work as expected when included. The class-level
+  # method is not carried along. So it is now just a Class
+  # method. Accordingly, #mattr has been deprecated.
+  #
+  #  CREDIT: David Heinemeier Hansson
+  #  CREDIT: Ara T. Howard (for suggesting)
+
+  def cattr( *syms )
+    writers, readers = syms.flatten.partition{ |a| a.to_s =~ /=$/ }
+    writers = writers.collect{ |e| e.to_s.chomp('=').to_sym }
+    readers.concat( writers ) # writers also get readers
+    cattr_writer( *writers )
+    cattr_reader( *readers )
+    return readers + writers
+  end
+
+  # Creates a class-variable attr_reader that can
+  # be accessed both on an instance and class level.
+  #
+  #   class MyClass
+  #     @@a = 10
+  #     cattr_reader :a
+  #   end
+  #
+  #   MyClass.a           #=> 10
+  #   MyClass.new.a       #=> 10
+  #
+  #  CREDIT: David Heinemeier Hansson
+
+  def cattr_reader( *syms )
+    syms.flatten.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}
+          @@#{sym}
+        end
+
+        def #{sym}
+          @@#{sym}
+        end
+      EOS
+    end
+    return syms
+  end
+
+  # Creates a class-variable attr_writer that can
+  # be accessed both on an instance and class level.
+  #
+  #   class MyClass
+  #     cattr_writer :a
+  #     def a
+  #       @@a
+  #     end
+  #   end
+  #
+  #   MyClass.a = 10
+  #   MyClass.a            #=> 10
+  #   MyClass.new.a = 29
+  #   MyClass.a            #=> 29
+  #
+  #  CREDIT: David Heinemeier Hansson
+
+  def cattr_writer(*syms)
+    syms.flatten.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
+
+        def #{sym}=(obj)
+          @@#{sym}=(obj)
+        end
+      EOS
+    end
+    return syms
+  end
+
+  # Creates a class-variable attr_accessor that can
+  # be accessed both on an instance and class level.
+  #
+  #   class MyClass
+  #     cattr_accessor :a
+  #   end
+  #
+  #   MyClass.a = 10
+  #   MyClass.a           #=> 10
+  #   mc = MyClass.new
+  #   mc.a                #=> 10
+
+  def cattr_accessor(*syms)
+    cattr_reader(*syms) + cattr_writer(*syms)
+  end
+
+end
+
+#class Module
+  #alias_method :mattr,          :cattr            # deprecate
+  #alias_method :mattr_reader,   :cattr_reader     # deprecate
+  #alias_method :mattr_writer,   :cattr_writer     # deprecate
+  #alias_method :mattr_accessor, :cattr_accessor   # deprecate
+#end
+

data/lib/gems/facets-2.4.5/lib/core/facets/class/cattr_accessor.rb

@@ -0,0 +1 @@
+require 'facets/class/cattr'

data/lib/gems/facets-2.4.5/lib/core/facets/class/cattr_reader.rb

@@ -0,0 +1 @@
+require 'facets/class/cattr'

data/lib/gems/facets-2.4.5/lib/core/facets/class/cattr_writer.rb

@@ -0,0 +1 @@
+require 'facets/class/cattr'

data/lib/gems/facets-2.4.5/lib/core/facets/class/descendents.rb

@@ -0,0 +1,36 @@
+class Class
+
+  # List all descedents of this class.
+  #
+  #   class X ; end
+  #   class A < X; end
+  #   class B < X; end
+  #   X.descendents  #=> [A,B]
+  #
+  # NOTE: This is a intesive operation. Do not
+  # expect it to be super fast.
+
+  def descendents
+    subclass = []
+    ObjectSpace.each_object( Class ) do |c|
+      if c.ancestors.include?( self ) and self != c
+        subclass << c
+      end
+    end
+    return subclass
+  end
+
+  unless defined?(::ActiveSupport)
+
+    # Obvious alias for descendents.
+    #
+    # NOTE: ActiveSupport returns string names rather
+    # then actual classes, so this is excluded
+    # if ActiveSupport has already been loaded.
+    #
+    alias_method :subclasses, :descendents
+
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/class/methodize.rb

@@ -0,0 +1,14 @@
+require 'facets/string/methodize'
+
+class Class
+
+  # Translate a class name to a suitable method name.
+  #
+  #   My::CoolClass.methodize => "my__cool_class"
+  #
+  def methodize
+    name.methodize
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/class/pathize.rb

@@ -0,0 +1,14 @@
+require 'facets/string/pathize'
+
+class Class
+
+  # Converts a class name to a unix path.
+  #
+  #   My::CoolClass.pathize  #=> "my/cool_class"
+  #
+  def pathize
+    name.pathize
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/class/prepend.rb

@@ -0,0 +1,50 @@
+class Class
+
+  # Prepend an "aspect module" to a class.
+  #
+  #   class Firetruck
+  #     def put_out_fire(option)
+  #       "Put out #{option}"
+  #     end
+  #   end
+  #
+  #   module FastFiretruck
+  #     def put_out_fire(option)
+  #       super("very #{option}!")
+  #     end
+  #   end
+  #
+  #   Firetruck.prepend(FastFiretruck)
+  #
+  #   ft = Firetruck.new
+  #   ft.put_out_fire('fast') #=> "Put out very fast!"
+  #
+  # Implementation of this method has some limitations,
+  # in that it works by overriding #new and #allocate.
+  #
+  # CREDIT Trans
+  #
+  # TODO: Perhaps rename this to preallocate, b/c of
+  #       the way it works. It is not really a clean
+  #       prepend, like that of Module#prepend.
+
+  def prepend( aspect )
+    _new      = method(:new)
+    _allocate = method(:allocate)
+    (class << self; self; end).class_eval do
+      define_method(:new) do |*args|
+        o = _new.call(*args)
+        o.extend aspect
+        o
+      end
+      define_method(:allocate) do |*args|
+        o = _allocate.call(*args)
+        o.extend aspect
+        o
+      end
+    end
+  end
+
+  #alias_method :preallocate, :prepend
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/class/subclasses.rb

@@ -0,0 +1,2 @@
+require 'facets/class/descendents'
+

data/lib/gems/facets-2.4.5/lib/core/facets/class/to_proc.rb

@@ -0,0 +1,42 @@
+class Class
+
+  # Convert instatiation of a class into a Proc.
+  #
+  #   class Person
+  #     def initialize(name)
+  #       @name = name
+  #     end
+  #
+  #     def inspect
+  #       @name.to_str
+  #     end
+  #   end
+  #
+  #   %w(john bob jane hans).map(&Person) => [john, bob, jane, hans]
+  #
+  # CREDIT: Daniel Schierbeck
+
+  def to_proc
+    proc{|*args| new(*args)}
+  end
+
+end
+
+
+
+=begin test
+  reqiure 'test/unit'
+
+  class TestClassConversion < Test::Unit::TestCase
+
+    Person = Struct.new(:name)
+
+    def test_to_proc
+      people = ["joe"].map(&Person)
+      assert_equal("joe", people[0].name)
+    end
+
+  end
+
+=end
+

data/lib/gems/facets-2.4.5/lib/core/facets/comparable.rb

@@ -0,0 +1,6 @@
+dir, base = *File.split(__FILE__)
+base = base.chomp('.rb')
+Dir[File.join(dir, base, '*')].each do |lib|
+  require "facets/#{base}/#{File.basename(lib)}"
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/comparable/bound.rb

@@ -0,0 +1,65 @@
+class String
+  def to_s
+    self
+  end
+end
+
+module Comparable
+
+  # Returns the lower of self or x.
+  #
+  #   4.at_least(5)  #=> 5
+  #   6.at_least(5)  #=> 6
+  #
+  #   CREDIT Florian Gross
+
+  def at_least(x)
+    (self >= x) ? self : x
+  end
+
+  # Returns the greater of self or x.
+  #
+  #   4.at_most(5)  #=> 4
+  #   6.at_most(5)  #=> 5
+  #
+  #   CREDIT Florian Gross
+
+  def at_most(x)
+    (self <= x) ? self : x
+  end
+
+  # Returns the greater of self or x.
+  #
+  #   4.cap(5)  #=> 4
+  #   6.cap(5)  #=> 5
+  #
+  #   CREDIT Trans
+
+  def cap(upper)
+    (self <= upper) ? self : upper
+  end
+
+  # Returns self if above the given lower bound, or
+  # within the given lower and upper bounds,
+  # otherwise returns the the bound of which the
+  # value falls outside.
+  #
+  #   4.clip(3)    #=> 4
+  #   4.clip(5)    #=> 5
+  #   4.clip(2,7)  #=> 4
+  #   9.clip(2,7)  #=> 7
+  #   1.clip(2,7)  #=> 2
+  #
+  #   CREDIT Trans
+
+  def bound(lower, upper=nil)
+    return lower if self < lower
+    return self unless upper
+    return upper if self > upper
+    return self
+  end
+
+  alias_method :clip, :bound
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/comparable/cmp.rb

@@ -0,0 +1,38 @@
+module Comparable
+
+  # Alternate name for comparison operator #<=>.
+  #
+  #   3.cmp(1)   #=>  1
+  #   3.cmp(3)   #=>  0
+  #   3.cmp(10)  #=> -1
+  #
+  # This fundamental compare method is used to keep
+  # comparison compatible with <tt>#succ</tt>.
+  #
+  #   CREDIT Peter Vanbroekhoven
+
+  def cmp(o)
+    self<=>o
+  end
+end
+
+class String 
+
+  # Compare method that takes length into account.
+  # Unlike #<=>, this is compatible with #succ.
+  #
+  #   "abc".cmp("abc")   #=>  0
+  #   "abcd".cmp("abc")  #=>  1
+  #   "abc".cmp("abcd")  #=> -1
+  #   "xyz".cmp("abc")   #=>  1
+  #
+  #   CREDIT Peter Vanbroekhoven
+
+  def cmp(other)
+    return -1 if length < other.length
+    return 1 if length > other.length
+    self <=> other  # alphabetic compare
+  end
+
+end
+