mack-facets 0.8.2 → 0.8.3

data/lib/gems/extlib-0.9.8/lib/extlib.rb

@@ -1,56 +0,0 @@
-require 'pathname'
-require 'rubygems'
-
-__DIR__ = File.expand_path(File.dirname(__FILE__))
-$LOAD_PATH.unshift(__DIR__) unless $LOAD_PATH.include?(__DIR__)
-
-# for Pathname /
-require File.expand_path(File.join(__DIR__, 'extlib', 'pathname'))
-
-dir = Pathname(__FILE__).dirname.expand_path / 'extlib'
-
-require dir / "class.rb"
-require dir / "object"
-require dir / "object_space"
-
-require dir / "string"
-require dir / "symbol"
-require dir / "hash"
-require dir / "mash"
-require dir / "virtual_file"
-require dir / "logger"
-require dir / "time"
-require dir / "datetime"
-
-require dir / 'assertions'
-require dir / 'blank'
-require dir / 'boolean'
-require dir / 'inflection'
-require dir / 'lazy_array'
-require dir / 'module'
-require dir / 'nil'
-require dir / 'numeric'
-require dir / 'blank'
-require dir / 'simple_set'
-require dir / 'struct'
-require dir / 'symbol'
-
-Extlib.autoload("Hook", (dir / 'hook').to_s)
-Extlib.autoload("Pooling", (dir / 'pooling').to_s)
-
-module Extlib
-
-  def self.exiting= bool
-    if bool && Extlib.const_defined?("Pooling")
-      if Extlib::Pooling.scavenger?
-        Extlib::Pooling.scavenger.wakeup
-      end
-    end
-    @exiting = true
-  end
-
-  def self.exiting
-    @exiting
-  end
-
-end

data/lib/gems/extlib-0.9.8/lib/extlib/blank.rb

@@ -1,59 +0,0 @@
-class Object
-  # @return <TrueClass, FalseClass>
-  #
-  # @example [].blank?         #=>  true
-  # @example [1].blank?        #=>  false
-  # @example [nil].blank?      #=>  false
-  # 
-  # Returns true if the object is nil or empty (if applicable)
-  def blank?
-    nil? || (respond_to?(:empty?) && empty?)
-  end
-end # class Object
-
-class Numeric
-  # @return <TrueClass, FalseClass>
-  # 
-  # Numerics can't be blank
-  def blank?
-    false
-  end
-end # class Numeric
-
-class NilClass
-  # @return <TrueClass, FalseClass>
-  # 
-  # Nils are always blank
-  def blank?
-    true
-  end
-end # class NilClass
-
-class TrueClass
-  # @return <TrueClass, FalseClass>
-  # 
-  # True is not blank.  
-  def blank?
-    false
-  end
-end # class TrueClass
-
-class FalseClass
-  # False is always blank.
-  def blank?
-    true
-  end
-end # class FalseClass
-
-class String
-  # @example "".blank?         #=>  true
-  # @example "     ".blank?    #=>  true
-  # @example " hey ho ".blank? #=>  false
-  # 
-  # @return <TrueClass, FalseClass>
-  # 
-  # Strips out whitespace then tests if the string is empty.
-  def blank?
-    strip.empty?
-  end
-end # class String

data/lib/gems/extlib-0.9.8/lib/extlib/boolean.rb

@@ -1,11 +0,0 @@
-class TrueClass
-  def try_dup
-    self
-  end
-end
-
-class FalseClass
-  def try_dup
-    self
-  end
-end

data/lib/gems/extlib-0.9.8/lib/extlib/class.rb

@@ -1,175 +0,0 @@
-# Copyright (c) 2004-2008 David Heinemeier Hansson
-# 
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-# 
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-# 
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-# Allows attributes to be shared within an inheritance hierarchy, but where
-# each descendant gets a copy of their parents' attributes, instead of just a
-# pointer to the same. This means that the child can add elements to, for
-# example, an array without those additions being shared with either their
-# parent, siblings, or children, which is unlike the regular class-level
-# attributes that are shared across the entire hierarchy.
-class Class
-  # Defines class-level and instance-level attribute reader.
-  #
-  # @param *syms<Array> Array of attributes to define reader for.
-  # @return <Array[#to_s]> List of attributes that were made into cattr_readers
-  #
-  # @api public
-  #
-  # @todo Is this inconsistent in that it does not allow you to prevent
-  #   an instance_reader via :instance_reader => false
-  def cattr_reader(*syms)
-    syms.flatten.each do |sym|
-      next if sym.is_a?(Hash)
-      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-        unless defined? @@#{sym}
-          @@#{sym} = nil
-        end
-
-        def self.#{sym}
-          @@#{sym}
-        end
-
-        def #{sym}
-          @@#{sym}
-        end
-      RUBY
-    end
-  end
-
-  # Defines class-level (and optionally instance-level) attribute writer.
-  #
-  # @param <Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to define writer for.
-  # @option syms :instance_writer<Boolean> if true, instance-level attribute writer is defined.
-  # @return <Array[#to_s]> List of attributes that were made into cattr_writers
-  #
-  # @api public
-  def cattr_writer(*syms)
-    options = syms.last.is_a?(Hash) ? syms.pop : {}
-    syms.flatten.each do |sym|
-      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-        unless defined? @@#{sym}
-          @@#{sym} = nil
-        end
-
-        def self.#{sym}=(obj)
-          @@#{sym} = obj
-        end
-      RUBY
-      
-      unless options[:instance_writer] == false
-        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-          def #{sym}=(obj)
-            @@#{sym} = obj
-          end
-        RUBY
-      end
-    end
-  end
-
-  # Defines class-level (and optionally instance-level) attribute accessor.
-  #
-  # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to define accessor for.
-  # @option syms :instance_writer<Boolean> if true, instance-level attribute writer is defined.
-  # @return <Array[#to_s]> List of attributes that were made into accessors
-  #
-  # @api public
-  def cattr_accessor(*syms)
-    cattr_reader(*syms)
-    cattr_writer(*syms)
-  end
-
-  # Defines class-level inheritable attribute reader. Attributes are available to subclasses,
-  # each subclass has a copy of parent's attribute.
-  #
-  # @param *syms<Array[#to_s]> Array of attributes to define inheritable reader for.
-  # @return <Array[#to_s]> Array of attributes converted into inheritable_readers.
-  #
-  # @api public
-  #
-  # @todo Do we want to block instance_reader via :instance_reader => false
-  # @todo It would be preferable that we do something with a Hash passed in
-  #   (error out or do the same as other methods above) instead of silently
-  #   moving on). In particular, this makes the return value of this function
-  #   less useful.
-  def class_inheritable_reader(*ivars)
-    instance_reader = ivars.pop[:reader] if ivars.last.is_a?(Hash)
-    
-    ivars.each do |ivar|
-      self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def self.#{ivar}
-          return @#{ivar} if self == #{self} || defined?(@#{ivar})
-          ivar = superclass.#{ivar}
-          return nil if ivar.nil? && !#{self}.instance_variable_defined?("@#{ivar}")
-          @#{ivar} = ivar && !ivar.is_a?(Module) && !ivar.is_a?(Numeric) ? ivar.dup : ivar
-        end
-      RUBY
-      unless instance_reader == false
-        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def #{ivar}
-            self.class.#{ivar}
-          end
-        RUBY
-      end
-    end
-  end
-  
-  # Defines class-level inheritable attribute writer. Attributes are available to subclasses,
-  # each subclass has a copy of parent's attribute.
-  #
-  # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to
-  #   define inheritable writer for.
-  # @option syms :instance_writer<Boolean> if true, instance-level inheritable attribute writer is defined.
-  # @return <Array[#to_s]> An Array of the attributes that were made into inheritable writers.
-  #
-  # @api public
-  #
-  # @todo We need a style for class_eval <<-HEREDOC. I'd like to make it 
-  #   class_eval(<<-RUBY, __FILE__, __LINE__), but we should codify it somewhere.
-  def class_inheritable_writer(*ivars)
-    instance_writer = ivars.pop[:instance_writer] if ivars.last.is_a?(Hash)
-    ivars.each do |ivar|
-      self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def self.#{ivar}=(obj)
-          @#{ivar} = obj        
-        end
-      RUBY
-      unless instance_writer == false
-        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def #{ivar}=(obj) self.class.#{ivar} = obj end
-        RUBY
-      end
-    end
-  end
-  
-  # Defines class-level inheritable attribute accessor. Attributes are available to subclasses,
-  # each subclass has a copy of parent's attribute.
-  #
-  # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to 
-  #   define inheritable accessor for.
-  # @option syms :instance_writer<Boolean> if true, instance-level inheritable attribute writer is defined.
-  # @return <Array[#to_s]> An Array of attributes turned into inheritable accessors.
-  #
-  # @api public
-  def class_inheritable_accessor(*syms)
-    class_inheritable_reader(*syms)
-    class_inheritable_writer(*syms)
-  end
-end

data/lib/gems/extlib-0.9.8/lib/extlib/datetime.rb

@@ -1,9 +0,0 @@
-class DateTime
-  def to_time
-    Time.parse self.to_s
-  end
-  
-  def to_datetime
-    self
-  end
-end

data/lib/gems/extlib-0.9.8/lib/extlib/dictionary.rb

@@ -1,433 +0,0 @@
-# TITLE:
-#
-#   Dictionary
-#
-# AUTHORS:
-#
-#   - Jan Molic
-#   - Thomas Sawyer
-#
-# CREDIT:
-#
-#   - Andrew Johnson (merge, to_a, inspect, shift and Hash[])
-#   - Jeff Sharpe    (reverse and reverse!)
-#   - Thomas Leitner (has_key? and key?)
-#
-# LICENSE:
-#
-#   Copyright (c) 2005 Jan Molic, 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.
-#
-#   Originally ported from OrderHash 2.0, Copyright (c) 2005 jan molic
-#
-# LOG:
-#
-#   - 2007.10.31 trans
-#     Fixed initialize so the constructor blocks correctly effected dictionary
-#     rather then just the internal hash.
-
-# = Dictionary
-#
-# The Dictionary class is a Hash that preserves order.
-# So it has some array-like extensions also. By defualt
-# a Dictionary object preserves insertion order, but any
-# order can be specified including alphabetical key order.
-#
-# == Usage
-#
-# Just require this file and use Dictionary instead of Hash.
-#
-#   # You can do simply
-#   hsh = Dictionary.new
-#   hsh['z'] = 1
-#   hsh['a'] = 2
-#   hsh['c'] = 3
-#   p hsh.keys     #=> ['z','a','c']
-#
-#   # or using Dictionary[] method
-#   hsh = Dictionary['z', 1, 'a', 2, 'c', 3]
-#   p hsh.keys     #=> ['z','a','c']
-#
-#   # but this doesn't preserve order
-#   hsh = Dictionary['z'=>1, 'a'=>2, 'c'=>3]
-#   p hsh.keys     #=> ['a','c','z']
-#
-#   # Dictionary has useful extensions: push, pop and unshift
-#   p hsh.push('to_end', 15)       #=> true, key added
-#   p hsh.push('to_end', 30)       #=> false, already - nothing happen
-#   p hsh.unshift('to_begin', 50)  #=> true, key added
-#   p hsh.unshift('to_begin', 60)  #=> false, already - nothing happen
-#   p hsh.keys                     #=> ["to_begin", "a", "c", "z", "to_end"]
-#   p hsh.pop                      #=> ["to_end", 15], if nothing remains, return nil
-#   p hsh.keys                     #=> ["to_begin", "a", "c", "z"]
-#   p hsh.shift                    #=> ["to_begin", 30], if nothing remains, return nil
-#
-# == Usage Notes
-#
-# * You can use #order_by to set internal sort order.
-# * #<< takes a two element [k,v] array and inserts.
-# * Use ::auto which creates Dictionay sub-entries as needed.
-# * And ::alpha which creates a new Dictionary sorted by key.
-
-class Dictionary
-
-  include Enumerable
-
-  class << self
-    #--
-    # TODO is this needed? Doesn't the super class do this?
-    #++
-    def [](*args)
-      hsh = new
-      if Hash === args[0]
-        hsh.replace(args[0])
-      elsif (args.size % 2) != 0
-        raise ArgumentError, "odd number of elements for Hash"
-      else
-        while !args.empty?
-          hsh[args.shift] = args.shift
-        end
-      end
-      hsh
-    end
-
-    # Like #new but the block sets the order.
-    #
-    def new_by(*args, &blk)
-      new(*args).order_by(&blk)
-    end
-
-    # Alternate to #new which creates a dictionary sorted by key.
-    #
-    #   d = Dictionary.alpha
-    #   d["z"] = 1
-    #   d["y"] = 2
-    #   d["x"] = 3
-    #   d  #=> {"x"=>3,"y"=>2,"z"=>2}
-    #
-    # This is equivalent to:
-    #
-    #   Dictionary.new.order_by { |key,value| key }
-    def alpha(*args, &block)
-      new(*args, &block).order_by_key
-    end
-
-    # Alternate to #new which auto-creates sub-dictionaries as needed.
-    #
-    #   d = Dictionary.auto
-    #   d["a"]["b"]["c"] = "abc"  #=> { "a"=>{"b"=>{"c"=>"abc"}}}
-    #
-    def auto(*args)
-      #AutoDictionary.new(*args)
-      leet = lambda { |hsh, key| hsh[key] = new(&leet) }
-      new(*args, &leet)
-    end
-  end
-
-   # New Dictiionary.
-  def initialize(*args, &blk)
-    @order = []
-    @order_by = nil
-    if blk
-      dict = self                                  # This ensure autmatic key entry effect the
-      oblk = lambda{ |hsh, key| blk[dict,key] }    # dictionary rather then just the interal hash.
-      @hash = Hash.new(*args, &oblk)
-    else
-      @hash = Hash.new(*args)
-    end
-  end
-
-  def order
-    reorder if @order_by
-    @order
-  end
-
-  # Keep dictionary sorted by a specific sort order.
-  def order_by( &block )
-    @order_by = block
-    order
-    self
-  end
-
-  # Keep dictionary sorted by key.
-  #
-  #   d = Dictionary.new.order_by_key
-  #   d["z"] = 1
-  #   d["y"] = 2
-  #   d["x"] = 3
-  #   d  #=> {"x"=>3,"y"=>2,"z"=>2}
-  #
-  # This is equivalent to:
-  #
-  #   Dictionary.new.order_by { |key,value| key }
-  #
-  # The initializer Dictionary#alpha also provides this.
-  def order_by_key
-    @order_by = lambda { |k,v| k }
-    order
-    self
-  end
-
-  # Keep dictionary sorted by value.
-  #
-  #   d = Dictionary.new.order_by_value
-  #   d["z"] = 1
-  #   d["y"] = 2
-  #   d["x"] = 3
-  #   d  #=> {"x"=>3,"y"=>2,"z"=>2}
-  #
-  # This is equivalent to:
-  #
-  #   Dictionary.new.order_by { |key,value| value }
-  def order_by_value
-    @order_by = lambda { |k,v| v }
-    order
-    self
-  end
-
-  #
-  def reorder
-    if @order_by
-      assoc = @order.collect{ |k| [k,@hash[k]] }.sort_by(&@order_by)
-      @order = assoc.collect{ |k,v| k }
-    end
-    @order
-  end
-
-  def ==(hsh2)
-    if hsh2.is_a?( Dictionary )
-      @order == hsh2.order &&
-      @hash  == hsh2.instance_variable_get("@hash")
-    else
-      false
-    end
-  end
-
-  def [] k
-    @hash[ k ]
-  end
-
-  def fetch(k, *a, &b)
-    @hash.fetch(k, *a, &b)
-  end
-
-  # Store operator.
-  #
-  #   h[key] = value
-  #
-  # Or with additional index.
-  #
-  #  h[key,index] = value
-  def []=(k, i=nil, v=nil)
-    if v
-      insert(i,k,v)
-    else
-      store(k,i)
-    end
-  end
-
-  def insert( i,k,v )
-    @order.insert( i,k )
-    @hash.store( k,v )
-  end
-
-  def store( a,b )
-    @order.push( a ) unless @hash.has_key?( a )
-    @hash.store( a,b )
-  end
-
-  def clear
-    @order = []
-    @hash.clear
-  end
-
-  def delete( key )
-    @order.delete( key )
-    @hash.delete( key )
-  end
-
-  def each_key
-    order.each { |k| yield( k ) }
-    self
-  end
-
-  def each_value
-    order.each { |k| yield( @hash[k] ) }
-    self
-  end
-
-  def each
-    order.each { |k| yield( k,@hash[k] ) }
-    self
-  end
-  alias each_pair each
-
-  def delete_if
-    order.clone.each { |k| delete k if yield(k,@hash[k]) }
-    self
-  end
-
-  def values
-    ary = []
-    order.each { |k| ary.push @hash[k] }
-    ary
-  end
-
-  def keys
-    order
-  end
-
-  def invert
-    hsh2 = self.class.new
-    order.each { |k| hsh2[@hash[k]] = k }
-    hsh2
-  end
-
-  def reject( &block )
-    self.dup.delete_if(&block)
-  end
-
-  def reject!( &block )
-    hsh2 = reject(&block)
-    self == hsh2 ? nil : hsh2
-  end
-
-  def replace( hsh2 )
-    @order = hsh2.order
-    @hash = hsh2.hash
-  end
-
-  def shift
-    key = order.first
-    key ? [key,delete(key)] : super
-  end
-
-  def unshift( k,v )
-    unless @hash.include?( k )
-      @order.unshift( k )
-      @hash.store( k,v )
-      true
-    else
-      false
-    end
-  end
-
-  def <<(kv)
-    push( *kv )
-  end
-
-  def push( k,v )
-    unless @hash.include?( k )
-      @order.push( k )
-      @hash.store( k,v )
-      true
-    else
-      false
-    end
-  end
-
-  def pop
-    key = order.last
-    key ? [key,delete(key)] : nil
-  end
-
-  def inspect
-    ary = []
-    each {|k,v| ary << k.inspect + "=>" + v.inspect}
-    '{' + ary.join(", ") + '}'
-  end
-
-  def dup
-    a = []
-    each{ |k,v| a << k; a << v }
-    self.class[*a]
-  end
-
-  def update( hsh2 )
-    hsh2.each { |k,v| self[k] = v }
-    reorder
-    self
-  end
-  alias :merge! update
-
-  def merge( hsh2 )
-    self.dup.update(hsh2)
-  end
-
-  def select
-    ary = []
-    each { |k,v| ary << [k,v] if yield k,v }
-    ary
-  end
-
-  def reverse!
-    @order.reverse!
-    self
-  end
-
-  def reverse
-    dup.reverse!
-  end
-
-  def first
-    @hash[order.first]
-  end
-
-  def last
-    @hash[order.last]
-  end
-
-  def length
-    @order.length
-  end
-  alias :size :length
-
-  def empty?
-    @hash.empty?
-  end
-
-  def has_key?(key)
-    @hash.has_key?(key)
-  end
-
-  def key?(key)
-    @hash.key?(key)
-  end
-
-  def to_a
-    ary = []
-    each { |k,v| ary << [k,v] }
-    ary
-  end
-  
-  def to_json
-    buf = "["
-    map do |k,v|
-      buf << k.to_json
-      buf << ", "
-      buf << v.to_json
-    end.join(", ")
-    buf << "]"
-    buf
-  end
-
-  def to_s
-    self.to_a.to_s
-  end
-
-  def to_hash
-    @hash.dup
-  end
-
-  def to_h
-    @hash.dup
-  end
-end