facets 2.8.4 → 2.9.0.pre.1

data/lib/core/facets/{kernel/instance.rb → instance.rb}

@@ -21,9 +21,10 @@ end
 #   end
 #
 #   f1 = Friend.new("John", 30, "555-1212")
-#   p f1.instance
+#   f1.instance
+#
 #   f1.instance.update({:name=>'Jerry'})
-#   p f1.instance
+#   f1.instance
 #
 class Instance
 

data/lib/core/facets/integer/bit.rb

@@ -0,0 +1 @@
+require 'facets/integer/bitmask'

data/lib/core/facets/{bitmask.rb → integer/bitmask.rb}

@@ -2,12 +2,15 @@ class Integer
 
   # Set a bit.
   #
-  #   0.bit!(4)  #=> 8
+  #   0.bit(4)  #=> 16
   #
-  # Using an inverted bit will clear a bit.
+  # Using a negative figure will clear a bit.
   #
-  #   10.bit!(~3)      #=> 2
-  #   0xb0100.bit(~3)  #=> 0
+  #   10.bit(-4)      #=> 2
+  #
+  # This is more easily seen using binary.
+  #
+  #   0b0100.bit(-3)  #=> 0
   #
   # CREDIT: Thomas Sawyer, George Moschovitis
 
@@ -21,14 +24,11 @@ class Integer
     end
   end
 
-  # Old name. Probably will be deprecated.
-  alias_method :bit!, :bit
-
   # Clear bit.
   #
   # CREDIT: George Moschovitis
 
-  def clear_bit(bit)
+  def bit_clear(bit)
     mask = (1 << bit)
     self & ~mask
   end
@@ -64,9 +64,6 @@ class Integer
     end
   end
 
-  # Old name. Probably will be deprecated.
-  alias_method :bitmask!, :bitmask
-
   # Is bitmask set?
   #
   #   7.bitmask?(7) #=> true
@@ -99,3 +96,4 @@ module Kernel
   end
 
 end
+

data/lib/core/facets/integer/factorial.rb

@@ -4,7 +4,7 @@ class Integer
   #
   #   2.factorial  #=> 2
   #   3.factorial  #=> 6
-  #   3.factorial  #=> 24
+  #   4.factorial  #=> 24
   #
   # CREDIT: Malte Milatz
 
@@ -17,14 +17,5 @@ class Integer
 
   alias_method( :fac, :factorial )
 
-  #-- OLD CODE
-  #def factorial
-  #  return 1 if self == 0
-  #  #self == 0 ? 1 : ( self * (self-1).factorial )
-  #  f = (1..self.abs).inject { |state, item| state * item }
-  #  return self < 0 ? -f : f
-  #end
-  #++
-
 end
 

data/lib/core/facets/integer/odd.rb

@@ -13,8 +13,7 @@ class Integer
     # CREDIT: Daniel Schierbeck
 
     def odd?
-      #self % 2 == 1
-      self & 1 == 1
+      self & 1 == 1  #self % 2 == 1
     end
 
   end
@@ -29,8 +28,7 @@ class Integer
     # CREDIT: Daniel Schierbeck
 
     def even?
-      #self % 2 == 0
-      self & 1 == 0
+      self & 1 == 0  #self % 2 == 0
     end
 
   end

data/lib/core/facets/integer/of.rb

@@ -3,7 +3,7 @@ class Integer
   # Like #times but returns a collection of the yield results.
   #
   #   a = 3.of { |i| "#{i+1}" }
-  #   a => [ "1", "2", "3" ]
+  #   a #=> [ "1", "2", "3" ]
   #
 
   def of(&block)

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

@@ -5,18 +5,22 @@ module Kernel
   #
   # CREDIT: Trans
 
-  def __DIR__
+  def __DIR__(*paths)
     c = caller.first
     return nil unless c.rindex(/:\d+(:in `.*')?$/)
     file = $` # File.dirname(c)
     return nil if /\A\((.*)\)/ =~ file # eval, etc.
-    #File.expand_path(File.dirname(file))
-    File.dirname(file)
+    #File.expand_path(File.join(File.dirname(file), paths))
+    File.join(File.dirname(file), paths)
   end
 
-  #def __DIR__
-  #  (/^(.+)?:\d+/ =~ caller[0]) ? File.dirname($1) : nil
-  #end
+  #--
+  # Old defintion ...
+  #
+  #  def __DIR__
+  #    (/^(.+)?:\d+/ =~ caller[0]) ? File.dirname($1) : nil
+  #  end
+  #++
 
 end
 

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

@@ -1,10 +1,15 @@
 module Kernel
 
   # Shadow method for instance_variable_get.
-  alias_method :__get__, :instance_variable_get
+  def __get__(ivar)
+    #ivar = "@#{ivar}" unless ivar.to_s[0,1] == '@'
+    instance_variable_get(ivar)
+  end
 
   # Shadow method for instance_variable_set.
-  alias_method :__set__, :instance_variable_set
+  def __set__(ivar, val)
+    #ivar = "@#{ivar}" unless ivar.to_s[0,1] == '@'
+    instance_variable_set(ivar, val)
+  end
 
 end
-

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

@@ -1,11 +1,14 @@
 module Kernel
 
-  unless method_defined?(:__method__)  # 1.8.7+
+  unless defined?(__method__) == "method"  # 1.8.7+
 
     # Retreive the current running method name.
     #
-    #   def tester; __method__; end
-    #   tester  #=> :tester
+    #   def method_example
+    #     __method__
+    #   end
+    #
+    #   method_example  #=> :method_example
     #
     # Technically __callee__ should provided alias names,
     # where __method__ should not. But we'll have to
@@ -19,12 +22,15 @@ module Kernel
 
   end
 
-  unless method_defined?(:__callee__)  # 1.9+
+  unless defined?(__callee__) == "method"  # 1.9+
 
     # Retreive the current running method name.
     #
-    #   def tester; __callee__; end
-    #   tester  #=> :tester
+    #   def callee_example
+    #     __callee__
+    #   end
+    #
+    #   callee_example  #=> :callee_example
     #
     # Technically __callee__ should provided alias names,
     # where as __method__ should not. But we'll have to

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

@@ -5,39 +5,42 @@ module Kernel
   # Returns a As-functor that allows one to call any
   # ancestor's method directly of the given object.
   #
-  #   class A
+  #   class AsExample1
   #     def x ; 1 ; end
   #   end
   #
-  #   class B < A
+  #   class AsExample2 < AsExample1
   #     def x ; 2 ; end
   #   end
   #
-  #   class C < B
-  #     def x ; as(A).x ; end
+  #   class AsExample3 < AsExample2
+  #     def x ; as(AsExample1).x ; end
   #   end
   #
-  #   C.new.x  #=> 1
+  #   AsExample1.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?
+    ##this = self
+    r = As.new(self, ancestor)
+    ##unless r
+    ##  r = As.cache[self][ancestor] = Functor.new do |op, *a, &b|
+    ##    ancestor.instance_method(op).bind(this).call(*a,&b)
+    ##  end
+    ##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
 
   #--
+  # Old version ...
+  #
   #   def send_as(klass, meth, *args, &blk)
   #     selfclass = Kernel.instance_method(:class).bind(self).call
   #     raise ArgumentError if ! selfclass.ancestors.include?(klass)
@@ -45,46 +48,57 @@ module Kernel
   #   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
-
+  ## DEPRECATED: There's no reliable way to get method name of caller.
+  ## This needs to have the same knowledge that #super itself has and
+  ## I do not thin that is possbile in pure Ruby.
+  ##
+  ## Like super but skips to a specific ancestor module or class.
+  ##
+  ##   class SuperAsExample1
+  ##     def x ; 1 ; end
+  ##   end
+  ##
+  ##   class SuperAsExample2 < SuperAsExample1
+  ##     def x ; 2 ; end
+  ##   end
+  ##
+  ##   class SuperAsExample3 < SuperAsExample2
+  ##     def x ; super_as(SuperAsExample1) ; end
+  ##   end
+  ##
+  ##   SuperAsExample3.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
+  ##  called = File.basename(caller(1).first)
+  ##  klass.instance_method(called).bind(self).call(*args,&blk)
+  ##end
 end
 
 # Support class for Kernel#as.
 #
-# TODO: Deprecate this and use Functor (HigherOrderMessage) instead.
+# TODO: Deprecate this and use Functor (HigherOrderMessage) instead ?
 
 class As #:nodoc:
+ 
+  class << self
+    alias_method :_new, :new
+
+    def new(subject, ancestor)
+      cache[subject][ancestor] ||= _new(subject, ancestor)
+    end
+    
+    def cache
+      @cache ||= Hash.new{|h,k| h[k]={} }
+    end
+
+    private :_new
+    private :cache
+  end
+
   # Privatize all methods except #binding an operators.
   private(*instance_methods.select { |m| m !~ /(^__|^\W|^binding$)/ })
 
@@ -93,6 +107,7 @@ class As #:nodoc:
     @ancestor = ancestor
   end
 
+  private
   def method_missing(sym, *args, &blk)
     @ancestor.instance_method(sym).bind(@subject).call(*args,&blk)
   end

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

@@ -2,26 +2,26 @@ module Kernel
 
   module_function
 
-  # Very simple convenience method to get a console reply.
+  # Very simple convenience method to get user input
+  # via the console. A prompt will be sent to $stdout,
+  # if given, and the input taken from $stdin...
   #
-  #   ask "Are you happy?", "Yn"
+  #   ask "Are you happy? [Yn]"
   #
-  # On the command line one would see.
+  # On the command line one would see...
   #
-  #   $ Are you happy? [Yn]
+  #   Are you happy? [Yn]
   #
-  # Responding:
+  # Responding...
   #
-  #   $ Are you happy? [Yn] Y <ENTER>
+  #   Are you happy? [Yn] Y <ENTER>
   #
   # The ask method would return "Y".
 
-  def ask(question, answers=nil)
-    $stdout << "#{question}"
-    $stdout << " [#{answers}] " if answers
+  def ask(prompt=nil)
+    $stdout << "#{prompt}"
     $stdout.flush
-    until inp = $stdin.gets ; sleep 1 ; end
-    inp.strip
+    $stdin.gets.chomp!
   end
 
 end

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

@@ -1,44 +1,36 @@
 module Kernel
 
-  # Assign via writer using a arguments, hash or
-  # associative array, and son on, or assign via 
-  # a block.
+  # Assign via writer using arguments, hash or associative array.
   #
   # Using name-value arguments:
   #
+  #   object = Object.new
+  #
   #   object.assign(:a, 1)
   #   object.assign(:b, 2)
   #
   # Using a hash:
   #
-  #   object.assign( :a => 1, :b => 2 )
+  #   object.assign(:a => 1, :b => 2)
   #
   # Use an associative array:
   #
-  #   object.assign( [[:a, 1], [:b, 2]] )
-  #
-  # Using a block:
-  #
-  #   object.assign do |s|
-  #     s.a = 1
-  #     s.b = 2
-  #   end
+  #   object.assign([[:a, 1], [:b, 2]])
   #
   # These are all equivalent to:
   #
-  #   object.a = 1
-  #   object.b = 2
+  #   object.a = 1 if object.respond_to?(:a=)
+  #   object.b = 2 if object.respond_to?(:b=)
   #
-  # Unless assigned via a block, undefined setters will not
-  # raise an error if they do not exist. They will simply be
-  # skipped.
+  # Using an associative array instead of hash guarantees order of assignemnt
+  # for older versions of Ruby (< 1.8.7).
   #
-  # Using an associative array instead of hash guarentees
-  # order of assignemnt for older versions of Ruby (< 1.8.7).
+  # NOTE: This method used to allow a block which would yield on +self+.
+  # This feature has been deprecated. There are plenty of other ways to
+  # handle this, such as #tap.
   #
-  # TODO: Should this be called #set instead? Consider
-  # Module#set in this question, and also #set_from as
-  # the alias of #assign_from.
+  # TODO: Should this be called #set instead? Consider Module#set in this
+  # question, and also #set_from as the alias of #assign_from.
 
   def assign(data=nil, value=Exception) #:yield:
     if data
@@ -50,14 +42,35 @@ module Kernel
         __send__("#{data}=", value) if respond_to?("#{data}=")
       end
     end
-    yield(self) if block_given?
     self
   end
 
-  # DEPRECATE: Use #assign instead.
-  def populate(*a,&b)
-    warn 'use #assign instead of #populate for future versions'
-    assign(*a,&b)
+  # Set attribute writers using like readers from another object.
+  #
+  #   class AssignExample
+  #     attr_accessor :a, :b
+  #     def initialize(a, b)
+  #        @a, @b = a, b
+  #     end
+  #   end
+  #
+  #   obj1 = AssignExample.new(1,2)
+  #   obj2 = AssignExample.new(3,4)
+  #
+  #   obj2.assign_from(obj1, :a, :b)
+  #
+  #   obj2.a  #=> 1
+  #   obj2.b  #=> 2
+  #
+  # TODO: Should this be called #set_from ?
+
+  def assign_from(obj, *fields)
+    fields.flatten.each do |k|
+      send("#{k}=", obj.__send__("#{k}"))  #if self.respond_to?("#{k}=") && obj.respond_to?("#{k}")
+    end
   end
+
+  ## DEPRECATED: Original name for #assign_from.
+  ##alias_method :set_from, :assign_from
 end