facets 1.4.5 → 1.7.0

data/snip/more/knowself.rb

@@ -1,42 +0,0 @@
-# Of course I'm not sure all of these are "real",
-# but that's okay for now.
-
-class Symbol
-  def self.coercer ; :to_sym ; end
-  def self.convertor ; :intern ; end
-end
-
-class Array
-  def self.coercer ; :to_ary ; end
-  def self.convertor ; :to_a ; end
-end
-
-class Hash
-  def self.coercer ; :to_hash ; end 
-  def self.convertor ; :to_h ; end
-end
-
-class String
-  def self.coercer ; :to_str ; end
-  def self.convertor ; :to_s ; end
-end
-
-class Range
-  def self.coercer ; :to_rng ; end 
-  def self.convertor ; :to_r ; end
-end
-
-class Regexp
-  def self.coercer ; :to_rexp ; end 
-  def self.convertor ; :to_re ; end
-end
-
-class Integer
-  def self.coercer ; :to_int ; end 
-  def self.convertor ; :to_i ; end
-end
-
-class Float
-  def self.coercer ; :to_float ; end
-  def self.convertor ; :to_f ; end
-end

data/snip/more/logger_sing.rb

@@ -1,207 +0,0 @@
-#--
-# GLogger
-#
-# Copyright (c) 2005 George Moschovitis <gm@navel.gr>
-#
-# 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.
-#
-# ===========================================================================
-#  Revision History ::
-# ---------------------------------------------------------------------------
-#
-#  2005.08.25  trans   Ported to Mega Modules with Mark Probet's changes.
-#
-# ===========================================================================
-#
-# :TODO: Docs upadte, What compatibility purposes?
-#
-# :TODO: Implement as mixin that can be added to Log4R.
-#
-#++
-
-require 'logger'
-
-#:title: GLogger
-#
-# A simple wrapper arround the Ruby logger. Mainly for
-# compatibility purposes.
-#
-# == Usage
-#
-#  TODO
-#
-# Author(s)
-#
-# * George Moschovitis
-# * Gavin Sinclair
-# * Mark Probet
-#
-
-class GLogger < Logger
-  alias_method :devel, :debug
-  alias_method :fine, :debug
-
-  # Prints a trace message to DEBUGLOG (at debug level).  
-  # Useful for emitting the value of variables, etc.  Use 
-  # like this:
-  #
-  #   x = y = 5
-  #   trace 'x'        # -> 'x = 5'
-  #   trace 'x ** y'   # -> 'x ** y = 3125'
-  #
-  # If you have a more complicated value, like an array of 
-  # hashes, then you'll probably want to use an alternative 
-  # output format.  For instance:
-  #
-  #   trace 'value', :yaml
-  #
-  # Valid output format values (the _style_ parameter) are:
-  #
-  #   :p :inspect
-  #   :pp                     (pretty-print, using 'pp' library)
-  #   :s :to_s
-  #   :y :yaml :to_yaml       (using the 'yaml' library')
-  #
-  # The default is <tt>:p</tt>.
-  #
-  # CREDITS:
-  #
-  # This code comes straight from the dev-utils Gem.
-  # Author: Gavin Sinclair <gsinclair@soyabean.com.au>
-
-  def trace(expr, style=:p)
-    unless expr.respond_to? :to_str
-      warn "trace: Can't evaluate the given value: #{caller.first}"
-    else
-      require 'nano/binding/of_caller'
-
-      Binding.of_caller do |b|
-        value = b.eval(expr.to_str)
-        formatter = TRACE_STYLES[style] || :inspect
-        case formatter
-        when :pp then require 'pp'
-        when :y, :yaml, :to_yaml then require 'yaml'
-        end
-        value_s = value.send(formatter)
-        message = "#{expr} = #{value_s}"
-        lines = message.split(/\n/)
-        indent = "   "
-        debug(lines.shift)                      
-        lines.each do |line|
-          debug(indent + line)
-        end
-      end
-    end
-  end
-
-  TRACE_STYLES = {}  # :nodoc:
-  TRACE_STYLES.update(
-    :pp => :pp_s, :s => :to_s, :p => :inspect,
-    :y => :to_yaml, :yaml => :to_yaml,
-    :inspect => :inspect, :to_yaml => :to_yaml
-  )
-
-  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-  # Global logger interface. 
-  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-  # Override the logger with your custom version.
-
-  @@global_logger = GLogger.new(STDERR)
-
-  # Set the global Logger.
-
-  def self.set(logger)
-    if logger.is_a?(String)
-      @@global_logger = GLogger.new(logger)
-    elsif logger.is_a?(Logger)
-      @@global_logger = logger
-    else
-      raise ArgumentError.new
-    end
-  end
-
-  def self.get
-    @@global_logger
-  end
-
-  def self.warn(str)
-    @@global_logger.warn(str)
-  end
-
-  def self.info(str)
-    @@global_logger.info(str)
-  end
-
-  def self.debug(str)
-    @@global_logger.debug(str)
-  end
-
-  def self.error(str)
-    @@global_logger.error(str)
-  end
-
-  #--
-  # Saddly have to duplicate the code to make
-  # Binding.of_caller work.
-  #++
-  def self.trace(expr, style=:p)
-    unless expr.respond_to? :to_str
-      warn "trace: Can't evaluate the given value: #{caller.first}"
-    else
-      require 'nano/binding/of_caller'
-
-      Binding.of_caller do |b|
-        value = eval(expr.to_str, b)
-        formatter = TRACE_STYLES[style] || :inspect
-        case formatter
-        when :pp then require 'pp'
-        when :y, :yaml, :to_yaml then require 'yaml'
-        end
-        value_s = value.send(formatter)
-        message = "#{expr} = #{value_s}"
-        lines = message.split(/\n/)
-        indent = "   "
-        debug(lines.shift)                      
-        lines.each do |line|
-          debug(indent + line)
-        end
-      end
-    end
-  end
-
-  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-  private
-
-  # the default Ruby logger has a hardwired silly format.
-
-  Format = "%5s: %s\n"
-
-  def format_message(severity, timestamp, msg, progname)
-    Format % [severity, msg]
-  end
-
-end
-
-# Add logging capabilities to the including class.
-# When using the log/logger variables always check
-# for nil:
-#
-#   log.info "your #{expensive_calculation} comes here" if @log
-#
-# This way the expensive calculation is avoided if the
-# logger is dissabled (@log == nil).
-#
-module Logging
-  attr_accessor :logger
-  alias_method :log, :logger
-end
-

data/snip/more/must.rb

@@ -1,37 +0,0 @@
-#
-# must.rb
-#
-#   Copyright (c) 1999-2002 Minero Aoki <aamine@loveruby.net>
-#
-#   This program is free software.
-#   You can distribute/modify this program under the terms of
-#   the GNU Lesser General Public License version 2 or later.
-#
-#   $Id: must.rb,v 1.12 2002/01/05 06:19:34 aamine Exp $
-#
-class Object
-
-  def must( *args )
-    args.each {|c| return self if c === self }
-    raise TypeError, "wrong arg type '#{self.class}' for required #{args.join('/')}"
-  end
-
-  def must_have( *args )
-    args.each do |m|
-      self.respond_to? m or
-        raise ArgumentError, "receiver #{inspect} does not have '#{m}'"
-    end
-    self
-  end
-  alias_method :needed, :must_have
-
-  def must_be( obj )
-    self == obj or raise ArgumentError, "expected #{eq.inspect} but is #{inspect}"
-    self
-  end
-
-  def must_exist
-    nil? and raise ArgumentError, 'receiver is wrongly nil'
-  end
-
-end

data/snip/more/openproxy.rb

@@ -1,245 +0,0 @@
-
-require 'nano/kernel/meta'
-
-
-module Open
-  def self.included( base )
-    ( class << base ; self ; end ).class_eval {
-      alias_method :create, :new
-      define_method( :new ) { |*args|
-        OpenProxy.new( base, *args )
-      }
-    }
-  end
-end
-
-
-class OpenProxy
-
-  EXCLUDE = /^(__|instance|null$|inspect$)/
-
-  class << self
-    #def new( delegate, *args, &blk )
-    #  o = self.allocate
-    #  self.initialize
-    #  o.instance_eval { @self = delegate.create( *args, &blk ) }
-    #  o
-    #end
-
-    def hide(name)
-      if method_defined?(name) and name !~ EXCLUDE and name =~ /\w+/
-        undef_method( name )
-      end
-    end
-  end
-  instance_methods.each { |m| hide(m) }
-
-  # Proxy Methods
-
-  def __self__ ; @self ; end
-
-  #def inspect( *args, &blk )
-  #  @self.inspect( *args, &blk )
-  #end
-
-  # Open Methods
-
-  def initialize( base, init=nil, *args, &blk )
-    @self = base.create( *args, &blk )
-    @table = {}
-
-    init ||= {}
-    case init
-    when Array
-      @table = Hash[*init]
-    when Hash
-      @table = init.dup
-    else
-      @table = init.to_h.dup
-    end
-  end
-
-  def method_missing( sym, *args )
-    type = sym.to_s[-1,1]
-    name = sym.to_s.gsub(/[=!?]$/, '').to_sym
-
-    if type == '='
-      @table[name] = args[0]
-    elsif type == '!' and args.size > 0
-      @table[name] = args[0]
-      self
-    else
-      #if @table.key?(name)
-        @table[name]
-      #else
-      #  Kernel.null #@table[name] = instance.class.new
-      #end
-    end
-  end
-
-  def to_a    ; @table.values ; end
-  def to_h    ; @table.dup    ; end
-  def to_hash ; @table.dup    ; end
-
-  # duplicate
-  def initialize_copy( orig )
-    super
-    @table = @table.dup
-  end
-
-  # Inspect the underlying delegate
-  def inspect
-    s = "<#{__meta__.class}"
-    s << " " << @table.collect{|k,v| "#{k}=#{v.inspect}"}.join(' ') unless @table.empty?
-    s << ">"
-  end
-
-  def marshal_dump
-    @table
-  end
-  def marshal_load( tbl )
-    @table = tbl
-  end
-
-  # Compare this object and +other+ for equality.
-  def ==(other)
-    return false unless other.__meta__.kind_of?( __meta__.class ) #other.__kind_of__?( __class__ )
-    return @table == other.__table__
-  end
-
-  def [](name)
-    name = name.to_sym
-    #if @table.key?(name)
-      @table[name]
-    #else
-    #  Kernel.null
-    #end
-  end
-
-  def []=(name,val)
-    @table[name.to_sym] = val
-  end
-
-  # For compatibility with other types of hash-like objects.
-  # This may indicate a need for __each__ and a complete set
-  # of secondary __#{name}__ methods from Enumerable.
-  def each(&yld)
-    @table.each( &yld )
-  end
-
-  # Some convenient shadow-methods (instead of doing '__meta__.foo')
-
-  def __table__ ; @table ; end
-
-  #def __get__(k) ; @table.key?(k.to_sym) ? @table[k.to_sym] : null ; end
-  def __get__(k) ; @table[k.to_sym] ; end
-  def __set__(k) ; @table[k.to_sym] = v ; end
-
-  def __keys__ ; @table.keys ; end
-  def __key__?(key) ; @table.key?(key) ; end
-
-  def __update__( other )
-    other = Hash[*other] if other.__meta__.is_a?(Array)
-    other.each{ |k, v| @table[k] = v }
-  end
-
-  other.__meta__(:is_a?,Array)
-
-  other.meta(:is_a?,Array)
-
-  Meta[other].is_a?(Array)
-
-  other.as(Hash).is_a?(Array)
-
-  def __merge__( other )
-    o = __meta__.dup
-    o.__update__( other )
-    o
-  end
-
-end
-
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-
-=begin testing
-
-  require 'test/unit'
-
-  class MyOpenObject
-    include Open
-  end
-
-  class MyOpenObjectExtra
-    include Open
-    def x ; "x" ; end
-    def u ; "u#{x}" ; end
-  end
-
-  class TC01 < Test::Unit::TestCase
-    def setup
-      @o =  MyOpenObjectExtra.new
-    end
-
-    def test_01_001
-      assert_equal( "x", @o.__self__.x )
-    end
-    def test_01_002
-      assert_equal( "ux", @o.__self__.u )
-    end
-    def test_01_003
-      assert_equal( nil, @o.x )
-    end
-    def test_01_004
-      assert_equal( nil, @o.u )
-    end
-  end
-
-  class TC02 < Test::Unit::TestCase
-    def test_02_001
-      f0 = MyOpenObject.new
-      f0[:a] = 1
-      assert_equal( [1], f0.to_a )
-      assert_equal( {:a=>1}, f0.to_h )
-    end
-    def test_02_002
-      f0 = MyOpenObject.new( {:a=>1} )
-      f0[:b] = 2
-      assert_equal( {:a=>1,:b=>2}, f0.to_h )
-    end
-  end
-
-  class TC03 < Test::Unit::TestCase
-    def test_03_001
-      f0 = MyOpenObject.new( :f0=>"f0" )
-      h0 = { :h0=>"h0" }
-      assert_equal( MyOpenObject.new( :f0=>"f0", :h0=>"h0" ), f0.__merge__( h0 ) )
-      assert_equal( {:f0=>"f0", :h0=>"h0"}, h0.merge( f0 ) )
-    end
-    def test_03_002
-      f1 = MyOpenObject.new( :f1=>"f1" )
-      h1 = { :h1=>"h1" }
-      f1.__update__( h1 )
-      h1.update( f1 )
-      assert_equal( MyOpenObject.new( :f1=>"f1", :h1=>"h1" ), f1 )
-      assert_equal( {:f1=>"f1", :h1=>"h1"}, h1 )
-    end
-  end
-
-  class TC04 < Test::Unit::TestCase
-    def test_04_001
-      fo = MyOpenObject.new
-      10.times{ |i| fo.__send__( "n#{i}=", 1 ) }
-      10.times{ |i|
-        assert_equal( 1, fo.__send__( "n#{i}" ) )
-      }
-    end
-  end
-
-=end