facets 2.8.4 → 2.9.0.pre.1

data/lib/more/facets/prepend.rb

@@ -1,57 +0,0 @@
-# :title:       Prepend
-# :copyright:   Copyright (c) 2005 Thomas Sawyer
-# :license:     Ruby License
-# :description: Prepend a module to another module, or to a class.
-
-# = Prepend
-#
-# This is a module prepend system, which provides an elegant
-# way to prepend code to the class hierarchy rather then append
-# it (a la #include).
-#
-#   class C
-#     def f
-#       "f"
-#     end
-#   end
-#
-#   module M
-#     def f
-#       '{' + super + '}'
-#     end
-#   end
-#
-#   class C
-#     prepend M
-#   end
-#
-#   c = C.new
-#   c.f  #=> "{f}"
-#
-# This works by overriding Class#new so that all prepended modules
-# extend new instances of the class upon instantiation.
-#
-# If needed the original #new method has been aliased as #init.
-
-class Class
-
-  #
-  def prepend(*mods)
-    @prepend ||= []
-    @prepend.concat(mods)
-    @prepend
-  end
-
-  alias_method :init, :new
-
-  def new(*args, &blk)
-    o = allocate
-    prepend.each do |mod|
-      o.extend(mod)
-    end
-    o.__send__(:initialize, *args, &blk) #if private_method_defined?(:initialize)
-    o
-  end
-
-end
-

data/lib/more/facets/rbsystem.rb

@@ -1,222 +0,0 @@
-# = 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/more/facets/registerable.rb

@@ -1,35 +0,0 @@
-# = Registerable
-#
-# == Copying
-#
-# Copyright (c) 2007 Tiger Ops
-
-# = Registerable
-#
-module Registerable
-
-  # Register format names.
-
-  def register(*names)
-    names.each do |name|
-      registry[name.to_s] = self
-    end
-  end
-
-  # Access registry.
-
-  def registry
-    @@registry ||= {}
-  end
-
-  #
-
-  def registry_invalid?(*types)
-    bad = []
-    types.each do |type|
-      bad << type unless @@registry[type]
-    end
-    return bad.empty? ? false : bad
-  end
-
-end

data/lib/more/facets/semaphore.rb

@@ -1,92 +0,0 @@
-# = Semaphore
-#
-# Technically a semaphore is simply an integer variable which
-# has an execution queue associated with it.
-#
-# == Authors
-#
-# * Fukumoto
-#
-# = Copying
-#
-# Copyright (c) 2005 Fukumoto
-#
-# 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.
-
-
-# = Semaphore
-#
-# Technically a semaphore is simply an integer variable which
-# has an execution queue associated with it.
-#
-class Semaphore
-
-  def initialize(initvalue = 0)
-    @counter = initvalue
-    @waiting_list = []
-  end
-
-  def wait
-    Thread.critical = true
-    if (@counter -= 1) < 0
-      @waiting_list.push(Thread.current)
-      Thread.stop
-    end
-    self
-  ensure
-    Thread.critical = false
-  end
-
-  def signal
-    Thread.critical = true
-    begin
-      if (@counter += 1) <= 0
-        t = @waiting_list.shift
-        t.wakeup if t
-      end
-    rescue ThreadError
-      retry
-    end
-    self
-  ensure
-    Thread.critical = false
-  end
-
-  alias_method( :down, :wait )
-  alias_method( :up,   :signal )
-  alias_method( :p,    :wait )
-  alias_method( :v,    :signal )
-
-  def exclusive
-    wait
-    yield
-  ensure
-    signal
-  end
-
-  alias_method( :synchronize, :exclusive )
-
-end
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-
-# TODO
-
-=begin #test
-
-  require 'test/unit'
-
-=end

data/lib/more/facets/stash.rb

@@ -1,181 +0,0 @@
-# Stash is just like Hash, except that all keys are
-# converted to Strings.
-#
-# Note this doesn't yet handle default_proc.
-
-class Stash < Hash
-
-  #
-  def self.[](*hash)
-    s = new
-    super(*hash).each{ |k,v| s[k] = v }
-    s
-  end
-
-  #
-  def [](key)
-    super(convert_key(key))
-  end
-
-  #
-  def []=(key,value)
-    super(convert_key(key), value)
-  end
-
-  #
-  def <<(other)
-    case other
-    when Hash
-      super(other.rekey{ |key| convert_key(key) })
-    when Array
-      self[other[0]] = other[1]
-    else
-      raise ArgumentError
-    end
-  end
-
-  #
-  def fetch(key)
-    super(convert_key(key))
-  end
-
-  #
-  def store(key, value)
-    super(convert_key(key), value)
-  end
-
-  #
-  def key?(key)
-    super(convert_key(key))
-  end
-
-  #
-  def has_key?(key)
-    super(convert_key(key))
-  end
-
-  #
-  def include?(key)
-    super(convert_key(key))
-  end
-
-  #
-  def member?(key)
-    super(convert_key(key))
-  end
-
-
-  # Synonym for Hash#rekey, but modifies the receiver in place (and returns it).
-  #
-  #   foo = { :name=>'Gavin', :wife=>:Lisa }.to_stash
-  #   foo.rekey!{ |k| k.upcase }  #=>  { "NAME"=>"Gavin", "WIFE"=>:Lisa }
-  #   foo.inspect                 #=>  { "NAME"=>"Gavin", "WIFE"=>:Lisa }
-  #
-  def rekey!(*args, &block)
-    # for backward comptability (TODO: DEPRECATE?).
-    block = args.pop.to_sym.to_proc if args.size == 1
-    if args.empty?
-      block = lambda{|k| k} unless block
-      keys.each do |k|
-        nk = block[k]
-        self[nk.to_s]=delete(k) #if nk
-      end
-    else
-      raise ArgumentError, "3 for 2" if block
-      to, from = *args
-      self[to] = delete(from) if has_key?(from)
-    end
-    self
-  end
-
-  #
-  def rekey(*args, &block)
-    dup.rekey!(*args, &block)
-  end
-
-  #
-  def delete(key)
-    super(convert_key(key))
-  end
-
-  #
-  def update(other)
-    super(other.rekey{ |key| convert_key(key) })
-  end
-
-  # Same as #update.
-  def merge!(other)
-    super(other.rekey{ |key| convert_key(key) })
-  end
-
-  #
-  def merge(other)
-    super(other.rekey{ |key| convert_key(key) })
-  end
-
-  #
-  def replace(other)
-    super(other.rekey{ |key| convert_key(key) })
-  end
-
-  #
-  def values_at(*keys)
-    super(*keys.map{ |key| convert_key(key) })
-  end
-
-  #
-  def to_hash
-    h = {}
-    each{ |k,v| h[k] = v }
-    h
-  end
-
-  alias_method :to_h, :to_hash
-
-  private
-
-    def convert_key(key)
-      key.to_s
-    end
-
-end
-
-class Hash
-
-  # Convert a Hash to a Stash object.
-  def to_stash
-    Stash[self]
-  end
-
-  # Synonym for Hash#rekey, but modifies the receiver in place (and returns it).
-  #
-  #   foo = { :name=>'Gavin', :wife=>:Lisa }
-  #   foo.rekey!{ |k| k.to_s }  #=>  { "name"=>"Gavin", "wife"=>:Lisa }
-  #   foo.inspect               #=>  { "name"=>"Gavin", "wife"=>:Lisa }
-  #
-  # This method comes from Ruby Facets.
-
-  def rekey!(*args, &block)
-    # for backward comptability (TODO: DEPRECATE).
-    block = args.pop.to_sym.to_proc if args.size == 1
-    if args.empty?
-      block = lambda{|k| k.to_sym} unless block
-      keys.each do |k|
-        nk = block[k]
-        self[nk]=delete(k) if nk
-      end
-    else
-      raise ArgumentError, "3 for 2" if block
-      to, from = *args
-      self[to] = self.delete(from) if self.has_key?(from)
-    end
-    self
-  end
-
-  # Non-inplace #rekey! method.
-  def rekey(*args, &block)
-    dup.rekey!(*args, &block)
-  end
-
-end
-