mega 0.3.1

data/lib/mega/promoteself.rb

@@ -0,0 +1,62 @@
+#--
+# PromoteSelf
+#
+# Copyright (c) 2005 fukumoto
+#
+# 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-07-10  Trans   * Started.
+# ==========================================================================
+#++
+
+#:title: PromoteSelf
+#
+# PromoteSelf converts a module's class methods into instance methods
+# such that the first parameter is passed self at the instance level.
+# This promotes DRY programming when wishin to offer both an inheritable
+# and a module callable procedure.
+#
+# == Usage
+#
+#   module MyModule
+#     extend PromoteSelf
+#     def self.jumble( obj, arg )
+#       obj + arg
+#     end
+#   end
+#
+#   class String
+#     include MyModule
+#   end
+#
+#   MyModule.jumble( "Try", "Me" )  #=> "TryMe"
+#
+#   "Try".jumble( "Me" )            #=> 'TryMe'
+#
+# == Authors(s)
+#
+# * Thomas Sawyer
+#
+
+module PromoteSelf
+  alias_method :singleton_method_added_promoteself, :singleton_method_added if defined?(singleton_method_added)
+  def singleton_method_added( meth )
+    d = %{
+      def #{meth}(*args)
+        #{self.name}.#{meth}(self,*args)
+      end
+    }
+    self.class_eval d
+    singleton_method_added_promoteself( meth ) if defined?(singleton_method_added_promoteself)
+  end
+end

data/lib/mega/reference.rb

@@ -0,0 +1,66 @@
+#--
+# Reference
+#
+# 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.06.12 trans  Changed name from Ref to Reference.
+#
+# ==========================================================================
+#++
+
+#:title: Reference
+#
+#   TODO
+#
+# == Synopsis
+#
+#   a = "Hello"
+#   b = ref(a)
+#   b.upcase  #=> "HELLO"
+#
+
+class Reference
+  #instance_methods.each{|m| undef_method(m)}
+  instance_methods.each{|m| undef_method(m) unless m == '__send__' or m == '__id__'}
+
+  def self.new(obj)
+    ref = allocate
+    ref.become obj
+    ref
+  end
+
+  def method_missing(*args, &block)
+    @ref.__send__(*args, &block)
+  end
+
+  def become(obj)
+    old = @ref
+    @ref = obj
+    old
+  end
+
+  def __value__
+    @ref
+  end
+end
+
+
+module Kernel
+  def ref(x)
+    Reference.new(x)
+  end
+end
+

data/lib/mega/semaphore.rb

@@ -0,0 +1,89 @@
+#--
+# Semaphore
+#
+# Copyright (c) 2005 fukumoto
+#
+# 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 Trans  - Ported to Mega Modules
+#
+# ==========================================================================
+#++
+
+#:title: Semaphore (CountingSemaphore)
+#
+# Technically a semaphore is simply an integer variable which
+# has an execution queue associated with it.
+#
+# == Usage
+#
+#   s = CountingSemaphore.new
+#
+#   TODO
+#
+# == Author(s)
+#
+# * fukumoto
+#
+
+class CountingSemaphore
+
+  def initialize(initvalue = 0)
+    @counter = initvalue
+    @waiting_list = []
+  end
+
+  def wait
+    Thread.critical = true
+    if (@counter -= 1) < 0
+      @waiting_list.push(Thread.current)
+      Thread.stop
+    end
+    self
+  ensure
+    Thread.critical = false
+  end
+
+  def signal
+    Thread.critical = true
+    begin
+      if (@counter += 1) <= 0
+        t = @waiting_list.shift
+        t.wakeup if t
+      end
+    rescue ThreadError
+      retry
+    end
+    self
+  ensure
+    Thread.critical = false
+  end
+
+  alias_method( :down, :wait )
+  alias_method( :up, :signal )
+  alias_method( :p, :wait )
+  alias_method( :v, :signal )
+
+  def exclusive
+    wait
+    yield
+  ensure
+    signal
+  end
+
+  alias_method( :synchronize, :exclusive )
+
+end
+
+Semaphore = CountingSemaphore

data/lib/mega/snapshot.rb

@@ -0,0 +1,160 @@
+#--
+# Snapshot
+#
+# Copyright (c) 2004 Michael Neumann
+#
+# 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  trans   * Ported to mega Modules
+# ==========================================================================
+#
+# :TODO: Perhaps extend to offer multiple depths.
+#
+# :TODO: Should key consitancy be enforced? Currently
+#        Struct's will have symobl keys while other classes
+#        will have string keys in the form of "@name".
+#
+# :TODO: Add other core classes.
+#
+#++
+
+##:title: Snapshot
+#
+# A lightweight single-depth object state capture.
+# The #take_snapshot method reads the object's state, 
+# which is generally it's collection of instance variables,
+# and returns them in a hash. The state can be restored
+# with #apply_snapshot.
+#
+# == Usage
+#
+#   Customer = Struct.new("Customer", :name, :address, :zip)
+#   joe = Customer.new( "Joe Pitare", "1115 Lila Ln.", 47634 )
+#
+#   # simple transactions
+#   joe_snap = joe.take_snapshot
+#   begin
+#     do_something_with( joe )
+#   rescue
+#     joe.apply_snapshot( joe_snap )
+#   end
+#
+#   joe_snap[:name]     => "Joe Pitare"
+#   joe_snap[:address]  => "1115 Lila Ln."
+#   joe_snap[:zip]      => 47634
+#
+# == Details
+#
+# Class Snapshot simply represents a collection of objects from
+# which snapshots were taken via their methods #take_snapshot.
+# It provides methods to add an object to a snapshot
+# (Snapshot#add) as well as to restore all objects
+# of the snapshot to their state stored in the snapshot (method
+# Snapshot#restore).
+#
+# In Wee, this class is used to backtracking the state of
+# components (or decorations/presenters). Components that want
+# an undo-facility to be implemented (triggered for example by
+# a browsers back-button), have to overwrite the
+# Wee::Component#backtrack_state method.
+#
+# == Author(s)
+#
+# * Michael Neumann
+#
+
+class Snapshot
+  def initialize
+    @objects = Hash.new
+  end
+
+  def add(object)
+    oid = object.object_id
+    @objects[oid] = [object, object.take_snapshot] unless @objects.include?(oid) 
+  end
+
+  def restore
+    @objects.each_value { |object, value| object.restore_snapshot(value) }
+  end
+end
+
+module DupReplaceSnapshotMixin
+  def take_snapshot
+    dup
+  end
+
+  def restore_snapshot(snap)
+    replace(snap)
+  end
+end
+
+# Implements a value holder. In Wee this is useful for 
+# backtracking the reference assigned to an instance variable 
+# (not the object itself!). An example where this is used is the
+# <tt>@__decoration</tt> attribute of class Wee::Component.
+
+class ValueHolder
+  attr_accessor :value
+
+  def initialize(value=nil)
+    @value = value
+  end
+
+  def take_snapshot
+    @value
+  end
+
+  def restore_snapshot(value)
+    @value = value
+  end
+end
+
+
+#--
+# Extend some base classes of Ruby (Object, Array, String, Hash, 
+# Struct) for the two methods #take_snapshot and 
+# #restore_snapshot, required by Snapshot.
+#++
+
+class Object
+  def take_snapshot
+    snap = Hash.new
+    instance_variables.each do |iv|
+      snap[iv] = instance_variable_get(iv)
+    end
+    snap
+  end
+
+  def restore_snapshot(snap)
+    instance_variables.each do |iv|
+      instance_variable_set(iv, snap[iv])
+    end
+  end
+end
+
+class Array  ; include DupReplaceSnapshotMixin ; end
+class String ; include DupReplaceSnapshotMixin ; end
+class Hash   ; include DupReplaceSnapshotMixin ; end
+
+class Struct
+  def take_snapshot
+    snap = Hash.new
+    each_pair {|k,v| snap[k] = v}
+    snap
+  end
+
+  def restore_snapshot(snap)
+    snap.each_pair {|k,v| send(k.to_s + "=", v)} 
+  end
+end
+

data/lib/mega/sstruct.rb

@@ -0,0 +1,413 @@
+#--
+# SuperStruct
+#
+# Copyright (c) 2005 Hal Fulton
+#
+# 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
+# ==========================================================================
+#
+#  05.02.02 trans   Ported to Mega Modules.
+#
+# ==========================================================================
+#++
+
+#:title: SuperStruct
+#
+# This is an easy way to create Struct-like classes; it converts easily
+# between hashes and arrays, and it allows OpenStruct-like dynamic naming
+# of members.
+#
+# Unlike Struct, it creates a "real" class, and it has real instance variables 
+# with predictable names.
+#
+# A basic limitation is that the hash keys must be legal method names (unless
+# used with send()).
+#
+# Basically, ss["alpha"], ss[:alpha], ss[0], and ss.alpha all mean the same.
+#
+# == What It's Like
+#
+# It's like a Struct...
+#   - you can pass in a list of symbols for accessors
+#   - it will create a class for you
+# but...
+#   - you don't have to pass in the class name
+#   - it returns a "real" class
+#     . instance variables have the expected names
+#     . you can reopen and add methods
+#   - it doesn't go into the Struct:: namespace
+#   - it preserves the order of the fields
+#   - you can use Strings instead of Symbols for the names
+#
+# It's like an Array...
+#  - you can access the items by [number] and [number]=
+# but...
+#  - you can also access the items by ["name"] and ["name"]=
+#  - you can access the items by accessors
+#
+# It's like an OpenStruct...
+#  - (if you use .open instead of .new) you can add fields 
+#    automatically with x.field or x.field=val
+# but...
+#  - you can initialize it like a Struct
+#  - it preserves the order of the fields
+#
+# It's like a Hash...
+#  - data can be accessed by ["name"]
+# but...
+#  - order (of entry or creation) is preserved
+#  - arbitrary objects are not allowed (it does obj.to_str or obj.to_s)
+#  - strings must be valid method names
+#
+# It's like Ara Howard's Named Array...
+#  - we can access elements by ["name"] or ["name"]=
+# but...
+#  - you can access the items by accessors
+#  - strings must be valid method names
+#
+# It's like Florian Gross's Keyed List...
+#  (to be done)
+# but...
+#  - it preserves the order of the fields
+#
+# == Usage
+#
+#   # Need not assign to existing fields (default to nil)
+#   myStruct = SuperStruct.new(:alpha)
+#   x = myStruct.new
+#   x.alpha  # nil
+#
+#   # A value assigned at construction may be retrieved
+#   myStruct = SuperStruct.new(:alpha)
+#   x = myStruct.new(234)
+#   x.alpha  # 234
+#
+#   # Unassigned fields are nil
+#   myStruct = SuperStruct.new(:alpha,:beta)
+#   x = myStruct.new(234)
+#   x.beta  # nil
+#
+#   # An open structure may not construct with nonexistent fields
+#   myStruct = SuperStruct.open
+#   x = myStruct.new(234)  # error
+#
+#   # An open structure may assign fields not previously existing
+#   myStruct = SuperStruct.open
+#   x = myStruct.new
+#   x.foo = 123
+#   x.bar = 456
+#
+#   # The act of retrieving a nonexistent field from an open struct will
+#   # create that field
+#   myStruct = SuperStruct.open
+#   x = myStruct.new
+#   x.foo   # nil
+#
+#   # A field (in an open struct) that is unassigned will be nil
+#   myStruct = SuperStruct.open
+#   x = myStruct.new
+#   y = x.foobar
+#
+#   # A struct created with new rather than open cannot reference nonexistent
+#   # fields
+#   myStruct = SuperStruct.new
+#   x = myStruct.new
+#   x.foo  # error
+#
+#   # Adding a field to a struct will create a writer and reader for that field
+#
+#   # An open struct will also create a writer and a reader together
+#
+#   # A field has a real writer and reader corresponding to it
+# 
+#   # A string will work as well as a symbol
+#   myStruct = SuperStruct.new("alpha")
+#
+#   # to_a will return an array of values
+#   myStruct = SuperStruct.new("alpha","beta","gamma")
+#   x = myStruct.new(7,8,9)
+#   assert(x.to_a == [7,8,9])
+#
+#   # Instance method 'members' will return a list of members (as strings)
+#   myStruct = SuperStruct.new(:alpha,"beta")
+#   x = myStruct.new
+#   assert_equal(["alpha","beta"],x.members)
+#
+#   # Class method 'members' will return a list of members (as strings)
+#   myStruct = SuperStruct.new(:alpha,"beta")
+#   assert_equal(["alpha","beta"],myStruct.members)
+#
+#   # to_ary will allow a struct to be treated like an array in
+#   # multiple assignment
+#   myStruct = SuperStruct.new("alpha","beta","gamma")
+#   x = myStruct.new(7,8,9)
+#   a,b,c = x
+#   assert(b == 8)
+#
+#   # to_ary will allow a struct to be treated like an array in
+#   # passed parameters
+#   myStruct = SuperStruct.new("alpha","beta","gamma")
+#   x = myStruct.new(7,8,9)
+#   b = meth(*x)
+#
+#   # to_hash will return a hash with fields as keys
+#   myStruct = SuperStruct.new("alpha","beta","gamma")
+#   x = myStruct.new(7,8,9)
+#   h = x.to_hash
+#   assert_equal({"alpha"=>7,"beta"=>8,"gamma"=>9},h)
+#
+#   # A field name (String) may be used in a hash-like notation
+#   myStruct = SuperStruct.new("alpha","beta","gamma")
+#   x = myStruct.new(7,8,9)
+#   y = x["beta"]
+#
+#   # A field name (Symbol) may be used in a hash-like notation
+#   myStruct = SuperStruct.new("alpha","beta","gamma")
+#   x = myStruct.new(7,8,9)
+#   y = x[:beta]
+#
+#   # [offset,length] may be used as for arrays
+#   myStruct = SuperStruct.new("alpha","beta","gamma")
+#   x = myStruct.new(7,8,9)
+#   y = x[0,2]
+#
+#   # Ranges may be used as for arrays
+#   myStruct = SuperStruct.new("alpha","beta","gamma")
+#   x = myStruct.new(7,8,9)
+#   y = x[1..2]
+#
+#   # Adding a field to an open struct adds it to the instance
+#   myStruct = SuperStruct.open(:alpha)
+#   x = myStruct.new
+#   x.beta = 5
+#
+#   # Adding a field to an open struct adds it to the class also
+#   myStruct = SuperStruct.open(:alpha)
+#   x = myStruct.new
+#   x.beta = 5
+#
+#   # An array passed to SuperStruct.new need not be starred
+#   myStruct = SuperStruct.new(%w[alpha beta gamma])
+#   x = myStruct.new
+#
+#   # A hash passed to #set will set multiple values at once
+#   myStruct = SuperStruct.new(%w[alpha beta gamma])
+#   x = myStruct.new
+#   hash = {"alpha"=>234,"beta"=>345,"gamma"=>456}
+#   x.set(hash)
+#
+#   # ||= works properly
+#   x = SuperStruct.open.new
+#   x.foo ||= 333
+#   x.bar = x.bar || 444
+#
+#   # attr_tester will create a ?-method
+#   myStruct = SuperStruct.new(:alive)
+#   myStruct.attr_tester :alive
+#   x = myStruct.new(true)
+#   x.alive?  # true
+#
+#
+# == Author(s)
+#
+# * Hal Fulton
+#
+
+class SuperStruct
+
+  def SuperStruct.new(*args)
+    @table = []
+    @setsyms = []        # Setter symbols
+    klass = Class.new
+    if (args.size == 1) && (args[0].is_a? Array)
+      args = args[0]
+    end
+    strs = args.map {|x| x.to_s }
+    args.each_with_index do |k,i|
+      case
+      when (! [String,Symbol].include? k.class)
+        raise ArgumentError, "Need a String or Symbol"
+      when (strs[i] !~ /[_a-zA-Z][_a-zA-Z0-9]*/)
+        raise ArgumentError, "Illegal character"
+      end
+      k = k.intern if k.is_a? String
+      @table << k
+      @setsyms << (k.to_s + "=").intern
+      klass.instance_eval { attr_accessor k }
+    end
+
+    setsyms = @setsyms
+    table   = @table
+    vals    = @vals
+    klass.class_eval do
+      attr_reader :singleton
+      define_method(:initialize) do |*vals|
+        n = vals.size
+        m = table.size
+        case
+        when n < m
+          # raise ArgumentError, "Too few arguments (#{n} for #{m})"
+          # Never mind... extra variables will just be nil
+        when n > m
+          raise ArgumentError, "Too many arguments (#{n} for #{m})"
+        end
+        setsyms.each_with_index do |var,i|
+          self.send(var,vals[i])
+        end
+      end
+      define_method(:pretty_print) do |q|  # pp.rb support
+        q.object_group(self) do
+          q.seplist(self.members, proc { q.text "," }) do |member|
+#           self.members.each do |member|
+#           q.text ","  # unless q.first?
+            q.breakable
+            q.text member.to_s
+            q.text '='
+            q.group(1) do
+              q.breakable ''
+              q.pp self[member]
+            end
+          end
+        end
+      end
+      define_method(:inspect) do
+        str = "#<#{self.class}:"
+        table.each {|item| str << " #{item}=#{self.send(item)}" }
+        str + ">"
+      end
+      define_method(:[]) do |*index|
+        case index.map {|x| x.class }
+        when [Fixnum]
+          self.send(table[*index])
+        when [Fixnum,Fixnum], [Range]
+          table[*index].map {|x| self.send(x)}
+        when [String]
+          self.send(index[0].intern)
+        when [Symbol]
+          self.send(index[0])
+        else
+          raise ArgumentError,"Illegal index"
+        end
+      end
+      define_method(:[]=) do |*index|
+        value = index[-1]
+        index = index[0..-2]
+        case index.map {|x| x.class }
+          when [Fixnum]
+            self.send(table[*index])
+          when [Fixnum,Fixnum], [Range]
+            setsyms[*index].map {|x| self.send(x,value) }
+          when [String]
+            self.send(index[0].intern,value)
+          when [Symbol]
+            self.send(index[0],value)
+        else
+          raise ArgumentError,"Illegal index"
+        end
+      end
+      define_method(:to_a)    { table.map {|x| eval("@"+x.to_s) } }
+      define_method(:to_ary)  { to_a }
+      define_method(:members) { table.map {|x| x.to_s } }
+      define_method(:to_struct) do
+        mems = table
+        Struct.new("TEMP",*mems)
+        # Struct::TEMP.new(*vals) # Why doesn't this work??
+        data = mems.map {|x| self.send(x) }
+        Struct::TEMP.new(*data)
+      end
+      define_method(:to_hash) do
+        hash = {}
+        table.each do |mem|
+          mem = mem.to_s
+          hash.update(mem => self.send(mem))
+        end
+        hash
+      end
+      define_method(:set) {|h| h.each_pair {|k,v| send(k.to_s+"=",v) } }
+
+      # Class methods...
+
+      @singleton = class << self
+        self
+      end
+
+      @singleton.instance_eval do
+        define_method(:members) do
+          table.map {|x| x.to_s }
+        end
+        me = self
+        define_method(:attr_tester) do |*syms| 
+          syms.each {|sym| alias_method(sym.to_s+"?",sym) }
+        end
+      end
+
+    end
+    klass
+  end
+
+
+  def SuperStruct.open(*args)
+    klass = SuperStruct.new(*args)
+    table = @table
+    setsyms = @setsyms
+    table = @table
+    klass.class_eval do
+      define_method(:method_missing) do |meth, *args|
+        mname = meth.id2name
+        if mname =~ /=$/
+          getter = mname.chop
+          setter = mname
+        elsif mname =~ /\?$/
+          raise NoMethodError  # ?-methods are not created automatically
+        else
+          getter = mname
+          setter = mname + "="
+        end
+        gsym = getter.intern
+        ssym = setter.intern
+        ivar = "@" + getter
+        setsyms << setter
+        table << getter
+        len = args.length
+        if mname == getter
+          klass.class_eval do                 # getter
+            define_method(getter) do
+              instance_variable_get(ivar)
+            end
+          end
+        else
+          klass.class_eval do                 # setter
+            define_method(setter) do |*args|
+              if len != 1
+                raise ArgumentError, "Wrong # of arguments (#{len} for 1)", caller(1)
+              end
+              instance_variable_set(ivar,args[0])
+              instance_variable_get(ivar)
+            end
+          end
+        end
+        if mname == setter
+          self.send(setter,*args)
+        else
+          if len == 0
+            self.send(getter)
+          else
+            raise NoMethodError, "Undefined method '#{mname}' for #{self}", caller(1)
+          end
+        end
+      end
+    end
+    klass
+  end
+
+end