mack-facets 0.8.1 → 0.8.2

data/lib/gems/facets-2.4.5/lib/more/facets/rbsystem.rb

@@ -0,0 +1,222 @@
+# = System
+#
+# The System module provides Platform and Ruby system information.
+# The module should also be able to stand in for rbconfig.
+# It is intended for use as a service module although it
+# can be mixed-in too.
+#
+# Note: This library is still being worked on a good bit.
+#
+# == History
+#
+#   Adapted from RubyParams module by Minero Aoki
+#   Copyright (c) 1999-2002 Minero Aoki <aamine@loveruby.net>
+#
+# == Authors
+#
+# * Thomas Sawyer
+# * Minero Aoki
+#
+# == Todo
+#
+# * Consider renaming module to "Ruby" ?
+#
+# == Copying
+#
+# Copyright (c) 2005 Thomas Sawyer, Minero Aoki
+#
+# Ruby License
+#
+# This module is free software. You may use, modify, and/or redistribute this
+# software under the same terms as Ruby.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.
+
+require 'rbconfig'
+
+# = System
+#
+# The System module provides Platform and Ruby system information.
+# The module should also be able to stand in for rbconfig.
+# It is intended for use as a service module although it
+# can be mixed-in too.
+
+module System
+
+  extend self  # or module_function ?
+
+  # Execution Environment -------------------------------------
+
+  def program_name; $0 ; end
+  def program_name=(x); $0=x ; end
+
+  def argv; $* ; end
+  alias options argv
+
+  # these won't work here
+  #def file; __FILE__ ; end
+  #def filepath; File.expand_path(__FILE__) ; end
+  #def lineno; __LINE__ ; end
+
+  def process_id; $$ ; end
+  alias_method :pid, :process_id
+
+  def child_status; $? ; end
+  alias exit_status child_status
+
+  def error_info; $! ; end
+  def error_position; $@ ; end
+
+  def debug; $DEBUG; end
+
+  def safe; $SAFE; end
+
+  def verbose; $VERBOSE; end
+  def verbose=(x); $VERBOSE=x; end
+
+  def coding; $-K ; end
+  def coding=(x); $-K=x ; end
+
+  def line_end_processing; $-l ; end
+
+  def program_loop; $-p ; end
+
+  def environment; ENV ; end
+  def env; ENV ; end
+
+  # Input/Ouput Variables -------------------------------------
+
+  def stdin; $stdin ; end
+  def stdin=(x); $stdin=x ; end
+
+  def stdout ; $stdout ; end
+  def stdout=(x); $stdout=x ; end
+
+  def stderr ; $stderr ; end
+  def stderr=(x); $stderr=x ; end
+
+  def default_input ; $< ; end
+  alias_method :defin, :default_input
+  alias_method :argf, :default_input
+
+  def default_output ; $> ; end
+  def default_output=(x); $defout=x ; end
+  alias_method :defout, :default_output
+  alias_method :defout=, :default_output=
+
+  def output_record_separator ; $\ ; end
+  def output_record_separator=(x) ; $\=x ; end
+  alias_method :ors, :output_record_separator
+  alias_method :ors=, :output_record_separator=
+
+  def output_field_separator ; $-F ; end
+  def output_field_separator=(x) ; $-F=x ; end
+  alias_method :ofs, :output_field_separator
+  alias_method :ofs=, :output_field_separator=
+
+  def input_record_separator ; $/ ; end
+  def input_record_separator=(x) ; $/=x ; end
+  alias_method :rs, :input_record_separator
+  alias_method :rs=, :input_record_separator=
+
+  def input_field_separator ; $/ ; end
+  def input_field_separator=(x) ; $/=x ; end
+  alias_method :fs, :input_field_separator
+  alias_method :fs=, :input_field_separator=
+
+  def input_line_number ; $. ; end
+  alias_method :input_lineno, :input_line_number
+
+  # Miscellaneous ---------------------------------------------
+
+  def data; DATA ; end
+
+  # Ruby Config -----------------------------------------------
+
+  ::Config::CONFIG.each do |k,v|
+    define_method( k.downcase ) { v }
+  end
+
+  alias_method :ruby, :ruby_install_name
+
+  def rubypath
+    File.join( bindir, ruby_install_name )
+  end
+
+  def platform
+    RUBY_PLATFORM
+  end
+
+  def version
+    RUBY_VERSION
+  end
+
+  def release
+    RUBY_RELEASE_DATE
+  end
+
+  def extentions
+    [ 'rb', DLEXT ]
+  end
+
+  def rubylibdir
+    File.join( libdir, 'ruby'  )
+  end
+
+  #def sitelibdir
+  #  File.join( rubylibdir, 'site_ruby', version )
+  #end
+  #
+  #STDLIBDIR  = File.join( LIBDIR, VERSION )
+  #RBDIR      = File.join( STDLIBDIR )
+  #SODIR      = File.join( STDLIBDIR, ARCH )
+  #
+  #SITE_RB    = File.join( SITELIBDIR )
+  #SITE_SO    = File.join( SITELIBDIR, ARCH )
+
+  # load path ----------------------------------------------------
+
+  def load_path; $: ; end
+
+  def loaded_features; $" ; end
+  alias_method :required, :loaded_features
+
+  # platform -----------------------------------------------------
+
+  def current_platform
+    arch = Config::CONFIG['arch']
+    #cpu, os = arch.split '-', 2
+    return match_platform(arch)
+  end
+
+  #
+
+  def match_platform(arch)
+    cpu, os = arch.split '-', 2
+    cpu, os = nil, cpu if os.nil? # java
+
+    cpu = case cpu
+          when /i\d86/ then 'x86'
+          else cpu
+          end
+
+    os  = case os
+          when /cygwin/ then            [ 'cygwin',  nil ]
+          when /darwin(\d+)?/ then      [ 'darwin',  $1  ]
+          when /freebsd(\d+)/ then      [ 'freebsd', $1  ]
+          when /^java$/ then            [ 'java',    nil ]
+          when /^java([\d.]*)/ then     [ 'java',    $1  ]
+          when /linux/ then             [ 'linux',   $1  ]
+          when /mingw32/ then           [ 'mingw32', nil ]
+          when /mswin32/ then           [ 'mswin32', nil ]
+          when /openbsd(\d+\.\d+)/ then [ 'openbsd', $1  ]
+          when /solaris(\d+\.\d+)/ then [ 'solaris', $1  ]
+          else                          [ 'unknown', nil ]
+          end
+
+    [cpu, os].flatten.compact.join("-")
+  end
+
+end

data/lib/gems/facets-2.4.5/lib/more/facets/recorder.rb

@@ -0,0 +1,109 @@
+# = Recorder
+#
+# == Synopsis
+#
+# Recorder is similar essentially a method probe. It records everthing
+# that happens to it, building an internal parse tree. You can then
+# pass a substitute object and apply the recoding to it. Or you can
+# utilize the parse tree.
+#
+# The only limitation of Recorder is with special operators, like if, &&, ||, etc.
+# Since they are not true methods they can't be recorded. (Too bad for Ruby.)
+#
+# == Usage
+#
+#   class Z
+#     def name ; 'George' ; end
+#     def age ; 12 ; end
+#   end
+#
+#   z = Z.new
+#
+#   r = Recorder.new
+#   q = proc { |x| (x.name == 'George') & (x.age > 10) }
+#   x = q[r]
+#   x.__call__(z)
+#
+# produces
+#
+#   true
+#
+# == Authors
+#
+# * Thomas Sawyer
+#
+# == Copying
+#
+# Copyright (c) 2006 Thomas Sawyer
+#
+# Ruby License
+#
+# This module is free software. You may use, modify, and/or redistribute this
+# software under the same terms as Ruby.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.
+
+require 'facets/kernel/object_class'
+
+# = Recorder
+#
+# Recorder is similar essentially a method probe. It records everthing
+# that happens to it, building an internal parse tree. You can then
+# pass a substitute object and apply the recoding to it. Or you can
+# utilize the parse tree.
+#
+# The only limitation of Recorder is with special operators, like if, &&, ||, etc.
+# Since they are not true methods they can't be recorded. (Too bad for Ruby.)
+#
+#   class Z
+#     def name ; 'George' ; end
+#     def age ; 12 ; end
+#   end
+#
+#   z = Z.new
+#
+#   r = Recorder.new
+#   q = proc { |x| (x.name == 'George') & (x.age > 10) }
+#   x = q[r]
+#   x.__call__(z)
+#
+# produces
+#
+#   true
+#
+class Recorder
+
+  # Privatize all kernel methods.
+
+  private(*instance_methods)
+
+  #
+
+  def initialize( msg=nil )
+    @msg = msg
+  end
+
+  def inspect
+    "<Recorder #{@msg.inspect}>"
+  end
+
+  def __call__( orig )
+    return orig unless @msg
+
+    sym  = @msg[0]
+    args = @msg[1..-1].collect do |a|
+      Recorder === a ? a.__call__(orig) : a
+    end
+    obj  = args.shift
+
+    obj.__send__( sym, *args )
+  end
+
+  def method_missing( sym, *args, &blk )
+    object_class.new( [ sym, self, *args ] )
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/more/facets/reference.rb

@@ -0,0 +1,99 @@
+# = Reference
+#
+# Reference provides a way to access object indirectly.
+# This allows for the object itself to be changed on the fly.
+#
+# == Synopsis
+#
+#   a = "HELLO"
+#   b = ref(a)
+#   puts b    #=> "HELLO"
+#   c = 10
+#   b.become(c)
+#   puts b    #=> "10"
+#
+# == Authors
+#
+# * Thomas Sawyer
+#
+# == Copying
+#
+# Copyright (c) 2005 Thomas Sawyer
+#
+# Ruby License
+#
+# This module is free software. You may use, modify, and/or redistribute this
+# software under the same terms as Ruby.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.
+
+# = Reference
+#
+# Reference provides a way to access object indirectly.
+# This allows for the object itself to be changed on the fly.
+#
+#   a = "HELLO"
+#   b = ref(a)
+#   puts b    #=> "HELLO"
+#   c = 10
+#   b.become(c)
+#   puts b    #=> "10"
+#
+class Reference
+
+  # Privatize most Kernel methods.
+
+  private *instance_methods
+
+  def self.new(obj)
+    ref = allocate
+    ref.become obj
+    ref
+  end
+
+  def method_missing(*args, &block)
+    @ref.__send__(*args, &block)
+  end
+
+  def become(obj)
+    old = @ref
+    @ref = obj
+    old
+  end
+
+  def __value__
+    @ref
+  end
+
+  alias_method :instance_delegate, :__value__
+end
+
+
+module Kernel
+
+  # Shortcut reference constructor.
+
+  def ref(x)
+    Reference.new(x)
+  end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+=begin #test
+
+  require 'test/unit'
+
+  # TODO
+
+=end

data/lib/gems/facets-2.4.5/lib/more/facets/reflection.rb

@@ -0,0 +1,145 @@
+# = Reflection
+#
+# Provides externailzed, safe access to an object's meta-information.
+#
+# == Authors
+#
+# * Thomas Sawyer
+#
+# == Copying
+#
+# Copyright (c) 2006 Thomas Sawyer
+#
+# Ruby License
+#
+# This module is free software. You may use, modify, and/or redistribute this
+# software under the same terms as Ruby.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.
+#
+# == NOTES
+#
+# This is expirmental. Maybe it should be moved to the Trinkets project.
+# The idea is to be able to access a object as a pure object, by binding
+# methods called to Object/Kernel first. Thus bypassing any overriden
+# methods.
+#
+# But you can use #at to do this already.
+#
+#   obj.at(Object).object_id
+#
+# For metaprogramming this can be important.
+
+#
+class << ObjectSpace
+  alias_method :[], :_id2ref
+end
+
+# = ObjectReflection
+#
+#   obj.__object__.id
+#   obj.__object__.class
+#
+# NOTE: This is still an expirmental library.
+
+class ObjectReflection
+
+  instance_methods.each{|m| private(m) unless m.to_s =~ /^__/ }
+
+  #
+  def initialize(object)
+    @self = object
+    @meth = {}
+  end
+
+  #
+  def id
+    _bind_method(:object_id).call
+  end
+
+  #Kernel.instance_methods.select{ |m| m =~ /^instance_/ }.each do |m|
+  #  meth = m.to_s.sub(/^instance_/, '')
+  #  module_eval %{
+  #    def #{meth}(*a, &b)
+  #      _bind_method(:#{m}).call(*a,&b)
+  #    end
+  #  }
+  #end
+
+  def method_missing(s, *a, &b)
+    _bind_method(s).call(*a, &b)
+  end
+
+  private
+
+  def _bind_method(meth)
+    @meth[meth.to_sym] ||= Kernel.instance_method(meth).bind(@self)
+  end
+
+end
+
+module Kernel
+
+  # Binds a method to Object/Kernel before calling it.
+  #
+  #   obj.__object__.id
+  #   obj.__object__.class
+  #
+  # For metaprogramming this can be important.
+
+  def __object__
+    @_object_reflection ||= ObjectReflection.new(self)
+  end
+
+  #def __instance__
+  #  @_instance_reflection ||= InstanceReflection.new(self)
+  #end
+
+end
+
+
+
+=begin
+# = InstanceReflection
+#
+#   obj.__instance__.id
+#   obj.__instance__.class
+#
+#
+class InstanceReflection < ObjectReflection
+
+  REFLECTION_METHODS = (
+    meths = Kernel.instance_methods.select{ |m| m =~ /^instance_/ }
+    meths += [:send]
+    meths.collect!{|m| m.to_sym}
+    meths.uniq!
+p meths
+    meths
+  )
+
+  def initialize(object)
+    @self = object
+    @proc = {}
+    #@meta = REFLECTION_METHODS.inject({}) do |rproc, meth|
+    #  name = meth.to_s.sub(/^instance_/, '').to_sym
+    #  rproc[name] = Kernel.instance_method(meth).bind(@self)
+    #  rproc
+    #end
+  end
+
+  REFLECTION_METHODS.each do |meth|
+    name = meth.to_s.sub(/^instance_/, '')
+
+    module_eval %{
+      def #{name}(*a,&b)
+        @proc[:#{meth}] ||= Kernel.instance_method(:#{meth}).bind(@self)
+        @proc[:#{meth}].call(*a,&b)
+      end
+    }, __FILE__, __LINE__
+  end
+
+end
+=end
+