ardm 0.0.1

data/lib/ardm/support/lazy_array.rb

@@ -0,0 +1,451 @@
+class LazyArray  # borrowed partially from StrokeDB
+  include Enumerable
+
+  attr_reader :head, :tail
+
+  def first(*args)
+    if lazy_possible?(@head, *args)
+      @head.first(*args)
+    else
+      lazy_load
+      @array.first(*args)
+    end
+  end
+
+  def last(*args)
+    if lazy_possible?(@tail, *args)
+      @tail.last(*args)
+    else
+      lazy_load
+      @array.last(*args)
+    end
+  end
+
+  def at(index)
+    if index >= 0 && lazy_possible?(@head, index + 1)
+      @head.at(index)
+    elsif index < 0 && lazy_possible?(@tail, index.abs)
+      @tail.at(index)
+    else
+      lazy_load
+      @array.at(index)
+    end
+  end
+
+  def fetch(*args, &block)
+    index = args.first
+
+    if index >= 0 && lazy_possible?(@head, index + 1)
+      @head.fetch(*args, &block)
+    elsif index < 0 && lazy_possible?(@tail, index.abs)
+      @tail.fetch(*args, &block)
+    else
+      lazy_load
+      @array.fetch(*args, &block)
+    end
+  end
+
+  def values_at(*args)
+    accumulator = []
+
+    lazy_possible = args.all? do |arg|
+      index, length = extract_slice_arguments(arg)
+
+      if index >= 0 && lazy_possible?(@head, index + length)
+        accumulator.concat(head.values_at(*arg))
+      elsif index < 0 && lazy_possible?(@tail, index.abs)
+        accumulator.concat(tail.values_at(*arg))
+      end
+    end
+
+    if lazy_possible
+      accumulator
+    else
+      lazy_load
+      @array.values_at(*args)
+    end
+  end
+
+  def index(entry)
+    (lazy_possible?(@head) && @head.index(entry)) || begin
+      lazy_load
+      @array.index(entry)
+    end
+  end
+
+  def include?(entry)
+    (lazy_possible?(@tail) && @tail.include?(entry)) ||
+    (lazy_possible?(@head) && @head.include?(entry)) || begin
+      lazy_load
+      @array.include?(entry)
+    end
+  end
+
+  def empty?
+    (@tail.nil? || @tail.empty?) &&
+    (@head.nil? || @head.empty?) && begin
+      lazy_load
+      @array.empty?
+    end
+  end
+
+  def any?(&block)
+    (lazy_possible?(@tail) && @tail.any?(&block)) ||
+    (lazy_possible?(@head) && @head.any?(&block)) || begin
+      lazy_load
+      @array.any?(&block)
+    end
+  end
+
+  def [](*args)
+    index, length = extract_slice_arguments(*args)
+
+    if length == 1 && args.size == 1 && args.first.kind_of?(Integer)
+      return at(index)
+    end
+
+    if index >= 0 && lazy_possible?(@head, index + length)
+      @head[*args]
+    elsif index < 0 && lazy_possible?(@tail, index.abs - 1 + length)
+      @tail[*args]
+    else
+      lazy_load
+      @array[*args]
+    end
+  end
+
+  alias_method :slice, :[]
+
+  def slice!(*args)
+    index, length = extract_slice_arguments(*args)
+
+    if index >= 0 && lazy_possible?(@head, index + length)
+      @head.slice!(*args)
+    elsif index < 0 && lazy_possible?(@tail, index.abs - 1 + length)
+      @tail.slice!(*args)
+    else
+      lazy_load
+      @array.slice!(*args)
+    end
+  end
+
+  def []=(*args)
+    index, length = extract_slice_arguments(*args[0..-2])
+
+    if index >= 0 && lazy_possible?(@head, index + length)
+      @head.[]=(*args)
+    elsif index < 0 && lazy_possible?(@tail, index.abs - 1 + length)
+      @tail.[]=(*args)
+    else
+      lazy_load
+      @array.[]=(*args)
+    end
+  end
+
+  alias_method :splice, :[]=
+
+  def reverse
+    dup.reverse!
+  end
+
+  def reverse!
+    # reverse without kicking if possible
+    if loaded?
+      @array = @array.reverse
+    else
+      @head, @tail = @tail.reverse, @head.reverse
+
+      proc = @load_with_proc
+
+      @load_with_proc = lambda do |v|
+        proc.call(v)
+        v.instance_variable_get(:@array).reverse!
+      end
+    end
+
+    self
+  end
+
+  def <<(entry)
+    if loaded?
+      lazy_load
+      @array << entry
+    else
+      @tail << entry
+    end
+    self
+  end
+
+  def concat(other)
+    if loaded?
+      lazy_load
+      @array.concat(other)
+    else
+      @tail.concat(other)
+    end
+    self
+  end
+
+  def push(*entries)
+    if loaded?
+      lazy_load
+      @array.push(*entries)
+    else
+      @tail.push(*entries)
+    end
+    self
+  end
+
+  def unshift(*entries)
+    if loaded?
+      lazy_load
+      @array.unshift(*entries)
+    else
+      @head.unshift(*entries)
+    end
+    self
+  end
+
+  def insert(index, *entries)
+    if index >= 0 && lazy_possible?(@head, index)
+      @head.insert(index, *entries)
+    elsif index < 0 && lazy_possible?(@tail, index.abs - 1)
+      @tail.insert(index, *entries)
+    else
+      lazy_load
+      @array.insert(index, *entries)
+    end
+    self
+  end
+
+  def pop(*args)
+    if lazy_possible?(@tail, *args)
+      @tail.pop(*args)
+    else
+      lazy_load
+      @array.pop(*args)
+    end
+  end
+
+  def shift(*args)
+    if lazy_possible?(@head, *args)
+      @head.shift(*args)
+    else
+      lazy_load
+      @array.shift(*args)
+    end
+  end
+
+  def delete_at(index)
+    if index >= 0 && lazy_possible?(@head, index + 1)
+      @head.delete_at(index)
+    elsif index < 0 && lazy_possible?(@tail, index.abs)
+      @tail.delete_at(index)
+    else
+      lazy_load
+      @array.delete_at(index)
+    end
+  end
+
+  def delete_if(&block)
+    if loaded?
+      lazy_load
+      @array.delete_if(&block)
+    else
+      @reapers << block
+      @head.delete_if(&block)
+      @tail.delete_if(&block)
+    end
+    self
+  end
+
+  def replace(other)
+    mark_loaded
+    @array.replace(other)
+    self
+  end
+
+  def clear
+    mark_loaded
+    @array.clear
+    self
+  end
+
+  def to_a
+    lazy_load
+    @array.to_a
+  end
+
+  alias_method :to_ary, :to_a
+
+  def load_with(&block)
+    @load_with_proc = block
+    self
+  end
+
+  def loaded?
+    @loaded == true
+  end
+
+  def kind_of?(klass)
+    super || @array.kind_of?(klass)
+  end
+
+  alias_method :is_a?, :kind_of?
+
+  def respond_to?(method, include_private = false)
+    super || @array.respond_to?(method)
+  end
+
+  def freeze
+    if loaded?
+      @array.freeze
+    else
+      @head.freeze
+      @tail.freeze
+    end
+    @frozen = true
+    self
+  end
+
+  def frozen?
+    @frozen == true
+  end
+
+  def ==(other)
+    if equal?(other)
+      return true
+    end
+
+    unless other.respond_to?(:to_ary)
+      return false
+    end
+
+    # if necessary, convert to something that can be compared
+    other = other.to_ary unless other.respond_to?(:[])
+
+    cmp?(other, :==)
+  end
+
+  def eql?(other)
+    if equal?(other)
+      return true
+    end
+
+    unless other.class.equal?(self.class)
+      return false
+    end
+
+    cmp?(other, :eql?)
+  end
+
+  def lazy_possible?(list, need_length = 1)
+    !loaded? && need_length <= list.size
+  end
+
+  private
+
+  def initialize
+    @frozen         = false
+    @loaded         = false
+    @load_with_proc = lambda { |v| v }
+    @head           = []
+    @tail           = []
+    @array          = []
+    @reapers        = []
+  end
+
+  def initialize_copy(original)
+    @head  = Ardm::Ext.try_dup(@head)
+    @tail  = Ardm::Ext.try_dup(@tail)
+    @array = Ardm::Ext.try_dup(@array)
+  end
+
+  def lazy_load
+    return if loaded?
+    mark_loaded
+    @load_with_proc[self]
+    @array.unshift(*@head)
+    @array.concat(@tail)
+    @head = @tail = nil
+    @reapers.each { |r| @array.delete_if(&r) } if @reapers
+    @array.freeze if frozen?
+  end
+
+  def mark_loaded
+    @loaded = true
+  end
+
+  ##
+  # Extract arguments for #slice an #slice! and return index and length
+  #
+  # @param [Integer, Array(Integer), Range] *args the index,
+  #   index and length, or range indicating first and last position
+  #
+  # @return [Integer] the index
+  # @return [Integer,NilClass] the length, if any
+  #
+  # @api private
+  def extract_slice_arguments(*args)
+    first_arg, second_arg = args
+
+    if args.size == 2 && first_arg.kind_of?(Integer) && second_arg.kind_of?(Integer)
+      return first_arg, second_arg
+    elsif args.size == 1
+      if first_arg.kind_of?(Integer)
+        return first_arg, 1
+      elsif first_arg.kind_of?(Range)
+        index = first_arg.first
+        length  = first_arg.last - index
+        length += 1 unless first_arg.exclude_end?
+        return index, length
+      end
+    end
+
+    raise ArgumentError, "arguments may be 1 or 2 Integers, or 1 Range object, was: #{args.inspect}", caller(1)
+  end
+
+  def each
+    lazy_load
+    if block_given?
+      @array.each { |entry| yield entry }
+      self
+    else
+      @array.each
+    end
+  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
+      results = @array.send(method, *args, &block)
+      results.equal?(@array) ? self : results
+    else
+      super
+    end
+  end
+
+  def cmp?(other, operator)
+    unless loaded?
+      # compare the head against the beginning of other.  start at index
+      # 0 and incrementally compare each entry. if other is a LazyArray
+      # this has a lesser likelyhood of triggering a lazy load
+      0.upto(@head.size - 1) do |i|
+        return false unless @head[i].__send__(operator, other[i])
+      end
+
+      # compare the tail against the end of other.  start at index
+      # -1 and decrementally compare each entry. if other is a LazyArray
+      # this has a lesser likelyhood of triggering a lazy load
+      -1.downto(@tail.size * -1) do |i|
+        return false unless @tail[i].__send__(operator, other[i])
+      end
+
+      lazy_load
+    end
+
+    @array.send(operator, other.to_ary)
+  end
+end

data/lib/ardm/support/local_object_space.rb

@@ -0,0 +1,13 @@
+module Ardm
+  module LocalObjectSpace
+    def self.extended(klass)
+      (class << klass; self; end).send :attr_accessor, :hook_scopes
+      klass.hook_scopes = []
+      super
+    end
+
+    def object_by_id(object_id)
+      self.hook_scopes.detect { |object| object.object_id == object_id }
+    end
+  end
+end

data/lib/ardm/support/logger.rb

@@ -0,0 +1,201 @@
+# ==== Public Ardm Logger API
+#
+# To replace an existing logger with a new one:
+#  Ardm::Logger.set_log(log{String, IO},level{Symbol, String})
+#
+# Available logging levels are
+#   Ardm::Logger::{ Fatal, Error, Warn, Info, Debug }
+#
+# Logging via:
+#   Ardm.logger.fatal(message<String>,&block)
+#   Ardm.logger.error(message<String>,&block)
+#   Ardm.logger.warn(message<String>,&block)
+#   Ardm.logger.info(message<String>,&block)
+#   Ardm.logger.debug(message<String>,&block)
+#
+# Logging with autoflush:
+#   Ardm.logger.fatal!(message<String>,&block)
+#   Ardm.logger.error!(message<String>,&block)
+#   Ardm.logger.warn!(message<String>,&block)
+#   Ardm.logger.info!(message<String>,&block)
+#   Ardm.logger.debug!(message<String>,&block)
+#
+# Flush the buffer to
+#   Ardm.logger.flush
+#
+# Remove the current log object
+#   Ardm.logger.close
+#
+# ==== Private Ardm Logger API
+#
+# To initialize the logger you create a new object, proxies to set_log.
+#   Ardm::Logger.new(log{String, IO},level{Symbol, String})
+module Ardm
+
+  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)
+      self.auto_flush = true
+      Ardm.logger = self
+    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]
+      else
+        @level = Levels[:debug]
+      end
+      @buffer     = []
+      @delimiter  = delimiter
+      @auto_flush = auto_flush
+
+      initialize_log(log)
+    end
+
+    # Flush the entire buffer to the log object.
+    def flush
+      return unless @buffer.size > 0
+      to_flush = @buffer
+      @buffer = []
+      @log.write(to_flush.join)
+    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_method :push, :<<
+
+    # Generate the logging methods for Ardm.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