mack-facets 0.8.1 → 0.8.2

data/lib/gems/facets-2.4.5/lib/core/facets/integer/ordinal.rb

@@ -0,0 +1,24 @@
+class Integer
+
+  def ordinal
+    if [11,12,13].include?(self % 100)
+      "#{self}th"
+    else
+      case (self % 10)
+      when 1
+        "#{self}st"
+      when 2
+        "#{self}nd"
+      when 3
+        "#{self}rd"
+      else
+        "#{self}th"
+      end
+    end
+  end
+
+  # Rails term.
+  alias_method :ordinalize, :ordinal
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/kernel.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/kernel/__callee__.rb

@@ -0,0 +1 @@
+require 'facets/kernel/__method__'

data/lib/gems/facets-2.4.5/lib/core/facets/kernel/__class__.rb

@@ -0,0 +1,9 @@
+module Kernel
+
+  # Defines core method __class__ as an alias of class.
+  # This allows you to use #class as your own method, without
+  # loosing the ability to determine the object's class.
+
+  alias_method :__class__, :class
+
+end

data/lib/gems/facets-2.4.5/lib/core/facets/kernel/__dir__.rb

@@ -0,0 +1,12 @@
+module Kernel
+
+  # Similar to __FILE__ and __LINE__, __DIR__ provides
+  # the directory path to the current executing script.
+  #
+  # CREDIT: Trans
+
+  def __DIR__
+    (/^(.+)?:\d+/ =~ caller[0]) ? File.dirname($1) : nil
+  end
+
+end

data/lib/gems/facets-2.4.5/lib/core/facets/kernel/__get__.rb

@@ -0,0 +1,10 @@
+module Kernel
+
+  # Shadow method for instance_variable_get.
+  alias_method :__get__, :instance_variable_get
+
+  # Shadow method for instance_variable_set.
+  alias_method :__set__, :instance_variable_set
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/kernel/__method__.rb

@@ -0,0 +1,36 @@
+unless (RUBY_VERSION[0,3] == '1.9')
+
+  module Kernel
+
+    # Retreive the current running method name.
+    #
+    #   def tester; __method__; end
+    #   tester  #=> :tester
+    #
+    # Technically __callee__ should provided alias names,
+    # where __method__ should not. But we'll have to
+    # leave that distinction to Ruby 1.9+.
+
+    def __method__
+      /\`([^\']+)\'/.match(caller(1).first)[1].to_sym
+    end
+
+    # Retreive the current running method name.
+    #
+    #   def tester; __callee__; end
+    #   tester  #=> :tester
+    #
+    # Technically __callee__ should provided alias names,
+    # where as __method__ should not. But we'll have to
+    # leave that distinction to Ruby 1.9+.
+
+    def __callee__
+      /\`([^\']+)\'/.match(caller(1).first)[1].to_sym
+    end
+
+    private :__callee__, :__method__
+
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/kernel/__set__.rb

@@ -0,0 +1 @@
+require 'facets/kernel/__get__'

data/lib/gems/facets-2.4.5/lib/core/facets/kernel/as.rb

@@ -0,0 +1,100 @@
+require 'facets/functor'
+
+module Kernel
+
+  # Returns a As-functor that allows one to call any
+  # ancestor's method directly of the given object.
+  #
+  #   class A
+  #     def x ; 1 ; end
+  #   end
+  #
+  #   class B < A
+  #     def x ; 2 ; end
+  #   end
+  #
+  #   class C < B
+  #     def x ; as(A).x ; end
+  #   end
+  #
+  #   C.new.x  #=> 1
+
+  def as(ancestor, &blk)
+    @__as ||= {}
+    unless r = @__as[ancestor]
+      r = (@__as[ancestor] = As.new(self, ancestor))
+    end
+    r.instance_eval(&blk) if block_given?
+    #yield(r) if block_given?
+    r
+  end
+
+  # Call parent class/module methods once bound to self.
+  #
+  # TODO: Does this have the proper scope for #send?
+
+  def send_as(ancestor, sym, *args, &blk)
+    ancestor.instance_method(sym).bind(self).call(*args,&blk)
+  end
+
+  #--
+  #   def send_as(klass, meth, *args, &blk)
+  #     selfclass = Kernel.instance_method(:class).bind(self).call
+  #     raise ArgumentError if ! selfclass.ancestors.include?(klass)
+  #     klass.instance_method(meth).bind(self).call(*args, &blk)
+  #   end
+  #++
+
+  # Returns method of a parent class bound to self.
+
+  def super_method(klass, meth)
+    unless self.class.ancestors.include?(klass)
+      raise ArgumentError, "Not an ancestor for super_method-- #{klass}"
+    end
+    klass.instance_method(meth).bind(self)
+  end
+
+  # Like super but skips to a specific ancestor module or class.
+  #
+  #   class A
+  #     def x ; 1 ; end
+  #   end
+  #
+  #   class B < A
+  #     def x ; 2 ; end
+  #   end
+  #
+  #   class C < B
+  #     def x ; super_as(A) ; end
+  #   end
+  #
+  #   C.new.x  #=> 1
+
+  def super_as(klass=self.class.superclass, *args, &blk)
+    unless self.class.ancestors.include?(klass)
+      raise ArgumentError
+    end
+    called = /\`([^\']+)\'/.match(caller(1).first)[1].to_sym
+    klass.instance_method(called).bind(self).call(*args,&blk)
+  end
+
+end
+
+# Support class for Kernel#as.
+#
+# TODO: Deprecate this and use Functor (HigherOrderMessage) instead.
+
+class As #:nodoc:
+  # Privatize all methods except #binding an operators.
+  private(*instance_methods.select { |m| m !~ /(^__|^\W|^binding$)/ })
+
+  def initialize(subject, ancestor)
+    @subject = subject
+    @ancestor = ancestor
+  end
+
+  def method_missing(sym, *args, &blk)
+    @ancestor.instance_method(sym).bind(@subject).call(*args,&blk)
+  end
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/kernel/ask.rb

@@ -0,0 +1,27 @@
+module Kernel
+
+  module_function
+
+  # Very simple convenience method to get a console reply.
+  #
+  #   ask "Are you happy?", "Yn"
+  #
+  # On the command line one would see.
+  #
+  #   $ Are you happy? [Yn]
+  #
+  # Responding:
+  #
+  #   $ Are you happy? [Yn] Y <ENTER>
+  #
+  # The ask method would return "Y".
+
+  def ask(question, answers=nil)
+    $stdout << "#{question}"
+    $stdout << " [#{answers}] " if answers
+    until inp = $stdin.gets ; sleep 1 ; end
+    inp.strip
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/kernel/attr_singleton.rb

@@ -0,0 +1,62 @@
+module Kernel
+
+  # Takes an array or a hash with default values and creates
+  # singleton attr_readers for each.
+  #
+  #   attr_singleton_reader {:x => 1, :y => 2}
+  #   @x       #=> 1
+  #   @y       #=> 2
+  #   self.x   #=> 1
+  #   self.y   #=> 2
+  #
+  #  CREDIT: Trans
+
+  def attr_singleton_reader(*args)
+    #h, a = *args.partition{|a| Hash===a}
+    (class << self ; self ; end).send( :attr_reader, *args )  
+    #(class << self ; self ; end).send( :attr_reader, *h.keys )
+    #h.each { |k,v| instance_variable_set("@#{k}", v) }
+  end
+
+  # Takes an array or a hash with default values and creates 
+  # singleton attr_writers for each.
+  #
+  #   attr_singleton_writer { :x => 1, :y => 2 }
+  #   @x           #=> 1
+  #   @y           #=> 2
+  #   self.x = 3
+  #   self.y = 4
+  #   @x           #=> 3
+  #   @y           #=> 4
+  #
+  #  CREDIT: Trans
+
+  def attr_singleton_writer(*args)
+    #h, a = *args.partition{|a| Hash===a}
+    (class << self ; self ; end).send( :attr_writer, *args )
+    #(class << self ; self ; end).send( :attr_writer, *h.keys )
+    #h.each { |k,v| instance_variable_set("@#{k}", v) }
+  end
+
+  # Takes an array or hash with default values and creates
+  # singleton attr_accessors for each.
+  #
+  #   attr_singleton_accessor { :x => 1, :y => 2 }
+  #   @x          #=> 1
+  #   @y          #=> 2
+  #   self.x = 3
+  #   self.y = 4
+  #   self.x      #=> 3
+  #   self.y      #=> 4
+  #
+  #  CREDIT: Trans
+
+  def attr_singleton_accessor(*args)
+    #h, a = *args.partition{|a| Hash===a}
+    (class << self ; self ; end).send( :attr_accessor, *args )
+    #(class << self ; self ; end).send( :attr_accessor, *h.keys )
+    #h.each { |k,v| instance_variable_set("@#{k}", v) }
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/kernel/complete.rb

@@ -0,0 +1,18 @@
+module Kernel
+
+  # Repeat loop until it yeilds false or nil.
+  #
+  #   a = [3, 2, 1]
+  #   complete do
+  #     b << a.pop
+  #   end
+  #   b  #=> [3, 2, 1, nil]
+  #
+  #  CREDIT: Trans
+
+  def complete
+    loop { break unless yield }
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/kernel/constant.rb

@@ -0,0 +1,24 @@
+module Kernel
+
+  # This is similar to +Module#const_get+ but is accessible at all levels,
+  # and, unlike +const_get+, can handle module hierarchy.
+  #
+  #   constant("Fixnum")                  # -> Fixnum
+  #   constant(:Fixnum)                   # -> Fixnum
+  #
+  #   constant("Process::Sys")            # -> Process::Sys
+  #   constant("Regexp::MULTILINE")       # -> 4
+  #
+  #   require 'test/unit'
+  #   Test.constant("Unit::Assertions")   # -> Test::Unit::Assertions
+  #   Test.constant("::Test::Unit")       # -> Test::Unit
+  #
+  #   CREDIT: Trans
+
+  def constant(const)
+    const = const.to_s.dup
+    base = const.sub!(/^::/, '') ? Object : ( self.kind_of?(Module) ? self : self.class )
+    const.split(/::/).inject(base){ |mod, name| mod.const_get(name) }
+  end
+
+end

data/lib/gems/facets-2.4.5/lib/core/facets/kernel/d.rb

@@ -0,0 +1,26 @@
+module Kernel
+
+  def __HERE__
+    "#{__FILE__}: #{__LINE__}"
+  end
+
+  # Like #p but gives file and line number.
+  #
+  #   d("hi")
+  #
+  # produces
+  #
+  #   /home/dave/projects/foo.rb, 38
+  #   "hi"
+  #
+  # TODO: This is borderline "prime". Keep here?
+  #       Another copy of it exits in dtools.rb
+
+  def d(*x)
+    puts "#{__FILE__}, #{__LINE__}"
+    x.each{ |e| puts e.inspect } #p(*x)
+    x.size > 1 ? x : x.last #x.last
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/kernel/deep_copy.rb

@@ -0,0 +1,13 @@
+module Kernel
+
+  # Anything that can be marshaled can be copied in totality.
+  # This is also commonly called a deep_copy.
+  #
+  #   "ABC".copy  #=> "ABC"
+  #
+  def deep_copy
+    Marshal::load(Marshal::dump(self))
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/kernel/demo.rb

@@ -0,0 +1,23 @@
+module Kernel
+
+  # For debugging and showing examples. Currently this
+  # takes an argument of a string in a block.
+  #
+  #   demo {%{ a = [1,2,3] }}
+  #   demo {%{ a.slice(1,2) }}
+  #   demo {%{ a.map { |x| x**3 } }}
+  #
+  # Produces:
+  #
+  #   a = [1,2,3]             #=>  [1, 2, 3]
+  #   a.slice(1,2)            #=>  [2, 3]
+  #   a.map { |x| x**3 }      #=>  [1, 8, 27]
+  #
+  #   TODO: Is there a way to do this without the eval string in block?
+  #         Preferably just a block and no string.
+
+  def demo(out=$stdout,&block)
+    out << sprintf("%-25s#=>  %s\n", expr = block.call, eval(expr, block.binding).inspect)
+  end
+
+end

data/lib/gems/facets-2.4.5/lib/core/facets/kernel/ergo.rb

@@ -0,0 +1,42 @@
+require 'facets/functor'
+
+module Kernel
+
+  # Yield self -or- return self.
+  #
+  #   "a".ergo.upcase #=> "A"
+  #   nil.ergo.foobar #=> nil
+  #
+  #   "a".ergo{ |o| o.upcase } #=> "A"
+  #   nil.ergo{ |o| o.foobar } #=> nil
+  #
+  # This is like #tap, but tap yields self -and- returns self.
+  #
+  #  CREDIT: Daniel DeLorme
+
+  def ergo &b
+    if block_given?
+      b.arity == 1 ? yield(self) : instance_eval(&b)
+    else
+      self
+    end
+  end
+
+end
+
+class NilClass
+
+  # Compliments Kernel#ergo.
+  #
+  #   "a".ergo{ |o| o.upcase } #=> "A"
+  #   nil.ergo{ |o| o.bar } #=> nil
+  #
+  #   CREDIT: Daniel DeLorme
+
+  def ergo
+    @_ergo ||= Functor.new{ nil }
+    @_ergo unless block_given?
+  end
+
+end
+