facets 1.0.2 → 1.0.3

data/packages/core/lib/facet/kernel/adhoc.rb

@@ -0,0 +1,11 @@
+
+#
+# It is what it is.
+#
+#                       -- transonoma
+
+module Kernel
+  def adhoc
+    (class << self; self; end)
+  end
+end

data/packages/core/lib/facet/kernel/as.rb

@@ -0,0 +1,91 @@
+
+begin
+  require 'calibre/functor.rb'
+rescue LoadError
+  require 'facet/functor.rb'
+end
+
+module Kernel
+
+  # Returns a Functor that allows one to call any parent method directly.
+  #
+  #   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( klass=nil, &blk )
+    selfclass = Kernel.instance_method(:class).bind(self).call
+    klass ||= selfclass.superclass
+    if selfclass.ancestors.include?(klass)
+      Functor.new do |meth, *args|  # &blk|
+        klass.instance_method(meth).bind(self).call(*args) # ,&blk)
+      end
+    else
+      raise ArgumentError, "#{klass} is not an ancestor"
+    end
+  end
+
+=begin
+  def as( role, &blk )
+    unless role.is_a?(Class)
+      role = self.class.const_get( role )
+    end
+    @roles ||= {}
+    @roles[role] ||= role.allocate
+    robj = @roles[role]
+    robj.assign_from( self )
+    result = robj.instance_eval( &blk )
+    self.assign_from( robj )  # w/o this much like namespaces
+    result
+  end
+=end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCKernel < Test::Unit::TestCase
+    class A
+      def x; "A.x"; end
+      def y; "A.y"; end
+    end
+    class B < A
+      def x; "B.x" end
+      def y; "B.y" end
+    end
+    class C < B
+      def x; "C.x"; end
+      def y; as.x ; end
+    end
+
+    def setup
+      @c = C.new
+    end
+
+    def test_as
+      assert_equal("B.x", @c.y)
+      assert_equal("C.x", @c.x)
+    end
+  end
+
+=end

data/packages/core/lib/facet/kernel/assign_from.rb

@@ -0,0 +1,82 @@
+require 'facet/kernel/assign_with'
+
+class Object
+
+  # Set instance vars using another object.
+  #
+  #   class O
+  #     attr_accessor :d
+  #     def initialize( a, b, c, d)
+  #       @a = a
+  #       @b = b
+  #       @c = c
+  #       @d = d
+  #     end
+  #   end
+  #   o1 = O.new(1,2,3,4)
+  #   o2 = O.new(0,0,0,0)
+  #
+  #   o2.assign_from( o1, '@a', '@b', '@c', '@d' )
+  #   o2.instance_eval{ @a }  #=> 1
+  #   o2.instance_eval{ @b }  #=> 2
+  #   o2.instance_eval{ @c }  #=> 3
+  #   o2.instance_eval{ @d }  #=> 4
+  #
+  # See also #assign_with.
+  #
+  def assign_from(obj, *fields)
+    force = false
+    case fields.last
+    when true, false, nil
+      force = fields.pop
+    end
+
+    unless fields.empty?
+      fields.each do |k|
+        var = k.to_s
+        var = var.slice(0,1) == '@' ? var : "@#{var}"
+        if obj.instance_variables.include?(var)
+          self.instance_variable_set( var, obj.instance_variable_get(var) )
+        end
+      end
+    else
+      if force
+        fields = obj.instance_variables
+      else
+        fields = instance_variables | obj.instance_variables
+      end
+      fields.each do |var|
+        instance_variable_set( var, obj.instance_variable_get(var) )
+      end
+    end
+    return
+  end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCKernel < Test::Unit::TestCase
+
+    def test_assign_from
+      o = Object.new
+      o.instance_eval{ @z=0; @a=1; @b=2 } #; @@a=3 }
+      assign_from( o, "z", "@a", "@b" ) #, "@@a" )
+      assert_equal( 1, @a )
+      assert_equal( 2, @b )
+      #assert_equal( 3, @@a )
+    end
+
+  end
+
+=end

data/packages/core/lib/facet/kernel/assign_with.rb

@@ -0,0 +1,75 @@
+require 'facet/kernel/instance_assign'
+require 'facet/kernel/assign_from'
+
+class Object
+
+  # Set setter methods and/or vars using a hash (or assoc array).
+  # #assign_with is a meta-programming method, which allows you to
+  # use a hash to do any kind of variable assignment and/or setting:
+  #
+  # For example, assuming that there is an accessor defined as <tt>d</tt>:
+  #
+  #   assign_with( '@a'=>1, '@@b'=>2, '$c'=>3, 'd'=>4 )
+  #   @a   #=> 1
+  #   @@b  #=> 2
+  #   $c   #=> 3
+  #   d    #=> 4
+  #
+  # Note that while the global variable is strictly unnecessary,
+  # it works for completeness sake.
+  #
+  # NOTE This proabably should be called instance_assign_with given
+  # it's nature. We'll consider that in the future.
+  #
+  def assign_with(*args)
+    harg = args.last.is_a?(Hash) ? args.pop : {}
+
+    unless args.empty?
+      # if not assoc array, eg. [ [], [], ... ]
+      # preserves order of opertation
+      unless args[0].is_a?(Array)
+        i = 0; a = []
+        while i < args.size
+          a << [ args[i], args[i+1] ]
+          i += 2
+        end
+        args = a
+      end
+    end
+
+    args.each do |k,v|
+      instance_assign( k, v )
+    end
+
+    harg.each do |k,v|
+      instance_assign( k, v )
+    end
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCKernel < Test::Unit::TestCase
+
+    def test_assign_with
+      ahash = { "z"=>0, "@a"=>1, "@b"=>2 } #, "@@a"=>3 }
+      assign_with( ahash )
+      assert_equal( 0, @z )
+      assert_equal( 1, @a )
+      assert_equal( 2, @b )
+      #assert_equal( 3, @@a )
+    end
+
+  end
+
+=end

data/packages/core/lib/facet/kernel/autoreload.rb

@@ -0,0 +1,124 @@
+
+module Kernel
+
+  # Autoreload feature files.
+  #
+  # Automatically reload, at regular intervals, any previously loaded features,
+  # and/or other files not already loaded, if they have been modified since the last
+  # interval check. A numeric parameter sets the reload interval in seconds
+  # and the file parameter can either be a glob string or an array
+  # of file paths. If a glob string, it is expanded only once on the initial
+  # method call. Supplying a boolean parameter of 'false' will force autreload to
+  # skip previously loaded features and only reload the specified files.
+  # Also keeps a "dirty" flag.
+
+  def autoreload( *args )
+
+    check_interval=10
+    include_features = true
+    files = nil
+
+    args.each { |arg|
+      case arg
+      when Numeric
+        check_interval = arg
+      when String
+        files = Dir.glob( arg )
+      when Array
+        files = arg
+      when TrueClass, FalseClass
+        include_features = arg
+      end
+    end
+
+    file_mtime = {}
+
+    Thread.new(Time.now) do |start_time|
+      loop do
+        sleep check_interval
+
+        if include_features
+          feature_files = $LOADED_FEATURES.collect { |feature|
+            $LOAD_PATH.each { |lp| file = File.join(lp, feature) }
+          }.flatten
+
+          feature_files.each { |file|
+            if File.exists?(file) and (mtime = File.stat(file).mtime) > (file_mtime[file] || start_time)
+              $autoreload_dirty = true
+              file_mtime[file] = mtime
+              STDERR.puts "File '#{ file }' reloaded"
+              begin
+                load(file)
+              rescue Exception => e
+                STDERR.puts e.inspect
+              end
+            end
+          }
+        end
+
+        if files
+          files.each do |file|
+            if File.exists?(file) and (mtime = File.stat(file).mtime) > (file_mtime[file] || start_time)
+              $autoreload_dirty = true
+              file_mtime[file] = mtime
+              STDERR.puts "File '#{ file }' changed"
+            end
+          end
+        end
+
+      end
+    end
+
+  end
+
+
+  # Same as #autoreload, but does not include previously loaded features.
+  # This is equivalent to as adding a 'false' parameter to #autoreload.
+
+  def autoreload_files( *args )
+    autoreload( *args, false )
+  end
+
+  # deprecate
+  alias_method :autoreload_glob, :autoreload_files
+
+end
+
+# Michael Neumann
+# Tom Sawyer
+# George Moschovitis <gm@navel.gr>
+
+#--
+#   # OLD VERSION
+#   def autoreload(check_interval=10)
+#     Thread.new(Time.now) { |start_time|
+#       file_mtime = {}
+#       loop {
+#         sleep check_interval
+#         $LOADED_FEATURES.each { |feature|
+#           $LOAD_PATH.each { |lp|
+#             file = File.join(lp, feature)
+#             if (File.exists?(file) and
+#               File.stat(file).mtime > (file_mtime[file] || start_time))
+#               file_mtime[file] = File.stat(file).mtime
+#               STDERR.puts "reload #{ file }"
+#               begin
+#                 load(file)
+#               rescue Exception => e
+#                 STDERR.puts e.inspect
+#               end
+#             end
+#           }
+#         }
+#       }
+#     }
+#   end
+#++
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+# TODO

data/packages/core/lib/facet/kernel/autoreload_files.rb

@@ -0,0 +1,2 @@
+# stub
+require 'facet/kernel/autoreload.rb'

data/packages/core/lib/facet/kernel/autoreload_glob.rb

@@ -0,0 +1,3 @@
+# stub
+warn "autoreload_glob will be deprecated. Use autoreload_files instead."
+require 'facet/kernel/autoreload.rb'

data/packages/core/lib/facet/kernel/bool.rb

@@ -0,0 +1,77 @@
+#--
+# As suggested by Ara T. Howard
+#++
+
+class Object
+
+  # Returns true is an object is class TrueClass,
+  # otherwise false.
+  #
+  #   true.true?   #=> true
+  #   false.true?  #=> false
+  #   nil.true?    #=> false
+  #
+  def true?
+    (true == self)
+  end
+
+  # Returns true is an object is class FalseClass,
+  # otherwise false.
+  #
+  #   true.false?   #=> false
+  #   false.false?  #=> true
+  #   nil.false?    #=> false
+  #
+  def false?
+    (false == self)
+  end
+
+  # Returns true is an object is class TrueClass
+  # or FalseClass, otherwise false.
+  #
+  #   true.bool?   #=> true
+  #   false.bool?  #=> true
+  #   nil.bool?    #=> false
+  #
+  def bool?
+    (true == self or false == self)
+  end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCKernel < Test::Unit::TestCase
+
+    def test_false?
+      assert( false.false? )
+      assert( (1 == 2).false? )
+      assert( ! (1 == 1).false? )
+    end
+
+    def test_true?
+      assert( true.true? )
+      assert( (1 == 1).true? )
+      assert( ! (1 == 2).true? )
+    end
+
+    def test_bool?
+      assert_equal( true, true.bool? )
+      assert_equal( true, false.bool? )
+      assert_equal( false, nil.bool? )
+      assert_equal( false, 0.bool? )
+    end
+
+  end
+
+=end