facets 2.6.0 → 2.7.0

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

@@ -1,6 +1,6 @@
 class Integer
 
-  if RUBY_VERSION < '1.9'
+  unless method_defined?(:odd?)  # 1.8.7+
 
     # Returns true if this integer is odd, false otherwise.
     #
@@ -17,6 +17,10 @@ class Integer
       self & 1 == 1
     end
 
+  end
+
+  unless method_defined?(:even?)  # 1.8.7+
+
     # Returns true if this integer is even, false otherwise.
     #
     #   2.even?  #=> true

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

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

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

@@ -0,0 +1,14 @@
+module Kernel
+
+  # Outputs the file, line and current method.
+  #
+  #   caller(1).first
+  #   "/usr/lib/ruby/1.8/irb/workspace.rb:52:in `irb_binding'"
+  #
+  # CREDIT: William Mason
+  def __HERE__
+    caller(1).first
+  end
+
+end
+

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

@@ -1,6 +1,6 @@
-unless (RUBY_VERSION[0,3] == '1.9')
+module Kernel
 
-  module Kernel
+  unless method_defined?(:__method__)  # 1.8.7+
 
     # Retreive the current running method name.
     #
@@ -15,6 +15,12 @@ unless (RUBY_VERSION[0,3] == '1.9')
       /\`([^\']+)\'/.match(caller(1).first)[1].to_sym
     end
 
+    private :__method__
+
+  end
+
+  unless method_defined?(:__callee__)  # 1.9+  # TODO: Is this so?
+
     # Retreive the current running method name.
     #
     #   def tester; __callee__; end
@@ -28,7 +34,7 @@ unless (RUBY_VERSION[0,3] == '1.9')
       /\`([^\']+)\'/.match(caller(1).first)[1].to_sym
     end
 
-    private :__callee__, :__method__
+    private :__callee__
 
   end
 

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

@@ -19,6 +19,7 @@ module Kernel
   def ask(question, answers=nil)
     $stdout << "#{question}"
     $stdout << " [#{answers}] " if answers
+    $stdout.flush
     until inp = $stdin.gets ; sleep 1 ; end
     inp.strip
   end

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

@@ -0,0 +1,13 @@
+module Kernel
+
+  # Broad equality.
+  # 
+  # Checks to see if the object +x+ is in any
+  # way equal to the reciever, starting with the 
+  # identity #equals? and ending with #===.
+  #
+  def equate?(x)
+    equal?(x) || eql?(x) || self == x || self === x
+  end
+
+end

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

@@ -0,0 +1,9 @@
+module Kernel
+
+  # Don't say it!
+  def extension
+    class << self; self; end
+  end
+
+end
+

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

@@ -0,0 +1,4 @@
+module Kernel
+  alias_method :identical?, :equal?
+end
+

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

@@ -1,9 +1,10 @@
 class Object #module Kernel
 
-  unless defined? instance_exec # 1.9
+  unless method_defined?(:instance_exec) # 1.9
 
     module InstanceExecMethods #:nodoc:
     end
+
     include InstanceExecMethods
 
     # Evaluate the block with the given arguments within the context of

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

@@ -0,0 +1,49 @@
+$FIRST_CLASS_METHODS = Hash.new{ |h,k| h[k] = {} }
+
+module Kernel
+
+  # Easy access to method as object, and they retain state.
+  #
+  #   def hello
+  #     puts "Hello World!"
+  #   end
+  #
+  #   m1 = method!(:hello)   #=> <Method: #hello>
+  #
+  #   def m1.annotate
+  #     "simple example"
+  #   end
+  #
+  #   m2 = method!(:hello)
+  #   m2.annotate  #=> "simple example"
+
+  def method!(s)
+    #( @__methods__ ||= {} )[s.to_sym] ||= method(s)
+    $FIRST_CLASS_METHODS[self][s.to_sym] ||= method(s)
+  end
+
+end
+
+# Should 1st Class Methods be part of Ruby proper?
+#
+# Perhaps the best solution would be using the notation
+# <tt>::ameth</tt>. This would require some minor changes
+# to Ruby, but with few backward incompatabilites if
+# parantheticals revert back to the actual method invocation.
+# Although this later stipulation means capitalized methods
+# would not be accessible in this way b/c they would intefere with
+# constant lookup. It's a trade off.
+#
+#                   Current           Proposed           Alternate
+#                   ----------------- ------------------ -------------------
+#     Foo.Bar()     method call       method call        method call
+#     Foo.Bar       method call       method call        method call
+#     Foo.bar()     method call       method call        method call
+#     Foo.bar       method call       method call        method call
+#     Foo::Bar()    method call       method call        1st class method
+#     Foo::Bar      constant lookup   constant lookup    constant lookup
+#     Foo::bar()    method call       method call        1st class method
+#     Foo::bar      method call       1st class method   1st class method
+#
+# Then again this dosen't address bound versus unbound.
+

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

@@ -20,9 +20,9 @@ module Kernel
   def object_send(name,*args,&blk)
     #instance_eval "self.#{name}(*args)"
     if respond_to?(name)
-      send(name,*args,&blk)
+      __send__(name,*args,&blk)
     else #if respond_to?(:method_missing)
-      method_missing(name,*args,&blk)
+      __send__(:method_missing,name,*args,&blk)
     #else
     #  raise NoMethodError
     end

data/lib/core/facets/kernel/{state.rb → object_state.rb}

@@ -1,50 +1,61 @@
-module Kernel
-
-  def state(data=nil)
-    if state
+class Object
+  # Get state of object.
+  def object_state(data=nil)
+    if data
       instance_variables.each do |iv|
         name = iv.to_s.sub(/^[@]/, '').to_sym
-        instance_variable_set(iv, data[name])
+        instance_variable_set(iv, snap[name])
       end
     else
-      data = Hash.new
+      data = {}
       instance_variables.each do |iv|
         name = iv.to_s.sub(/^[@]/, '').to_sym
         data[name] = instance_variable_get(iv)
       end
-      data
+      snap
     end
   end
 
+  # Replace state of object.
+  def replace(data)
+    instance_variables.each do |iv|
+      name = iv.to_s.sub(/^[@]/, '').to_sym
+      instance_variable_set(iv, data[name])
+    end
+  end
 end
 
 class Array
-  def state(data=nil)
+  def object_state(data=nil)
     data ? replace(data) : dup
   end
 end
 
 class String
-  def state(data=nil)
+  def object_state(data=nil)
     data ? replace(data) : dup
   end
 end
 
 class Hash
-  def state(data=nil)
+  def object_state(data=nil)
     data ? replace(data) : dup
   end
 end
 
 class Struct
-  def state(data=nil)
+  def object_state(data=nil)
     if data
       data.each_pair {|k,v| send(k.to_s + "=", v)}
     else
-      data = Hash.new
+      data = {}
       each_pair{|k,v| data[k] = v}
       data
     end
   end
+
+  def replace(snap)
+    snap.each_pair {|k,v| send(k.to_s + "=", v)}
+  end
 end
 

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

@@ -5,12 +5,17 @@ module Kernel
   #
   #   require_all 'facets/time/*'
   #
+  # You can also you #require_all relative to the
+  # current script simply by using __DIR__.
+  #
+  #   require_all(__DIR__ + '/foo/*')
+  #
   def require_all(pat)
     $LOAD_PATH.each do |path|
       fs = Dir[File.join(path,pat)]
       unless fs.empty?
         fs.each { |f|
-          Kernel.require( f ) unless File.directory?( f )
+          Kernel.require(f) unless File.directory?(f)
         }
         break;
       end

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

@@ -1,9 +1,14 @@
+require 'facets/kernel/require_relative'
+
+=begin
 module Kernel
 
   # Require file from same dir as calling script.
   #
   #   require_local 'templib'
   #
+  # CREDIT: Paul Brannan
+  #
   def require_local(fname)
     #fdir = File.expand_path( File.dirname( caller[0] ) )
     fdir = File.dirname( caller[0] )
@@ -14,6 +19,8 @@ module Kernel
   #
   #   load_local 'templib'
   #
+  # CREDIT: Paul Brannan
+  #
   def load_local(fname, safe=nil)
     #fdir = File.expand_path( File.dirname( caller[0] ) )
     fdir = File.dirname( caller[0] )
@@ -21,4 +28,4 @@ module Kernel
   end
 
 end
-
+=end

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

@@ -0,0 +1,52 @@
+module Kernel
+
+  unless method_defined?(:require_relative) # 1.9
+
+    # Require file from same dir as calling script.
+    #
+    #   require_local 'templib'
+    #
+    # CREDIT: Paul Brannan, Pragmatic Programmers
+    #
+    def require_relative(relative_feature)
+      c = caller.first
+      fail "Can't parse #{c}" unless c.rindex(/:\d+(:in `.*')?$/)
+      file = $` # File.dirname(c)
+      if /\A\((.*)\)/ =~ file # eval, etc.
+        raise LoadError, "require_relative is called in #{$1}"
+      end
+      absolute = File.expand_path(relative_feature, File.dirname(file))
+      require absolute
+    end
+
+  end
+
+  # Backward compatability.
+  alias_method :require_local, :require_relative
+
+  unless method_defined?(:load_relative) # 1.9
+
+    # Load file from same dir as calling script.
+    #
+    #   load_local 'templib'
+    #
+    # CREDIT: Paul Brannan, Pragmatic Programmers
+    #
+    def load_relative(relative_feature, safe=nil)
+      c = caller.first
+      fail "Can't parse #{c}" unless c.rindex(/:\d+(:in `.*')?$/)
+      file = $` # File.dirname(c)
+      if /\A\((.*)\)/ =~ file # eval, etc.
+        raise LoadError, "require_relative is called in #{$1}"
+      end
+      absolute = File.expand_path(relative_feature, File.dirname(file))
+      load absolute, safe
+    end
+
+  end
+
+  # Backward compatability.
+  alias_method :load_local, :load_relative
+
+end
+

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

@@ -0,0 +1,13 @@
+module Kernel
+
+  unless method_defined?(:source_location) # 1.9
+
+    def source_location
+      file, line, meth = *caller(1).first.split(':')
+      return file, line
+    end
+
+  end
+
+end
+

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

@@ -1,9 +1,12 @@
-unless (RUBY_VERSION[0,3] == '1.9')
+module Kernel
 
-  module Kernel
+  unless method_defined?(:tap)  # 1.8.7+
 
     # The tap K-Combinator. This yields self -and- returns self.
-
+    #
+    # Note, Ruby 1.9+ does not appear to support the zero arity 
+    # instance_eval option.
+    #
     def tap(&b)
       if block_given?
         b.arity == 1 ? yield(self) : instance_eval(&b)
@@ -11,11 +14,11 @@ unless (RUBY_VERSION[0,3] == '1.9')
       self
     end
 
-    # This is just an off-the-cuff consideration for #tap using Functor:
+    # == Future definition?
     #
-    #   require 'facets/functor'
+    # This is a consideration for a future #tap using Functor:
     #
-    #   # Yield self -and- return self.
+    #   require 'facets/functor'
     #
     #   def tap(&b)
     #     if block_given?
@@ -25,6 +28,10 @@ unless (RUBY_VERSION[0,3] == '1.9')
     #       Functor.new{ |op, *args| self.send(op, *args); self }
     #     end
     #   end
+    #
+    # It would allow a single call, before returning the original.
+    # However there are not very many useful things you can do with
+    # that.
 
   end
 

data/lib/core/facets/module/attr_setter.rb

@@ -0,0 +1,57 @@
+class Module
+
+  # Create an attribute method for both getting
+  # and setting an instance variable.
+  #
+  #   attr_setter :a
+  #
+  # _is equivalent to_
+  #
+  #   def a(*args)
+  #     if args.size > 0
+  #       @a = args[0]
+  #       self
+  #     else
+  #       @a
+  #     end
+  #   end
+  #
+  # CREDIT: Trans
+
+  def attr_setter(*args)
+    code, made = '', []
+    args.each do |a|
+      code << %{
+        def #{a}(*args)
+          args.size > 0 ? ( @#{a}=args[0] ; self ) : @#{a}
+        end
+      }
+      made << "#{a}".to_sym
+    end
+    module_eval code
+    made
+  end
+
+  # Alias an accessor. This create an alias for
+  # both a reader and a writer.
+  #
+  #   class X
+  #     attr_accessor :a
+  #     alias_accessor :b, :a
+  #   end
+  #
+  #   x = X.new
+  #   x.b = 1
+  #   x.a        #=> 1
+  #
+  # CREDIT: Trans
+
+  def alias_setter(*args)
+    args = args - [orig]
+    args.each do |name|
+      alias_method(name, orig)
+    end
+  end
+
+end
+