facets 2.4.0 → 2.4.1

data/lib/facets/net/smtp_tls.rb

@@ -41,17 +41,13 @@ class Net::SMTP
     send :remove_method, :start
   end
 
-  def self.start( address, port = nil,
-                  helo = 'localhost.localdomain',
-                  user = nil, secret = nil, authtype = nil, use_tls = false,
-                  &block) # :yield: smtp
+  def self.start(address, port=nil, helo='localhost.localdomain', user=nil, secret=nil, authtype=nil, use_tls=false, &block) # :yield: smtp
     new(address, port).start(helo, user, secret, authtype, use_tls, &block)
   end
 
   alias tls_old_start start
 
-  def start( helo = 'localhost.localdomain',
-             user = nil, secret = nil, authtype = nil, use_tls = false ) # :yield: smtp
+  def start(helo='localhost.localdomain', user=nil, secret=nil, authtype=nil, use_tls=false) # :yield: smtp
     start_method = use_tls ? :do_tls_start : :do_start
     if block_given?
       begin
@@ -75,7 +71,7 @@ class Net::SMTP
     sock = timeout(@open_timeout) { TCPSocket.open(@address, @port) }
     @socket = Net::InternetMessageIO.new(sock)
     @socket.read_timeout = 60 #@read_timeout
-    @socket.debug_output = STDERR #@debug_output
+    @socket.debug_output = STDERR if $DEBUG #@debug_output
 
     check_response(critical { recv_response() })
     do_helo(helodomain)
@@ -87,7 +83,7 @@ class Net::SMTP
     ssl.connect
     @socket = Net::InternetMessageIO.new(ssl)
     @socket.read_timeout = 60 #@read_timeout
-    @socket.debug_output = STDERR #@debug_output
+    @socket.debug_output = STDERR if $DEBUG #@debug_output
     do_helo(helodomain)
 
     authenticate user, secret, authtype if user
@@ -132,3 +128,4 @@ class Net::SMTP
 
 end unless Net::SMTP.private_method_defined? :do_tls_start or
            Net::SMTP.method_defined? :tls?
+

data/lib/facets/openhash.rb

@@ -15,6 +15,7 @@
 # an method_missing definition that routes to [] and []=.
 #
 class OpenHash < Hash
+  #private *instance_methods.select{|m| m !~ /^__/}
 
   # New OpenHash.
 

data/lib/facets/openobject.rb

@@ -47,7 +47,8 @@
 
 require 'facets/hash/to_h'
 require 'facets/hash/to_proc'
-require 'facets/kernel/object' # object_class, object_hexid
+require 'facets/kernel/object_class'
+require 'facets/kernel/object_hexid'
 
 # = OpenObject
 #

data/lib/facets/paramix.rb

@@ -0,0 +1,187 @@
+# TITLE:
+#
+#   Parametric Mixins
+#
+# SUMMARY:
+#
+#   Parametric Mixins provides parameters for mixin modules.
+#
+# COPYRIGHT:
+#
+#   Copyright (c) 2008 T. Sawyer
+#
+# LICENSE:
+#
+#   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.
+#
+# AUTHORS:
+#
+#   - Thomas Sawyer
+
+require 'facets/module/basename'
+require 'facets/module/modspace'
+
+# = Parametric Mixin
+#
+# Parametric Mixins provides parameters for mixin modules.
+# Module parameters can be set at the time of inclusion or extension,
+# then accessed via an instance method per mixin.
+#
+#   module Mixin
+#     def hello
+#       puts "Hello from #{mixin_parameters[Mixin][:name]}"
+#     end
+#   end
+#
+#   class MyClass
+#     include Mixin(:name => 'Ruby')
+#   end
+#
+#   m = MyClass.new
+#   m.hello -> 'Hello from Ruby'
+#
+# You can view the full set of parameters via the #mixin_parameters
+# class method, which returns a hash keyed on the included modules.
+#
+#   MyClass.mixin_parameters         #=> {Mixin=>{:name=>'Ruby'}}
+#   MyClass.mixin_parameters[Mixin]  #=> {:name=>'Ruby'}
+#
+# To create _dynamic mixins_ you can use the #included callback
+# method along with mixin_parameters method like so:
+#
+#   module Mixin
+#     def self.included( base )
+#       parms = base.mixin_parameters[self]
+#       base.class_eval {
+#         def hello
+#           puts "Hello from #{parms(:name)}"
+#         end
+#       }
+#     end
+#   end
+#
+#--
+# More conveniently a new callback has been added, #included_with_parameters,
+# which passes in the parameters in addition to the base class/module.
+#
+#   module Mixin
+#     def self.included_with_parameters( base, parms )
+#       base.class_eval {
+#         def hello
+#           puts "Hello from #{parms(:name)}"
+#         end
+#       }
+#     end
+#   end
+#
+# We would prefer to have passed the parameters through the #included callback
+# method itself, but implementation of such a feature is much more complicated.
+# If a reasonable solution presents itself in the future however, we will fix.
+#++
+
+module Paramix  # or PatrametricMixin ?
+
+  def self.append_features(base)
+    base.modspace.module_eval %{
+      def #{base.basename.to_s}(parameters, &block)
+        Delegator.new(#{base}, parameters, &block)
+      end
+    }
+  end
+
+  # It you want to define the module method by hand. You
+  # can use Parmix.new instead of Parmix::Delegator.new.
+
+  def self.new(delegate_module, parameters={}, &base_block)
+    Delegator.new(delegate_module, parameters, &base_block)
+  end
+
+  #
+
+  class Delegator < Module
+
+    attr :delegate_module
+    attr :parameters
+    attr :base_block
+
+    def initialize(delegate_module, parameters={}, &base_block)
+      @delegate_module = delegate_module
+      @parameters      = parameters
+      @base_block      = base_block
+    end
+
+    def append_features(base)
+      base.__send__(:include, delegate_module)
+
+      base.mixin_parameters[delegate_module] = parameters
+
+      base.module_eval do 
+        define_method(:mixin_parameters) do
+          base.mixin_parameters
+        end
+      end
+
+      base.module_eval(&@base_block) if base_block
+    end
+
+    def [](name)
+      @parameters[name]
+    end
+
+  end
+
+end
+
+
+class Module
+
+  # Store for parametric mixin parameters.
+  #
+  # Returns a hash, the keys of which are the parametric mixin module
+  # and the values are the parameters associacted with this module/class.
+  #
+  #   class C
+  #     include P(:x=>1)
+  #   end
+  #
+  #   C.mixin_parameters[P]   #=> {:x=>1}
+  #
+  def mixin_parameters
+    @mixin_parameters ||= {}
+  end
+
+end
+
+
+if __FILE__ == $0
+
+  module O
+    include Paramix
+
+    def x
+      mixin_parameters[O][:x]
+    end
+  end
+
+  #def O(options)
+  #  Paramix.new(O, options)
+  #end
+
+  class X
+    include O(:x=>1)
+  end
+
+  x = X.new
+  p x.x
+
+  p X.ancestors
+
+end
+

data/lib/facets/platform.rb

@@ -0,0 +1,192 @@
+# Copyright (c) 2007 Eric Hodel
+#
+# Available list of platforms.
+
+require 'rbconfig'
+
+class Platform
+
+  @local      = nil
+  @supported  = nil
+
+  attr_accessor :cpu
+
+  attr_accessor :os
+
+  attr_accessor :version
+
+  RbConfig = Config unless defined? ::RbConfig
+
+  DEPRECATED_CONSTS = [
+    :DARWIN,
+    :LINUX_586,
+    :MSWIN32,
+    :PPC_DARWIN,
+    :WIN32,
+    :X86_LINUX
+  ]
+
+  # Array of supported platforms (ie. pure-Ruby and local platform).
+
+  def self.supported
+    @suported ||= [Platform::RUBY, Platform.local]
+  end
+
+  def self.const_missing(name) # TODO remove six months from 2007/12
+    if DEPRECATED_CONSTS.include? name then
+      raise NameError, "#{name} has been removed, use CURRENT instead"
+    else
+      super
+    end
+  end
+
+  def self.local
+    arch = RbConfig::CONFIG['arch']
+    arch = "#{arch}_60" if arch =~ /mswin32$/
+    @local ||= new(arch)
+  end
+
+  def self.match(platform)
+    supported.any? do |local_platform|
+      platform.nil? or local_platform == platform or
+        (local_platform != Platform::RUBY and local_platform =~ platform)
+    end
+  end
+
+  def self.new(arch) # :nodoc:
+    case arch
+    when Platform::CURRENT then
+      Platform.local
+    when Platform::RUBY, nil, '' then
+      Platform::RUBY
+    else
+      super
+    end
+  end
+
+  def initialize(arch)
+    case arch
+    when Array then
+      @cpu, @os, @version = arch
+    when String then
+      arch = arch.split '-'
+
+      if arch.length > 2 and arch.last !~ /\d/ then # reassemble x86-linux-gnu
+        extra = arch.pop
+        arch.last << "-#{extra}"
+      end
+
+      cpu = arch.shift
+
+      @cpu = case cpu
+             when /i\d86/ then 'x86'
+             else cpu
+             end
+
+      if arch.length == 2 and arch.last =~ /^\d+$/ then # for command-line
+        @os, @version = arch
+        return
+      end
+
+      os, = arch
+      @cpu, os = nil, cpu if os.nil? # legacy jruby
+
+      @os, @version = case os
+                      when /aix(\d+)/ then             [ 'aix',       $1  ]
+                      when /cygwin/ then               [ 'cygwin',    nil ]
+                      when /darwin(\d+)?/ then         [ 'darwin',    $1  ]
+                      when /freebsd(\d+)/ then         [ 'freebsd',   $1  ]
+                      when /hpux(\d+)/ then            [ 'hpux',      $1  ]
+                      when /^java$/, /^jruby$/ then    [ 'java',      nil ]
+                      when /^java([\d.]*)/ then        [ 'java',      $1  ]
+                      when /linux/ then                [ 'linux',     $1  ]
+                      when /mingw32/ then              [ 'mingw32',   nil ]
+                      when /(mswin\d+)(\_(\d+))?/ then
+                        os, version = $1, $3
+                        @cpu = 'x86' if @cpu.nil? and os =~ /32$/
+                        [os, version]
+                      when /netbsdelf/ then            [ 'netbsdelf', nil ]
+                      when /openbsd(\d+\.\d+)/ then    [ 'openbsd',   $1  ]
+                      when /solaris(\d+\.\d+)/ then    [ 'solaris',   $1  ]
+                      # test
+                      when /^(\w+_platform)(\d+)/ then [ $1,          $2  ]
+                      else                             [ 'unknown',   nil ]
+                      end
+    when Platform then
+      @cpu = arch.cpu
+      @os = arch.os
+      @version = arch.version
+    else
+      raise ArgumentError, "invalid argument #{arch.inspect}"
+    end
+  end
+
+  def inspect
+    "#<%s:0x%x @cpu=%p, @os=%p, @version=%p>" % [self.class, object_id, *to_a]
+  end
+
+  def to_a
+    [@cpu, @os, @version]
+  end
+
+  def to_s
+    to_a.compact.join '-'
+  end
+
+  def ==(other)
+    self.class === other and
+      @cpu == other.cpu and @os == other.os and @version == other.version
+  end
+
+  def ===(other)
+    return nil unless Platform === other
+
+    # cpu
+    (@cpu == 'universal' or other.cpu == 'universal' or @cpu == other.cpu) and
+
+    # os
+    @os == other.os and
+
+    # version
+    (@version.nil? or other.version.nil? or @version == other.version)
+  end
+
+  def =~(other)
+    case other
+    when Platform then # nop
+    when String then
+      # This data is from http://gems.rubyforge.org/gems/yaml on 19 Aug 2007
+      other = case other
+              when /^i686-darwin(\d)/ then     ['x86',       'darwin',  $1]
+              when /^i\d86-linux/ then         ['x86',       'linux',   nil]
+              when 'java', 'jruby' then        [nil,         'java',    nil]
+              when /mswin32(\_(\d+))?/ then    ['x86',       'mswin32', $2]
+              when 'powerpc-darwin' then       ['powerpc',   'darwin',  nil]
+              when /powerpc-darwin(\d)/ then   ['powerpc',   'darwin',  $1]
+              when /sparc-solaris2.8/ then     ['sparc',     'solaris', '2.8']
+              when /universal-darwin(\d)/ then ['universal', 'darwin',  $1]
+              else                             other
+              end
+
+      other = Platform.new other
+    else
+      return nil
+    end
+
+    self === other
+  end
+
+  ##
+  # A pure-ruby gem that may use Gem::Specification#extensions to build
+  # binary files.
+
+  RUBY = 'ruby'
+
+  ##
+  # A platform-specific gem that is built for the packaging ruby's platform.
+  # This will be replaced with Gem::Platform::local.
+
+  CURRENT = 'current'
+
+end
+

data/lib/facets/recorder.rb

@@ -45,7 +45,7 @@
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 # FOR A PARTICULAR PURPOSE.
 
-require 'facets/kernel/object' # for object_class
+require 'facets/kernel/object_class'
 
 # = Recorder
 #