mega 0.3.1

data/lib/mega/lru_cache.rb

@@ -0,0 +1,160 @@
+#--
+# LRUCache
+#
+# Copyright (c) 2004-2005 Navel
+#
+# 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.05.10  0.1   Trans   * Added to Facets
+# ============================================================================
+#++
+
+# :title: Least Recently Used Cache
+#
+# A cache utilizing a simple LRU (Least Recently Used) policy.
+# The items managed by this cache must respond to the #key method.
+# Attempts to optimize reads rather than inserts!
+#
+# LRU semantics are enforced by inserting the items in a queue.
+# The lru item is always at the tail. Two special sentinels
+# (head, tail) are used to simplify (?) the code.
+#
+# == Usage
+#
+#   TODO: If you have an example of using this, please submit. -T
+#
+# == Author(s)
+#
+# * George Moschovitis  <gm@navel.gr>
+# * Anastasios Koutoumanos  <ak@navel.gr>
+#
+
+class LRUCache < Hash
+
+  # Mix this in your class to make LRU-managable.
+
+  module Item
+    attr_accessor :lru_key, :lru_prev, :lru_next
+  end
+
+  # head-tail sentinels
+
+  class Sentinel; include Item; end
+
+  # the maximum number of items in the cache.
+
+  attr_accessor :max_items
+
+  # the head sentinel and the tail sentinel, tail.prev points to the lru item.
+
+  attr_reader :head, :tail
+
+  def initialize(max_items)
+    @max_items = max_items
+    lru_clear()
+  end
+
+  # Lookup an item in the cache.
+
+  def [](key)
+    if item = super
+      return lru_touch(item)
+    end
+  end
+
+  # The inserted item is considered mru!
+
+  def []=(key, item)
+    item = super
+    item.lru_key = key
+    lru_insert(item)
+  end
+
+  # Delete an item from the cache.
+
+  def delete(key)
+    if item = super
+      lru_delete(item)
+    end
+  end
+
+  # Clear the cache.
+
+  def clear
+    super
+    lru_clear()
+  end
+
+  # The first (mru) element in the cache.
+
+  def first
+    @head.lru_next
+  end
+
+  # The last (lru) element in the cache.
+
+  def last
+    @tail.lru_prev
+  end
+  alias_method :lru, :last
+
+  private
+
+  # Delete an item from the lru list.
+
+  def lru_delete(item)
+    lru_join(item.lru_prev, item.lru_next)
+    return item
+  end
+
+  # Join two items in the lru list.
+  # Return y to allow for chaining.
+
+  def lru_join(x, y)
+    x.lru_next = y
+    y.lru_prev = x
+    return y
+  end
+
+  # Append a child item to a parent item in the lru list
+  # (Re)inserts the child in the list.
+
+  def lru_append(parent, child)
+    lru_join(child, parent.lru_next)
+    lru_join(parent, child)
+  end
+
+  # Insert an item
+
+  def lru_insert(item)
+    delete(last.lru_key) if size() > @max_items
+    lru_append(@head, item)
+  end
+
+  # Touch an item, make mru!
+  # Returns the item.
+
+  def lru_touch(item)
+    lru_append(@head, lru_delete(item))
+  end
+
+  # Clear the lru.
+
+  def lru_clear
+    @head = Sentinel.new
+    @tail = Sentinel.new
+    lru_join(@head, @tail)
+  end
+
+end

data/lib/mega/macro.rb

@@ -0,0 +1,91 @@
+#--
+# Module Macros
+#
+# Copyright (c) 2004 George Moschovitis
+# Copyright (c) 2005 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.
+#
+# ==========================================================================
+# Revision History ::
+# --------------------------------------------------------------------------
+#  2005.04.28  1.0  Trans     * Minor modifications to documentation.
+# ==========================================================================
+#++
+
+#:title: Module Macros
+#
+# A macro construction for creating dynamic mixins.
+#
+# == Example
+#
+#   module Mixin
+#     macro { |options| %{
+#       def hello
+#         puts 'Hello from #{options[:name]}'
+#       end
+#     } }
+#   end
+#
+#   class MyClass
+#     include Mixin, :name => 'tml'
+#   end
+#
+#   m = MyClass.new
+#   m.hello -> 'Hello from tml'
+#
+# == Author(s)
+#
+# * George Moschovitis <gm@navel.gr>
+# * Thomas Sawyer
+#
+class Module
+
+  def macro( &blk )
+    (@macros ||= []) << blk
+  end
+
+  def macros ; @macros ||= [] ; end
+
+  alias_method :include_without_macros, :include
+
+  def include(*args)
+    options = args.last.is_a?(Hash) ? args.pop : {}
+    for mod in args
+      mod.append_dynamic_features( self, options )
+    end
+    include_without_macros(*args)
+  end
+
+  # Note: Is this the best name for this callback?
+  def append_dynamic_features( base, options )
+    macros.each do |m|
+      base.class_eval m.call( options )
+    end
+  end
+
+  alias_method :extend_without_macros, :extend
+
+  def extend(*args)
+    options = args.last.is_a?(Hash) ? args.pop : {}
+    for mod in args
+      mod.extend_dynamic_object( self, options )
+    end
+    extend_without_macros(*args)
+  end
+
+  # Note: Is this the best name for this callback?
+  def extend_dynamic_object( base, options )
+    macros.each do |m|
+      (class << base; self ; end).class_eval m.call( options )
+    end
+  end
+
+end

data/lib/mega/methodprobe.rb

@@ -0,0 +1,166 @@
+#--
+# Method Probe
+#
+# Copyright (c) 2004,2005 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.
+#
+#
+# ===========================================================================
+# Revision History ::
+# ---------------------------------------------------------------------------
+#  5.7.21  Trans   * Changed name from DuckHunter to Method::Probe.
+# ===========================================================================
+#++
+
+#:title: Method Probe
+#
+# Method::Probe (aka DuckHunter) is a decoy object whic is dropped into
+# methods which records the calls made against it --hence a method probe.
+# Of course, it is not perfect --an inescapable matter it seems for any
+# internal probe. There are a couple of issues related to conditionals.
+# Since the method test for a certain condition against the decoy, how
+# is the decoy to respond? Thus ceratin paths in the code may never get
+# exceuted and thus go unmapped. If Ruby had better conditional reflection
+# (i.e. if 'if', 'case', 'unless', 'when', etc. were true methods) then
+# this could be fixed by making the Probe reentrant, mapping out variant
+# true/false/nil replies. The likely insurmountable problem though is the
+# Halting problem. A probe can cause some methods to complete execution.
+# It's pretty rare, but it can happen and little can be done about it (I think).
+#
+# Note, the alternative to this kind of probe is a program that examines, rather
+# then executes, the code. This would circumvent the above problems, but run
+# into difficulties with dynamic evals. It would also be more complicated,
+# but might prove a better means in the future.
+#
+# This script is provided for experimetnal purposes. Please inform the author
+# if you find ways to improve it or put to an interesting use.
+#
+# == Synopsis
+#
+#   require 'methodprobe'
+#
+#   def amethod(x)
+#     x + 1
+#   end
+#
+#   p method(:amethod).signiture
+#   p method(:amethod).signiture(:class)
+#   p method(:amethod).signiture(:pretty)
+#
+# produces
+#
+#   [["+"]]
+#   [{"+"=>[["Fixnum"]]}]
+#   [["+( Fixnum )"]]
+#
+# == Authors(s)
+#
+# * Thomas Sawyer
+#
+
+class Method
+
+  class Probe
+
+    def Probe.duckcall
+      begin
+        yield
+      rescue TypeError => e
+        self.send(e.message)
+        retry
+      end
+    end
+
+    attr_reader :ducks, :decoys
+
+    def initialize
+      @ducks, @decoys = {}, {}
+    end
+
+    def initialize_copy(from)
+      initialize
+    end
+
+    def method_missing(aSym, *args)
+      aSymStr = aSym.to_s
+
+      # This will happen the first time
+      @ducks[aSymStr] ||= [] #unless @ducks[aSymStr]
+      @ducks[aSymStr] << args.collect { |a| "#{a.class}" }
+
+      decoy = self.dup
+
+      @decoys[aSymStr] ||= [] #unless @decoys[aSymStr]
+      @decoys[aSymStr] << decoy
+
+      # build proxy?
+      #begin
+      #  d = <<-HERE
+      #    def self.#{aSymStr}(*args)
+      #      # This will happen the subsequent times
+      #      @ducks["#{aSymStr}"] << args.collect { |a| #{'"#{a.class}"'} }
+      #      @ducks["#{aSymStr}"].uniq!
+      #      decoy = self.dup
+      #      @decoys["#{aSymStr}"] = [] unless @decoys["#{aSymStr}"]
+      #      @decoys["#{aSymStr}"] << decoy
+      #      decoy
+      #    end
+      #  HERE
+      #  instance_eval d
+      #rescue SyntaxError
+      #  puts "This error may be avoidable by returning the failing duck type as the error message."
+      #  raise
+      #end
+
+      decoy
+    end
+
+  end #class Probe
+
+
+  # Outputs migration information.
+  def migration
+    parameters = []; argc = self.arity
+    if argc > 0
+      argc.times { parameters << Probe.new }
+      Probe.duckcall { self.call(*parameters) }
+    elsif argc < 0
+      raise "(NYI) method takes unlimited arguments"
+    end
+    return parameters
+  end
+  private :migration
+
+
+  # Outputs signiture information.
+  def signature(detail=nil)
+    ds = []
+    case detail
+    when :complete, :all, :full
+      ds = migration
+    when :class, :with_class
+      migration.each { |dh| ds << dh.ducks }
+    when :pp, :pretty, :prettyprint, :pretty_print
+      migration.each do |dh|
+        responders = []
+        dh.ducks.each do |responder, argss|
+          argss.each { |args| responders << "#{responder}( #{args.join(',')} )" }
+        end
+        ds << responders
+      end
+    else
+      migration.each { |dh| ds << dh.ducks.keys }
+    end
+    return ds
+  end
+
+end #class Method
+

data/lib/mega/mock.rb

@@ -0,0 +1,219 @@
+#--
+# Mock
+#
+# Copyright (c) 2005 Thomas Sawyer, Michael Granger and George Moschovitis
+#
+# 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 ::
+# --------------------------------------------------------------------------
+#  0.5.8.24  trans  Created, based-off of George's initial Mock idea, and
+#                   largely influence by Michael Granger's Test::Unit::Mock.
+# ==========================================================================
+#
+#++
+
+require 'ostruct'
+
+#:title: Mock
+#
+# A straightfoward mocking facility. Typically used in test cases.
+# The Mock class offers a few constructors fro quickly building
+# mockups.
+#
+#   mock - Returns a static reponse.
+#   echo - Returns the arguments passed-in.
+#   spin - Returns a rotation of reponses.
+#   keys - Returns an index of responses.
+#
+# Mock classes can be built from sratch or partially framed
+# against other classes.
+#
+# === Usage
+#
+#   class ContextMock < Mock
+#     mock :response_headers, {}
+#     spin :host_url, ['http://www.nitrohq.com','http://www.rubyforge.com']
+#   end
+#
+#   ctx = ContextMock.new
+#   ctx.response_headers['location'] = url
+#   ctx.host_url   #=> "http://www.nitrohq.com"
+#   ctx.host_url   #=> "http://www.rubyforge.com"
+#
+# Or
+#
+#   class ContextMock < Mock(Context)
+#     ...
+#   end
+#
+class Mock < OpenStruct
+
+  # include these?
+  #include Test::Unit::Assertions
+
+  # Certain methods are not mocked:
+  #   inspect       (tricky)
+  #   class         (delegated)
+  #   kind_of?      (delegated)
+  #   is_a?         (delegated)
+  #   instance_of?  (delegated)
+  #   method        (works as-is)
+  #   send          (works as-is)
+  #   respond_to?   (works as-is)
+  #   hash          (no way to mock)
+  #
+  #   __id__, __call__, etc. (not meant to be mocked, ever!)
+  #
+  UnmockedMethods = %r{^(
+    |inspect
+    |kind_of\?|is_a\?|instance_of\?|class
+    |method|send|respond_to\?
+    |hash
+    |__
+  )}x
+
+  class << self
+
+    attr :mocked_class
+
+    def mocks
+      self.methods(false)
+    end
+
+    # Mock a static repsonse.
+    def mock( sym, val )
+      define_method( sym ) { |*args| val }
+    end
+
+    # Responds with input.
+    def echo( sym )
+      define_method( sym ) { |*args| args }
+    end
+
+    # Reponds with a rotation of reponses.
+    def spin( sym, arr )
+      define_method( sym ) { |*args| arr.push(arr.shift) ; arr[-1] }
+    end
+
+    # Responds according to a mapping of input parameters.
+    def keys( sym, hsh )
+      define_method( sym ) { |*args| hsh[args] }
+    end
+
+  end
+
+  # Delegate methods: #class, instance_of?, kind_of?, and is_a?
+  alias :__class :class
+  def class # :nodoc:
+    return __class.mocked_class
+  end
+  def instance_of?( klass ) # :nodoc:
+    self.class == klass
+  end
+  def kind_of?( klass ) # :nodoc:
+    self.class <= klass
+  end
+  alias_method :is_a?, :kind_of?
+
+end
+
+
+# Factory method for creating semi-functional mock objects given the
+# class which is to be mocked. It looks like a constant for purposes
+# of syntactic sugar.
+def Mock( realclass )
+
+  mockclass = Class.new( Mock )
+
+  mockclass.instance_eval do @mocked_class = realclass end
+
+  # Provide an accessor to class instance var that holds the class
+  # object we're faking
+  class << mockclass
+    # The actual class being mocked
+    attr_reader :mocked_class
+
+    # Propagate the mocked class ivar to derivatives so it can be
+    # called like:
+    #   class MockFoo < Mock( RealClass )
+    def inherited( subclass )
+      mc = self.mockedClass
+      subclass.instance_eval do @mocked_class = mc end
+    end
+  end
+
+  # Build method definitions for all the mocked class's instance
+  # methods, as well as those given to it by its superclasses, since
+  # we're not really inheriting from it.
+  imethods = realclass.instance_methods(true).collect do |name|
+    next if name =~ ::Mock::UnmockedMethods
+
+    # Figure out the argument list
+    arity = realclass.instance_method( name ).arity
+    optargs = false
+
+    if arity < 0
+      optargs = true
+      arity = (arity+1).abs
+    end
+
+    args = []
+    arity.times do |n| args << "arg#{n+1}" end
+    args << "*optargs" if optargs
+
+    # Build a method definition. Some methods need special
+    # declarations.
+    argsj = args.join(',')
+    case name.intern
+    when :initialize
+      "def initialize(#{argsj}) ; super ; end"
+    else
+      "def #{name}(#{argsj}) ; self.send(#{name},#{argsj}) ; end"
+      #"def %s( %s ) ; self.__mockRegisterCall(%s) ; end" %
+      #  [ name, argstr, [":#{name}", *args].join(',') ]
+    end
+  end
+
+  # Now add the instance methods to the mockclass class
+  mockclass.class_eval imethods.join( "\n" )
+
+  return mockclass
+end
+
+
+
+# test
+
+if $0 == __FILE__
+
+  class MyMock < Mock
+    mock :m, 10
+    echo :e
+    spin :s, [1,2,3]
+    keys :i, { [:foo] => 'Hello', [:boo] => 'Frog' }
+
+    def a(k) k+1 end
+  end
+
+  my = MyMock.new
+
+  p my.m
+  p my.e('hi')
+  p my.s
+  p my.s
+  p my.s
+  p my.i(:foo)
+  p my.i(:boo)
+  p my.a(1)
+
+end