mega 0.3.1

data/lib/mega/ohash.rb

@@ -0,0 +1,267 @@
+#--
+# OrderedHash
+#
+# from OrderHash 2.0, Copyright (c) 2005 jan molic
+#
+# 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.2.0  Trans  - Ported to Mega Modules
+# ==========================================================================
+#++
+
+#:title: OrderedHash
+#
+# Hash with preserved order and some array-like extensions.
+#
+# == Usage
+#
+# Just require this file and use OrderedHash instead of Hash.
+#
+#   require 'hash/ordered'
+#
+#   # You can do simply
+#   hsh = Hash::Ordered.new
+#   hsh['z'] = 1
+#   hsh['a'] = 2
+#   hsh['c'] = 3
+#   p hsh.keys     #=> ['z','a','c']
+#
+#   # or using OrderedHash[] method
+#   hsh = OrderedHash['z', 1, 'a', 2, 'c', 3] 
+#   p hsh.keys     #=> ['z','a','c']
+#
+#   # but this don't preserve order
+#   hsh = OrderedHash['z'=>1, 'a'=>2, 'c'=>3]
+#   p hsh.keys     #=> ['a','c','z']
+#
+#   # OrderedHash 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
+#
+# == Author(s)
+#
+# * jan molic </mig/at/1984/dot/cz/>
+#
+# == Special Thanks
+#
+# Andrew Johnson for his suggestions and fixes of Hash[], merge,
+# to_a, inspect and shift.
+#
+
+class Hash::Ordered < Hash
+
+    attr_accessor :order
+
+    class << self
+        def [] *args
+            hsh = OrderedHash.new
+            if Hash === args[0]
+                hsh.replace args[0]
+            elsif (args.size % 2) != 0
+                raise ArgumentError, "odd number of elements for Hash"
+            else
+                hsh[args.shift] = args.shift while args.size > 0
+            end
+            hsh
+        end
+    end
+
+    def initialize 
+        @order = []
+    end
+    
+    def store_only a,b
+        store a,b
+    end
+    
+    alias orig_store store    
+    def store a,b
+        @order.push a unless has_key? a
+        super a,b
+    end
+    alias []= store
+    
+    def == hsh2
+        return false if @order != hsh2.order
+        super hsh2
+    end
+    
+    def clear
+        @order = []
+        super
+    end
+    
+    def delete key
+        @order.delete key
+        super
+    end
+    
+    def each_key
+        @order.each { |k| yield k }
+        self
+    end
+    
+    def each_value
+        @order.each { |k| yield self[k] }
+        self
+    end
+    
+    def each
+        @order.each { |k| yield k,self[k] }
+        self
+    end
+    alias each_pair each    
+
+    def delete_if
+        @order.clone.each { |k| 
+            delete k if yield
+        }
+        self
+    end
+    
+    def values
+        ary = []
+        @order.each { |k| ary.push self[k] }
+        ary
+    end
+    
+    def keys
+        @order
+    end
+    
+    def invert
+        hsh2 = Hash.new    
+        @order.each { |k| hsh2[self[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.keys 
+        super hsh2
+    end
+    
+    def shift
+        key = @order.first
+        key ? [key,delete(key)] : super
+    end
+
+    def unshift k,v
+        unless self.include? k
+            @order.unshift k
+            orig_store(k,v)
+            true
+        else
+            false
+        end
+    end
+    
+    def push k,v
+        unless self.include? k
+            @order.push k
+            orig_store(k,v)
+            true
+        else
+            false
+        end
+    end
+    
+    def pop
+        key = @order.last
+        key ? [key,delete(key)] : nil
+    end
+    
+    def to_a
+        ary = []
+        each { |k,v| ary << [k,v] }
+        ary
+    end
+    
+    def to_s
+        self.to_a.to_s
+    end
+    
+    def inspect
+        ary = []
+        each {|k,v| ary << k.inspect + "=>" + v.inspect}
+        '{' + ary.join(", ") + '}'
+    end
+    
+    def update hsh2
+        hsh2.each { |k,v| self[k] = v }
+        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
+    
+end
+
+# Synonym
+OrderedHash = Hash::Ordered
+
+
+=begin
+# --- development testing ---
+
+if __FILE__ == $0
+
+    # You can do simply
+    hsh = OrderedHash.new
+    hsh['z'] = 1
+    hsh['a'] = 2
+    hsh['c'] = 3
+    p hsh.keys     # ['z','a','c']
+
+    # or using OrderedHash[] method
+    hsh = OrderedHash['z', 1, 'a', 2, 'c', 3] 
+    p hsh.keys     # ['z','a','c']
+
+    # but this don't preserve order
+    hsh = OrderedHash['z'=>1, 'a'=>2, 'c'=>3]
+    p hsh.keys     # ['a','c','z']
+
+    # OrderedHash 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
+
+end
+=end

data/lib/mega/orm_support.rb

@@ -0,0 +1,132 @@
+#--
+# ORMSupport
+#
+# 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.8.25 Trans
+#    - Created based on a set of methods from Rails. Spruced up to support
+#      Multiple frameworks, mainly Nitro.
+#
+# ==========================================================================
+#++
+
+#:title: ORMSupport
+#
+# Provides a number of basc convenience methods for working with Object
+# Relational Mappings.
+#
+# == Usage
+#
+#  TODO
+#
+# == Author(s)
+#
+# * D.H.H.
+# * George Moschovitis
+# * Thomas Sawyer
+#
+
+require 'nano/module/basename'
+require 'nano/string/to_const'
+require 'nano/inflect'
+
+module ORMSupport
+
+  ##################
+  # class level
+  ##################
+
+  def self.default_key
+    @default_key ||= '_id'
+  end
+
+  def self.default_key=(x)
+    @default_key = x.to_s
+  end
+
+  ##################
+  # instance level
+  ##################
+
+  # Converts a class-esque name into a table name.
+  #
+  def tablename( type=:nitro )
+    case type
+    when :rails, :ar, :activerecord
+      self.to_s.underscore.plural
+    when :nitro
+      self.to_s.gsub(/::/, '_').downcase
+    else
+      self.to_s.gsub(/::/, '_').downcase
+    end
+  end
+  alias_method :table_name, :tablename  # a la Rails
+  alias_method :tableize, :tablename  # a la Rails
+
+  # Converts a table name into a class name.
+  #
+  def classname( type=:nitro )
+    case type
+    when :rails, :ar, :activerecord
+      self.to_s.singular.camelize
+    when :nitro
+      self.to_s.gsub(/_/, '::').camelize
+    else
+      self.to_s.gsub(/_/, '::').camelize
+    end
+  end
+  alias_method :calss_name, :classname  # a la Rails
+
+  # Like classname, but returns the actual class.
+  #
+  def classify( type=:nitro )
+    classname( type ).to_const
+  end
+
+  # This is good for generating database key/id field names from class names.
+  # In essense, it demodulizes, underscores and appends 'id'.
+  #
+  def keyname( type=nil )
+    case type
+    when :_id
+      self.basename.underscore + "_id"
+    when :id
+      self.basename.underscore + "id"
+    when :_key
+      self.basename.underscore + "_key"
+    when :key
+      self.basename.underscore + "key"
+    else
+      self.basename.underscore + ORMSupport.default_key
+    end
+  end
+  alias_method :key_name, :keyname  # to be consistant
+  alias_method :foreign_key, :keyname  # a la Rails
+
+end
+
+#--
+
+class String
+  include ORMSupport
+end
+
+class Class
+  include ORMSupport
+  alias_method :demodulize, :basename  # a la Rails
+end
+
+#++

data/lib/mega/ostructable.rb

@@ -0,0 +1,158 @@
+#--
+# OpenStructable
+#
+# 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 ::
+# --------------------------------------------------------------------------
+# 05.04.28  Trans
+#   - Minor modifications to documentation.
+# ==========================================================================
+#
+# :ONGOING:
+# Keep this uptodate with ostruct.rb.
+#
+# :TODO: Ask Matz
+# See if Matz will accept it into core so we don't have to anymore.
+#
+# :TODO: Marshalling
+# As with OpenStruct, marshalling is problematic at the moment.
+#
+#++
+
+#:title: OpenStructable
+#
+# OpensStructable is a mixin module which can provide OpenStruct behavior to
+# any class or object. OpenStructable allows extention of data objects 
+# with arbitrary attributes.
+#
+# == Usage
+#
+#   require 'mega/ostructable'
+#
+#   class Record
+#     include OpenStructable
+#   end
+#
+#   record = Record.new
+#   record.name    = "John Smith"
+#   record.age     = 70
+#   record.pension = 300
+#
+#   puts record.name     # -> "John Smith"
+#   puts record.address  # -> nil
+#
+# == Author(s)
+#
+# * Thomas Sawyer
+# * Yukihiro Matsumoto
+# * Gavin Sinclair (Documentation)
+#
+
+module OpenStructable
+  VERSION = '0.9.0'
+
+  # Duplicate an OpenStruct object members. 
+  def initialize_copy(orig)
+    super
+    @__table__ = @__table__.dup
+  end
+
+  def new_ostruct_member(name)
+    self.instance_eval %{
+      def #{name}; @__table__[:#{name}]; end
+      def #{name}=(x); @__table__[:#{name}] = x; end
+    }
+  end
+
+  #
+  # Generate additional attributes and values.
+  #
+  def update(hash)
+    @__table__ ||= {}
+    if hash
+      for k,v in hash
+        @__table__[k.to_sym] = v
+        new_ostruct_member(k)
+      end
+    end
+  end
+  
+  def method_missing(mid, *args) # :nodoc:
+    mname = mid.id2name
+    len = args.length
+    if mname =~ /=$/
+      if len != 1
+        raise ArgumentError, "wrong number of arguments (#{len} for 1)", caller(1)
+      end
+      if self.frozen?
+        raise TypeError, "can't modify frozen #{self.class}", caller(1)
+      end
+      mname.chop!
+      @__table__ ||= {}
+      @__table__[mname.intern] = args[0]
+      self.new_ostruct_member(mname)
+    elsif len == 0
+      @__table__ ||= {}
+      @__table__[mid]
+    else
+      raise NoMethodError, "undefined method `#{mname}' for #{self}", caller(1)
+    end
+  end
+
+  #
+  # Remove the named field from the object.
+  #
+  def delete_field(name)
+    @__table__ ||= {}
+    @__table__.delete name.to_sym
+  end
+
+  #
+  # Returns a string containing a detailed summary of the keys and values.
+  #
+  def inspect
+    str = "<#{self.class}"
+    for k,v in (@__table__ ||= {})
+      str << " #{k}=#{v.inspect}"
+    end
+    str << ">"
+  end
+
+  def __table__ # :nodoc:
+    @__table__ ||= {}
+  end
+  protected :__table__
+
+  #
+  # Compare this object and +other+ for equality.
+  #
+  def ==(other)
+    return false unless(other.kind_of?(OpenStruct))
+    return @__table__ == other.table
+  end
+  
+end
+
+=begin
+#
+# It is possibe to implement OpenStruct itself with 
+# this OpenStructable module as follows:
+#
+class OpenStruct
+  include OpenStructable
+  def initialize(hash=nil)
+    update(hash)
+  end  
+end
+=end