mack-facets 0.8.1 → 0.8.2

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

@@ -0,0 +1,202 @@
+# 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 using Module#[] method, then parameters
+# can be accessed via the #mixin_parameters method.
+#
+#   module MyMixin
+#     include Paramix
+#
+#     def hello
+#       puts "Hello from #{mixin_parameters[MyMixin][: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         #=> {MyMixin=>{:name=>'Ruby'}}
+#   MyClass.mixin_parameters[MyMixin]  #=> {:name=>'ruby'}
+#
+# The include Praamix is equivalent to:
+#
+#   def [](parameters)
+#     Paramix.new(self, parameters)
+#   end
+#
+# Paramix.new can also take a block that injects code into the class
+# or module including the parametric mixin. This is useful as an
+# alternative to using the #included callback for creating dynamic
+# mixins.. For example:
+#
+#   def self.[](parameters)
+#     Paramix.new(self, parameters) do
+#       attr_accessor mixin_params[MyMixin][:name]
+#     end
+#   end
+#
+# As opposed to:
+#
+#   module Mixin
+#     def self.included(base)
+#       base.class_eval do
+#         attr_accessor mixin_params[MyMixin][: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 #{mixin_parameters[Mixin][: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)
+    (class << base; self; end).class_eval do
+      define_method(:[]) do |parameters|  # TODO until 1.9 no &block
+        Delegator.new(base, parameters)
+      end
+    end
+  end
+
+  # It you want to define the module's ::[] method by hand. You
+  # can use Paramix.new instead of Paramix::Delegator.new.
+
+  def self.new(delegate_module, parameters={}, &base_block)
+    Delegator.new(delegate_module, parameters, &base_block)
+  end
+
+  #
+
+  class Delegator < Module
+
+    attr :module_delegate
+    attr :parameters
+    attr :base_block
+
+    #
+
+    def initialize(module_delegate, parameters={}, &base_block)
+      @module_delegate = module_delegate
+      @parameters      = parameters
+      @base_block      = base_block
+    end
+
+    #
+
+    def append_features(base)
+      base.mixin_parameters[module_delegate] = parameters
+
+      base.module_eval do 
+        define_method(:mixin_parameters) do
+          base.mixin_parameters
+        end
+        alias_method :mixin_params, :mixin_parameters
+      end
+
+      base.module_eval(&@base_block) if base_block
+
+      base.__send__(:include, module_delegate)
+    end
+
+    #
+
+    def extend_object(base)
+      baseclass = (class << base; self; end)
+
+      baseclass.mixin_parameters[module_delegate] = parameters
+
+      baseclass.module_eval do 
+        define_method(:mixin_parameters) do
+          baseclass.mixin_parameters
+        end
+        alias_method :mixin_params, :mixin_parameters
+      end
+
+      baseclass.module_eval(&@base_block) if base_block
+
+      base.__send__(:extend, module_delegate)
+    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
+  alias_method :mixin_params, :mixin_parameters
+
+end
+

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

@@ -0,0 +1,37 @@
+# MissingArgument exception class is used to represent an argument "hole".
+
+class MissingArgument < ArgumentError
+end
+
+# Convenience method for an argument hole.
+# It simple returns the MissingArgument exception class.
+
+def __
+  MissingArgument
+end
+
+class Proc
+
+  # Convert a Proc object into new partial Proc object.
+  #
+  #   a = proc { |a,b,c| a+b+c }
+  #   b = a.partial(__, 2, __)
+  #   b[1,3] #=> 6
+  #
+  # This method is similar to Proc#curry.
+  #
+  # CREDT Trans
+  #
+  # TODO: Parhaps ArgumentError would suffice, and we don't need MissingArgument?
+
+  def partial(*args)
+    Proc.new do |*spice|
+      result = args.collect do |a|
+        MissingArgument == a ? spice.pop : a
+      end
+      call(*result)
+    end
+  end
+
+end
+

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

@@ -0,0 +1,112 @@
+# = PathList
+#
+# A PathList is an array containing 1..n paths. It is useful to regroup paths and
+# make lookups on them.
+#
+# == Usage
+#
+#  path = PathList.new(ENV['PATH'])
+#  path.find 'env'            #=> "/usr/bin/env"
+#
+#  # This is already done when including the library
+#  $:.class                   #=> Array
+#  $:.extend PathList::Finder
+#  $:.find_ext = 'rb'
+#
+#  $:.find 'uri'              #=> "/usr/lib/ruby/1.8/uri.rb"
+#
+# == Authors
+#
+# * Jonas Pfenniger
+#
+# == Copying
+#
+# Copyright (c) 2005 Jonas Pfenniger
+#
+# 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.
+
+
+# = PathList
+#
+# A PathList is an array containing 1..n paths. It is useful to regroup paths and
+# make lookups on them.
+#
+# == Usage
+#
+#  path = PathList.new(ENV['PATH'])
+#  path.find 'env'            #=> "/usr/bin/env"
+#
+#  # This is already done when including the library
+#  $:.class                   #=> Array
+#  $:.extend PathList::Finder
+#  $:.find_ext = 'rb'
+#
+#  $:.find 'uri'              #=> "/usr/lib/ruby/1.8/uri.rb"
+#
+class PathList < Array
+
+  def initialize(paths, default_ext = nil)
+    @find_ext = default_ext
+    if paths.kind_of? String
+      paths = paths.split(File::PATH_SEPARATOR)
+    end
+    super(paths)
+  end
+
+  def to_s
+    join(File::PATH_SEPARATOR)
+  end
+
+  module Finder
+
+    attr_accessor :find_ext
+
+    def find(filename, use_ext=true)
+      filename += '.' + @find_ext if @find_ext and use_ext
+      to_a.each do |path|
+        filepath = File.join(path, filename)
+        return filepath if File.exist?( filepath )
+      end
+      return nil
+    end
+    alias :include? find
+
+  end
+  include Finder
+end
+
+$:.extend PathList::Finder
+$:.find_ext = 'rb'
+
+# Doesn't work
+#ENV['PATH'] = PathList.new(ENV['PATH'])
+
+#++
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin #testing
+
+  require 'test/unit'
+
+  # Needs a Mockup
+  # It is not possible to test file lookups in a platform independent manner.
+
+  class TC_PathList < Test::Unit::TestCase
+
+  end
+
+=end
+

data/lib/gems/facets-2.4.5/lib/more/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
+