mack-facets 0.8.2 → 0.8.3

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

@@ -1,106 +0,0 @@
-class LazyArray  # borrowed partially from StrokeDB
-  instance_methods.each { |m| undef_method m unless %w[ __id__ __send__ send dup class object_id kind_of? respond_to? assert_kind_of should should_not instance_variable_set instance_variable_get extend ].include?(m.to_s) }
-
-  include Enumerable
-
-  # these methods should return self or nil
-  RETURN_SELF = [ :<<, :clear, :concat, :collect!, :each, :each_index,
-    :each_with_index, :freeze, :insert, :map!, :push, :replace,
-    :reject!, :reverse!, :reverse_each, :sort!, :unshift ]
-
-  RETURN_SELF.each do |method|
-    class_eval <<-EOS, __FILE__, __LINE__
-      def #{method}(*args, &block)
-        lazy_load
-        results = @array.#{method}(*args, &block)
-        results.kind_of?(Array) ? self : results
-      end
-    EOS
-  end
-
-  (Array.public_instance_methods(false).map { |m| m.to_sym } - RETURN_SELF - [ :taguri= ]).each do |method|
-    class_eval <<-EOS, __FILE__, __LINE__
-      def #{method}(*args, &block)
-        lazy_load
-        @array.#{method}(*args, &block)
-      end
-    EOS
-  end
-
-  def replace(other)
-    mark_loaded
-    @array.replace(other.entries)
-    self
-  end
-
-  def clear
-    mark_loaded
-    @array.clear
-    self
-  end
-
-  def eql?(other)
-    lazy_load
-    @array.eql?(other.entries)
-  end
-
-  alias == eql?
-
-  def load_with(&block)
-    @load_with_proc = block
-    self
-  end
-
-  def loaded?
-    @loaded == true
-  end
-
-  def unload
-    clear
-    @loaded = false
-    self
-  end
-
-  def respond_to?(method, include_private = false)
-    super || @array.respond_to?(method, include_private)
-  end
-
-  def to_proc
-    @load_with_proc
-  end
-
-  private
-
-  def initialize(*args, &block)
-    @loaded         = false
-    @load_with_proc = proc { |v| v }
-    @array          = Array.new(*args, &block)
-  end
-
-  def initialize_copy(original)
-    @array = original.entries
-    load_with(&original)
-    mark_loaded if @array.any?
-  end
-
-  def lazy_load
-    return if loaded?
-    mark_loaded
-    @load_with_proc[self]
-  end
-
-  def mark_loaded
-    @loaded = true
-  end
-
-  # delegate any not-explicitly-handled methods to @array, if possible.
-  # this is handy for handling methods mixed-into Array like group_by
-  def method_missing(method, *args, &block)
-    if @array.respond_to?(method)
-      lazy_load
-      @array.send(method, *args, &block)
-    else
-      super
-    end
-  end
-end

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

@@ -1,202 +0,0 @@
-require "time" # httpdate
-# ==== Public Merb Logger API
-#
-# To replace an existing logger with a new one:
-#  Merb::Logger.set_log(log{String, IO},level{Symbol, String})
-#
-# Available logging levels are
-#   Merb::Logger::{ Fatal, Error, Warn, Info, Debug }
-#
-# Logging via:
-#   Merb.logger.fatal(message<String>,&block)
-#   Merb.logger.error(message<String>,&block)
-#   Merb.logger.warn(message<String>,&block)
-#   Merb.logger.info(message<String>,&block)
-#   Merb.logger.debug(message<String>,&block)
-#
-# Logging with autoflush:
-#   Merb.logger.fatal!(message<String>,&block)
-#   Merb.logger.error!(message<String>,&block)
-#   Merb.logger.warn!(message<String>,&block)
-#   Merb.logger.info!(message<String>,&block)
-#   Merb.logger.debug!(message<String>,&block)
-#
-# Flush the buffer to 
-#   Merb.logger.flush
-#
-# Remove the current log object
-#   Merb.logger.close
-# 
-# ==== Private Merb Logger API
-# 
-# To initialize the logger you create a new object, proxies to set_log.
-#   Merb::Logger.new(log{String, IO},level{Symbol, String})
-module Extlib
-
-  class << self
-    attr_accessor :logger
-  end
-
-  class Logger
-
-    attr_accessor :level
-    attr_accessor :delimiter
-    attr_accessor :auto_flush
-    attr_reader   :buffer
-    attr_reader   :log
-    attr_reader   :init_args
-
-    # ==== Notes
-    # Ruby (standard) logger levels:
-    # :fatal:: An unhandleable error that results in a program crash
-    # :error:: A handleable error condition
-    # :warn:: A warning
-    # :info:: generic (useful) information about system operation
-    # :debug:: low-level information for developers
-    Levels = 
-    {
-      :fatal => 7, 
-      :error => 6, 
-      :warn  => 4,
-      :info  => 3,
-      :debug => 0
-    }
-
-    private
-
-    # Readies a log for writing.
-    #
-    # ==== Parameters
-    # log<IO, String>:: Either an IO object or a name of a logfile.
-    def initialize_log(log)
-      close if @log # be sure that we don't leave open files laying around.
-
-      if log.respond_to?(:write)
-        @log = log
-      elsif File.exist?(log)
-        @log = open(log, (File::WRONLY | File::APPEND))
-        @log.sync = true
-      else
-        FileUtils.mkdir_p(File.dirname(log)) unless File.directory?(File.dirname(log))
-        @log = open(log, (File::WRONLY | File::APPEND | File::CREAT))
-        @log.sync = true
-        @log.write("#{Time.now.httpdate} #{delimiter} info #{delimiter} Logfile created\n")
-      end
-    end
-
-    public
-
-    # To initialize the logger you create a new object, proxies to set_log.
-    #
-    # ==== Parameters
-    # *args:: Arguments to create the log from. See set_logs for specifics.
-    def initialize(*args)
-      @init_args = args
-      set_log(*args)
-    end
-
-    # Replaces an existing logger with a new one.
-    # 
-    # ==== Parameters
-    # log<IO, String>:: Either an IO object or a name of a logfile.
-    # log_level<~to_sym>::
-    #   The log level from, e.g. :fatal or :info. Defaults to :error in the
-    #   production environment and :debug otherwise.
-    # delimiter<String>::
-    #   Delimiter to use between message sections. Defaults to " ~ ".
-    # auto_flush<Boolean>::
-    #   Whether the log should automatically flush after new messages are
-    #   added. Defaults to false.
-    def set_log(log, log_level = nil, delimiter = " ~ ", auto_flush = false)
-      if log_level && Levels[log_level.to_sym]
-        @level = Levels[log_level.to_sym]
-      elsif Merb.environment == "production"
-        @level = Levels[:warn]
-      else
-        @level = Levels[:debug]
-      end
-      @buffer     = []
-      @delimiter  = delimiter
-      @auto_flush = auto_flush
-
-      initialize_log(log)
-
-      Merb.logger = self
-    end
-
-    # Flush the entire buffer to the log object.
-    def flush
-      return unless @buffer.size > 0
-      @log.write(@buffer.slice!(0..-1).to_s)
-    end
-
-    # Close and remove the current log object.
-    def close
-      flush
-      @log.close if @log.respond_to?(:close) && !@log.tty?
-      @log = nil
-    end
-
-    # Appends a message to the log. The methods yield to an optional block and
-    # the output of this block will be appended to the message.
-    #
-    # ==== Parameters
-    # string<String>:: The message to be logged. Defaults to nil.
-    #
-    # ==== Returns
-    # String:: The resulting message added to the log file.
-    def <<(string = nil)
-      message = ""
-      message << delimiter
-      message << string if string
-      message << "\n" unless message[-1] == ?\n
-      @buffer << message
-      flush if @auto_flush
-
-      message
-    end
-    alias :push :<<
-
-    # Generate the logging methods for Merb.logger for each log level.
-    Levels.each_pair do |name, number|
-      class_eval <<-LEVELMETHODS, __FILE__, __LINE__
-
-      # Appends a message to the log if the log level is at least as high as
-      # the log level of the logger.
-      #
-      # ==== Parameters
-      # string<String>:: The message to be logged. Defaults to nil.
-      #
-      # ==== Returns
-      # self:: The logger object for chaining.
-      def #{name}(message = nil)
-        self << message if #{number} >= level
-        self
-      end
-
-      # Appends a message to the log if the log level is at least as high as
-      # the log level of the logger. The bang! version of the method also auto
-      # flushes the log buffer to disk.
-      #
-      # ==== Parameters
-      # string<String>:: The message to be logged. Defaults to nil.
-      #
-      # ==== Returns
-      # self:: The logger object for chaining.
-      def #{name}!(message = nil)
-        self << message if #{number} >= level
-        flush if #{number} >= level
-        self
-      end
-
-      # ==== Returns
-      # Boolean:: True if this level will be logged by this logger.
-      def #{name}?
-        #{number} >= level
-      end
-      LEVELMETHODS
-    end
-
-  end
-  
-end

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

@@ -1,148 +0,0 @@
-# This class has dubious semantics and we only have it so that people can write
-# params[:key] instead of params['key'].
-class Mash < Hash
-
-  # @param constructor<Object>
-  #   The default value for the mash. Defaults to an empty hash.
-  #
-  # @details [Alternatives]
-  #   If constructor is a Hash, a new mash will be created based on the keys of
-  #   the hash and no default value will be set.
-  def initialize(constructor = {})
-    if constructor.is_a?(Hash) 
-      super() 
-      update(constructor) 
-    else 
-      super(constructor) 
-    end 
-  end
-
-  # @param key<Object> The default value for the mash. Defaults to nil.
-  #
-  # @details [Alternatives]
-  #   If key is a Symbol and it is a key in the mash, then the default value will
-  #   be set to the value matching the key.
-  def default(key = nil) 
-    if key.is_a?(Symbol) && include?(key = key.to_s) 
-      self[key] 
-    else 
-      super 
-    end 
-  end 
- 
-  alias_method :regular_writer, :[]= unless method_defined?(:regular_writer) 
-  alias_method :regular_update, :update unless method_defined?(:regular_update)
-
-  # @param key<Object> The key to set.
-  # @param value<Object>
-  #   The value to set the key to.
-  #
-  # @see Mash#convert_key
-  # @see Mash#convert_value
-  def []=(key, value) 
-    regular_writer(convert_key(key), convert_value(value)) 
-  end
-
-  # @param other_hash<Hash>
-  #   A hash to update values in the mash with. The keys and the values will be
-  #   converted to Mash format.
-  #
-  # @return <Mash> The updated mash.
-  def update(other_hash) 
-    other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) } 
-    self 
-  end 
- 
-  alias_method :merge!, :update
-
-  # @param key<Object> The key to check for. This will be run through convert_key.
-  #
-  # @return <TrueClass, FalseClass> True if the key exists in the mash.
-  def key?(key) 
-    super(convert_key(key)) 
-  end 
-
-  # def include? def has_key? def member?
-  alias_method :include?, :key?
-  alias_method :has_key?, :key?
-  alias_method :member?, :key?
-
-  # @param key<Object> The key to fetch. This will be run through convert_key.
-  # @param *extras<Array> Default value.
-  #
-  # @return <Object> The value at key or the default value.
-  def fetch(key, *extras) 
-    super(convert_key(key), *extras) 
-  end
-
-  # @param *indices<Array>
-  #   The keys to retrieve values for. These will be run through +convert_key+.
-  #
-  # @return <Array> The values at each of the provided keys
-  def values_at(*indices) 
-    indices.collect {|key| self[convert_key(key)]} 
-  end
-
-  # @param hash<Hash> The hash to merge with the mash.
-  #
-  # @return <Mash> A new mash with the hash values merged in.
-  def merge(hash) 
-    self.dup.update(hash) 
-  end
-
-  # @param key<Object>
-  #   The key to delete from the mash.\
-  def delete(key) 
-    super(convert_key(key)) 
-  end
-
-  # @param *rejected<Array[(String, Symbol)] The mash keys to exclude.
-  #
-  # @return <Mash> A new mash without the selected keys.
-  #
-  # @example
-  #   { :one => 1, :two => 2, :three => 3 }.except(:one)
-  #     #=> { "two" => 2, "three" => 3 }
-  def except(*keys)
-    super(*keys.map {|k| convert_key(k)})
-  end
-
-  # Used to provide the same interface as Hash.
-  #
-  # @return <Mash> This mash unchanged.
-  def stringify_keys!; self end
- 
-  # @return <Hash> The mash as a Hash with string keys.
-  def to_hash 
-    Hash.new(default).merge(self) 
-  end 
- 
-  protected
-  # @param key<Object> The key to convert.
-  #
-  # @param <Object>
-  #   The converted key. If the key was a symbol, it will be converted to a
-  #   string.
-  #
-  # @api private
-  def convert_key(key) 
-    key.kind_of?(Symbol) ? key.to_s : key 
-  end
-
-  # @param value<Object> The value to convert.
-  #
-  # @return <Object>
-  #   The converted value. A Hash or an Array of hashes, will be converted to
-  #   their Mash equivalents.
-  #
-  # @api private
-  def convert_value(value) 
-    if value.class == Hash
-      value.to_mash 
-    elsif value.is_a?(Array)
-      value.collect { |e| convert_value(e) } 
-    else
-      value
-    end 
-  end
-end