mixers 1.0.0

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License
+
+Copyright (c) 2010 Thomas Sawyer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+

data/README

@@ -0,0 +1,17 @@
+= Ruby Mixers
+
+== DESCRIPTION
+
+Ruby Mixers is collection mixin modules for the Ruby
+programming language.
+
+Mixers is a spin-off of Ruby Facets. When Ruby Facets
+scaled back to extensions only project, it's mixin 
+modules were gathered to create this new project.
+
+== COPYRIGHTS
+
+Ruby Mixers Copyright (c) 2010 Thomas Sawyer
+
+Ruby Mixers is distibuted under the terms of the MIT license.
+

data/lib/mixers/advisable.rb

@@ -0,0 +1,148 @@
+# Copyright (c) 2007 Thomas Sawyer
+
+require 'facets/kernel/method'
+require 'facets/module/instance_method'
+require 'facets/unboundmethod/arguments'
+
+# = Advisable
+#
+# Advisable provides a means of using before, after and
+# around adivce in dynamic fashion.
+#
+module Advisable
+
+  def self.append_features(base)
+    base.extend self
+  end
+
+  def advice_before
+    @advice_before ||= {} #Hash.new{|h,k| h[k] = []}
+  end
+
+  def advice_after
+    @advice_after ||= {} #Hash.new{|h,k| h[k] = []}
+  end
+
+  def advice_around
+    @advice_around ||= {} #Hash.new{|h,k| h[k] = []}
+  end
+
+  def before(meth, &block)
+    name = "#{meth}:before:#{block.object_id}"
+    define_method(name, &block)
+    (advice_before[meth.to_sym] ||= []) << name
+  end
+
+  def after(meth, &block)
+    name = "#{meth}:after:#{block.object_id}"
+    define_method(name, &block)
+    (advice_after[meth.to_sym] ||= []) << name
+  end
+
+  def around(meth, &block)
+    name = "#{meth}:around:#{block.object_id}"
+    define_method(name, &block)
+    (advice_around[meth.to_sym] ||= []) << name
+  end
+
+  # Advise a method.
+
+  def advise(meth)
+    #return false if defined?(meth_origin)
+    args = instance_method(meth).arguments
+
+    module_eval(<<-END, __FILE__, __LINE__)
+      alias_method '#{meth}_origin', '#{meth}'
+      def #{meth}(#{args})
+        target = method!('#{meth}_origin')
+
+        unless target.advised
+          ancs = self.class.ancestors.select{ |anc| anc.respond_to?(:advice_before) }
+          target.advice_before = ancs.collect{ |anc| anc.advice_before[:'#{meth}'] }
+          target.advice_after  = ancs.collect{ |anc| anc.advice_after[:'#{meth}'] }
+          target.advice_around = ancs.collect{ |anc| anc.advice_around[:'#{meth}'] }
+          target.advised = true
+        end
+
+        target.call_with_advice(self, *[#{args}])
+      end
+    END
+  end
+
+  #advise(:method_added)
+
+  #after :method_added do |meth|
+  #  advise(meth) unless defined?("#{meth}_orig")
+  #end
+
+  def method_added(meth)
+    return if meth == :method_added
+    @added_stack ||= []
+    return if @added_stack.last == meth
+    return if /_(origin)$/ =~ meth.to_s
+    return if /:(before|after|around)/ =~ meth.to_s
+    @added_stack << meth
+    #return if instance_methods(false).include?("#{meth}_orig")
+    advise(meth)
+    @added_stack.pop
+  end
+
+  # Extensions for Method class.
+
+  module Method
+
+    attr_accessor :advised
+
+    attr_reader :advice_before
+    attr_reader :advice_after
+    attr_reader :advice_around
+
+    def advised?
+      @advised
+    end
+
+    def advice_before=(set); @advice_before = set.flatten.compact; end
+    def advice_after=(set) ;  @advice_after = set.flatten.compact; end
+    def advice_around=(set); @advice_around = set.flatten.compact; end
+
+    # Call with advice.
+
+    def call_with_advice(obj, *args, &blk)
+      advice_before.each do |name|
+        #advice.call(*args, &blk)
+        obj.send(name, *args, &blk)
+      end
+
+      target = lambda{ call(*args, &blk) }
+      advice_around.each do |name|
+        target = lambda_target(obj, name, target, *args, &blk)
+      end
+      ret = target.call
+
+      advice_after.reverse_each do |name|
+        #advice.call(*args, &blk)
+        obj.send(name, *args, &blk)
+      end
+
+      return ret
+    end
+
+    private
+
+    # Using separate method for this prevents infinite loop.
+
+    def lambda_target(obj, name, target, *args, &blk)
+      lambda do
+        #advice.call(target, *args, &blk)
+        obj.send(name, target, *args, &blk)
+      end
+    end
+
+  end
+
+end
+
+class Method #:nodoc:
+  include Advisable::Method
+end
+

data/lib/mixers/cloneable.rb

@@ -0,0 +1,54 @@
+# = Clonable
+#
+# Standard basis for adding deep #dup and #clone to a class.
+# Provides a class with deep cloneablity via the standard
+# #dup and #clone methods.
+#
+# == Credit
+#
+# Cloneable was originally ported from Jim Weirich's Rake.
+# The current version is the work of Ken Bloom.
+#
+#--
+# TODO: Is there a more robust means of determining if clone or dup is used?
+#++
+
+module Cloneable
+
+  def initialize_copy(sibling)
+    #first duplicate my superclass' state. Note that if it's duplicating
+    #instance variables, this will be overwritten, but this is important
+    #because we could be dealing with a C extension with state hidden from
+    #the Ruby interpreter
+    super
+
+    #we want to know if we're being dup'ed or clone'd, because we want to
+    #preserve the state of our internals the same way our state is being
+    #preserved. (If we can't figure it out, we'll just use #dup.)
+    operation = caller.find{|x| x !~ /'initialize_copy'/}.match(/`(dup|clone)'/)[1] or :dup
+
+    sibling.instance_variables.each do |ivar|
+      value = sibling.instance_variable_get(ivar)
+
+      #set my instance variable to be a #dup or #clone
+      #or my sibling, depending on what's happening to me right now
+      instance_variable_set(ivar, value.send(operation))
+    end
+  end
+
+end 
+
+# OLD VERSION
+
+#module Cloneable
+#  def clone
+#    sibling = self.class.new
+#    instance_variables.each do |ivar|
+#      value = self.instance_variable_get(ivar)
+#      sibling.instance_variable_set(ivar, value.dup) #rake_dup)
+#    end
+#    sibling
+#  end
+#  alias_method :dup, :clone
+#end
+

data/lib/mixers/enumargs.rb

@@ -0,0 +1,195 @@
+# Enumerable::Arguments
+#
+# Copyright (c) 2004 Thomas Sawyer
+#
+# LGPL(3) 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.
+
+begin
+  require 'enumerator'
+rescue LoadError
+end
+
+# This is a simple reimplementation of the core Enumerable module
+# to allow the methods to take and pass-on arbitrary arguments to the
+# underlying #each call. This library uses Enumerator and scans
+# Enumerable so it can alwasy stay in sync.
+#
+# NOTE Any Enumerable method with a negative arity cannot do pass arguments
+# due to ambiguity in the argument count. So the methods #inject and #zip
+# do NOT work this way, but simply work as they do in Enumerable.
+# The method #find (and #detect) though has been made to work by removing
+# its rarely used optional parameter and providing instead an optional
+# keyword parameter (:ifnone => ...). Please keep these difference in mind.
+#
+#   require 'enumargs'
+#
+#   class T
+#     include Enumerable::Arguments
+#     def initialize(arr)
+#       @arr = arr
+#     end
+#     def each(n)
+#       arr.each{ |e| yield(e+n) }
+#     end
+#   end
+#
+#   t = T.new([1,2,3])
+#   t.collect(4)
+#   #=> [5,6,7]
+#
+module Enumerable
+module Arguments
+
+  def self.wrap_enumerable_method( methodname )
+
+    m = methodname
+    meth = Enumerable.instance_method(m)
+    arity = meth.arity
+
+    case arity <=> 0
+    when 0
+      class_eval %{
+        def #{m}( *args, &yld )
+          enum_for(:each, *args).#{m}( &yld )
+        end
+      }
+    when 1
+      class_eval %{
+        def #{m}( *args, &yld )
+          args, each_args = args[0...#{arity}], args[#{arity}..-1]
+          enum_for(:each, *each_args).#{m}( *args, &yld )
+        end
+      }
+    else
+      class_eval %{
+        def #{m}( *args, &yld )
+          enum_for(:each).#{m}( *args, &yld )
+        end
+      }
+    end
+  end
+
+  Enumerable.instance_methods(false).each do |m|
+    wrap_enumerable_method( m )
+  end
+
+  #
+  def to_a(*args)
+    map(*args){ |x| x }
+  end
+
+  # Make exception for #find (a negative arity method) to accept
+  # keyword argument.
+  #
+  #   ObjectSpace.find(Class, :ifnone=>lambda{1}) { |e| ... }
+  #   ObjectSpace.find(Class, :ifnone=>lambda{1}) { |e| ... }
+  #
+  def find(*args, &yld)  # future use **keys ?
+    if Hash === args.last and args.last.key?(:ifnone)
+      ifnone = args.last.delete(:ifnone)
+      args.pop if args.last.empty?
+      enum_for(:each, *args).find( ifnone, &yld )
+    else
+      enum_for(:each, *args).find( &yld )
+    end
+  end
+  alias_method :detect, :find
+
+end
+end
+
+
+=begin  OLD CODE
+module EnumerableArgs
+
+  def collect(*args)  # :yield:
+    a = []
+    each(*args){ |n| a << yield(n) }
+    a
+  end
+  alias_method( :map, :collect )
+
+  def detect(*args)  # :yield:
+    each(*args){ |n| return n if yield(n) }
+    nil
+  end
+  alias_method( :find, :detect )
+
+  def each_with_index(*args)
+    i=0
+    each(*args){ |*n| n << i; yield(*n); i+=1 }
+    self
+  end
+
+  def to_a(*args)
+    a = []
+    each(*args){ |n| a << n }
+    a
+  end
+  alias_method( :entries, :to_a )
+
+  # An additional method not part of standard Enumerable.
+  # The regular version of this method can be found in Facets,
+  # but it is a bit more advanced then this one.
+  # At some point they need to be put into sync.
+  def each_slice(*args, &yld)
+    a = []; s = []
+    ar = yld.arity.abs
+    each(*args){ |n|
+      s << n
+      if s.length >= ar
+        yld.call(*s)
+        s = []
+      end
+    }
+    a
+  end
+  alias_method( :each_by, :each_slice )
+
+  def select(*args)  # :yield:
+    a = []
+    each(*args){ |n| a << n if yield(n) }
+    a
+  end
+  alias_method( :find_all, :select )
+
+  def grep(pattern, *args)
+    a = []
+    each(*args){ |n| a << (block_given? ? yield(n) : n) if pattern === n }
+    a
+  end
+
+  def include?(anObj, *args)
+    each(*args){ |n| return true if anObj == n }
+    false
+  end
+  alias_method( :member?, :include? )
+
+  def max(*args)
+    to_a(*args).max
+  end
+
+  def min(*args)
+    to_a(*args).min
+  end
+
+  def reject(*args)
+    a = []
+    each(*args){ |n| a << n if ! yield(n) }
+    a
+  end
+
+  def sort(*args)
+    # TODO
+  end
+
+end
+=end
+

data/lib/mixers/equitable.rb

@@ -0,0 +1,76 @@
+# = Equitable
+#
+# This mixin provides methods of equality based
+# on a single #identity method which must return
+# a list of accessors used as the identity keys.
+#
+# It also provides a "shortcut" for creating the
+# #identity method based on given accessors and returns
+# the Equitable module for inclusion.
+#
+#   include Equitable(:a, :b)
+#
+# is equivalent to including a module containing:
+#
+#   def ==(other)
+#     self.a == other.a && self.b == other.b
+#   end
+#
+#   def eql?(other)
+#     self.a.eql?(other.a) && self.b.eql?(other.b)
+#   end
+#
+#   def hash()
+#     self.a.hash ^ self.b.hash
+#   end
+#
+module Equitable
+
+  def self.identify(base, *accessors)
+    base.send(:define_method, :identity){ accessors }
+    self
+  end
+
+  def ==(o)
+    identity.all?{ |a| send(a) == o.send(a) }
+  end
+
+  def eql?(o)
+    identity.all?{ |a| send(a).eql?(o.send(a)) }
+  end
+
+  def hash
+    identity.inject(0){ |memo, a| memo ^ send(a).hash }
+  end
+
+end
+
+class Module
+
+  # This function provided a "shortcut" for creating the
+  # #identity method based on given accessors and returns
+  # the Equitable module for inclusion.
+  #
+  #  include Equitable(:a, :b)
+  #
+  # is equivalent to including a module containing:
+  #
+  #   def ==(other)
+  #     self.a == other.a && self.b == other.b
+  #   end
+  #
+  #   def eql?(other)
+  #     self.a.eql?(other.a) && self.b.eql?(other.b)
+  #   end
+  #
+  #   def hash()
+  #     self.a.hash ^ self.b.hash
+  #   end
+  #
+
+  def Equitable(*accessors)
+    Equitable.identify(self, *accessors)
+  end
+
+end
+

data/lib/mixers/expirable.rb

@@ -0,0 +1,38 @@
+# = Expirable
+#
+# Generic expirability mixin.
+#
+module Expirable
+
+  attr_accessor :expires
+
+  # Set the expires timeout for this entry.
+
+  def expires_after(timeout = (60*60*24))
+    @expires = Time.now + timeout
+  end
+
+  # Set the expire timeout for this entry. The timeout happens
+  # after (base + rand(spread)) seconds.
+
+  def expires_spread(base, spread)
+    @expires = Time.now + base + rand(spread)
+  end
+
+  # Is this entry expired?
+
+  def expired?
+    if @expires.nil? or (Time.now > @expires)
+      return true
+    else
+      return false
+    end
+  end
+
+  # Update the expiration period. Override in your application.
+
+  def touch!
+  end
+
+end
+

data/lib/mixers/hook.rb

@@ -0,0 +1,38 @@
+#require 'facets/kernel/instance_exec'
+
+# TODO: hooks should be an inheritor
+#
+module Hook
+
+  def self.append_features(base)
+    base.extend self
+  end
+
+  def hooks
+    @hooks ||= Hash.new{ |h,k| h[k] = [] }
+  end
+
+  def hook(name)
+    name = name.to_sym
+
+    (class << self; self; end).class_eval %{
+      def #{name}(meth=nil, &blk)
+        hooks[:#{name}] << (meth || blk)
+      end
+    }
+
+    module_eval %{
+      def #{name}(*args)
+        self.class.hooks[:#{name}].each do |blk|
+          if Proc === blk
+            instance_exec(:#{name}, *args, &blk)
+          else
+            __send__(blk, :#{name}, *args)
+          end
+        end
+      end
+    }
+  end
+
+end
+

data/lib/mixers/instantiable.rb

@@ -0,0 +1,25 @@
+# = Instantiable
+#
+# Initialize modules, almost as if they were classes.
+#
+# Alows a module to be used much like a class, by defining
+# a #new method that creates a class on demand.
+#
+module Instantiable
+
+  def self.append_features(mod)
+    mod.extend self
+  end
+
+  # Never use a class agian! ;)
+
+  def new(*args,&blk)
+    mod = self
+    @instantiable_class ||= Class.new{include mod}
+    @instantiable_class.new(*args,&blk)
+  end
+
+end
+
+
+

data/lib/mixers/ostructable.rb

@@ -0,0 +1,179 @@
+# = Ostructable
+#
+# 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 '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
+#
+#--
+# TODO: Keep this uptodate with ostruct.rb
+#
+# TODO: As with OpenStruct, marshalling is problematic at the moment.
+#++
+
+module OpenStructable
+
+  def initialize(hash=nil)
+    @__table__ = {}
+    if hash
+      for k,v in hash
+        @__table__[k.to_sym] = v
+        new_ostruct_member(k)
+      end
+    end
+  end
+
+  # duplicate an OpenStruct object members.
+  def initialize_copy(orig)
+    super
+    @__table__ = @__table__.dup
+  end
+
+  def marshal_dump
+    @table
+  end
+  def marshal_load(x)
+    @table = x
+    @table.each_key{|key| new_ostruct_member(key)}
+  end
+
+  def new_ostruct_member(name)
+    unless self.respond_to?(name)
+      self.instance_eval %{
+        def #{name}; @__table__[:#{name}]; end
+        def #{name}=(x); @__table__[:#{name}] = x; end
+      }
+    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.to_s
+    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
+end
+=end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+=begin testing
+
+  require 'test/unit'
+
+  # fixture
+
+  class Record
+    include OpenStructable
+  end
+
+  # test
+
+  class TC_OpenStructable < Test::Unit::TestCase
+
+    def test_record
+      record = nil
+      assert_nothing_raised {
+        record = Record.new
+        record.name    = "John Smith"
+        record.age     = 70
+        record.pension = 300
+      }
+      assert_equal( "John Smith", record.name )
+      assert_equal( 70, record.age )
+      assert_equal( nil, record.address )
+    end
+
+  end
+
+=end

data/lib/mixers/preinitilizable.rb

@@ -0,0 +1,93 @@
+# = Preinitialize
+#
+# This is an object preinitialize system, which provides
+# an elegant way to initialize an object allowing the
+# class to provide additional default structure to an
+# object prior to calling initialize.
+#
+# In effect it does two things after allocating the object
+# but prior to initializing it.
+#
+# First, it calls the class method #default_instance_variables,
+# which returns a hash and by default returns the hash
+# stored in @default_instance_variables. It uses this to
+# pre-define instance variables.
+#
+# Then it goes to the top of the class hierarchy  and works
+# it's way down calling #preinitialize if defined.
+# WARNING! It is rather useless to use <tt>super</tt>
+# inside the any preinitialize hook.
+#
+#   module M
+#     def preinitialize
+#       @a = 23
+#     end
+#   end
+#
+#   class X
+#     include M
+#     def a ; @a ; end
+#   end
+#
+#   x = X.new
+#   x.a         #=> 23
+#
+# If neded the original new method has been aliased, albeit
+# <tt>postinitialize_new</tt> is probably a bit of a misnomer.
+
+#--
+# class Module
+#
+#   def default_instance_variables(complete=false)
+#     @default_instance_variables ||= {}
+#     unless complete
+#       return @default_instance_variables
+#     else
+#       parent = ancestors[1]
+#       if parent
+#         return @default_instance_variables.merge(parent.default_instance_variables)
+#       else
+#         return @default_instance_variables
+#       end
+#     end
+#   end
+#
+# end
+#++
+
+module Preinitializable
+
+  def self.included(base)
+    if Class===base
+      (class << base; self; end).__send__(:alias_method, :post_new, :new)
+      base.extend Meta
+    else
+      (class << base; self; end).__send__(:define_method, :included, &method(:included))
+    end
+  end
+
+  module Meta
+
+    def new(*args, &blk)
+      o = allocate
+      #if respond_to?(:default_instance_variables)
+      #  default_instance_variables.each{|k,v| o.instance_variable_set( "@#{k.to_s.gsub(/\W$/,'')}",v )}
+      #end
+      a = ancestors
+      until a.empty?
+        m = a.pop
+        if m.private_instance_methods(false).include?('preinitialize') or
+             m.protected_instance_methods(false).include?('preinitialize') or
+               m.public_instance_methods(false).include?('preinitialize')
+          im = instance_method('preinitialize')
+          im.arity == 0 ? im.bind(o).call : im.bind(o).call(*args, &blk)
+        end
+      end
+      o.__send__(:initialize, *args, &blk) if o.class.private_method_defined?(:initialize)
+      o
+    end
+
+  end
+
+end
+

data/lib/mixers/registerable.rb

@@ -0,0 +1,29 @@
+# = Registerable
+#
+module Registerable
+
+  # Register format names.
+
+  def register(*names)
+    names.each do |name|
+      registry[name.to_s] = self
+    end
+  end
+
+  # Access registry.
+
+  def registry
+    @@registry ||= {}
+  end
+
+  #
+
+  def registry_invalid?(*types)
+    bad = []
+    types.each do |type|
+      bad << type unless @@registry[type]
+    end
+    return bad.empty? ? false : bad
+  end
+
+end

data/meta/contact

@@ -0,0 +1 @@
+rubyworks-mailinglist@googlegroups.com

data/meta/description

@@ -0,0 +1,6 @@
+Ruby Mixers is collection mixin modules for the Ruby
+programming language. Mixers is a spin-off of Ruby
+Facets. When Ruby Facets scaled back to extensions
+only project, it's mixin modules were gathered to
+create this new project.
+

data/meta/homepage

@@ -0,0 +1 @@
+http://rubyworks.github.com/mixers

data/meta/name

@@ -0,0 +1 @@
+mixers

data/meta/resource/development

@@ -0,0 +1 @@
+http://github.com/rubyworks/mixers

data/meta/resource/homepage

@@ -0,0 +1 @@
+http://rubyworks.github.com/mixers

data/meta/suite

@@ -0,0 +1 @@
+rubyworks

data/meta/summary

@@ -0,0 +1 @@
+Collection of helpful mixin modules

data/meta/version

@@ -0,0 +1 @@
+1.0.0

data/test/test_advisable.rb

@@ -0,0 +1,69 @@
+require 'mixers/advisable'
+require 'test/unit'
+
+class TestAdvice < Test::Unit::TestCase
+
+  class X
+    include Advisable
+
+    attr_reader :out
+
+    def initialize
+      @out = []
+    end
+
+    before :x do
+      @out << "BEFORE X#x"
+    end
+
+    after :x do
+      @out << "AFTER X#x"
+    end
+
+    def x
+      @out << "X#x"
+      "x"
+    end
+  end
+
+  class Y < X
+    before :x do
+      @out << "BEFORE Y#x"
+    end
+
+    after :x do
+      @out << "AFTER Y#x"
+    end
+
+    around :x do |target|
+      "{" + target.call + "}"
+    end
+
+    def x
+      @out << "Y#x"
+      super
+    end
+  end
+
+  # tests
+
+  def setup
+    @x = X.new
+    @y = Y.new
+  end
+
+  def test_x
+    r = @x.x
+    o = @x.out
+    assert_equal("x", r)
+    assert_equal(["BEFORE X#x", "X#x", "AFTER X#x"], o)
+  end
+
+  def test_y
+    r = @y.x
+    o = @y.out
+    assert_equal("{x}", r)
+    assert_equal(["BEFORE Y#x", "BEFORE X#x", "Y#x", "X#x", "AFTER X#x", "AFTER Y#x"], o)
+  end
+
+end

data/test/test_cloneable.rb

@@ -0,0 +1,41 @@
+require 'mixers/cloneable'
+require 'test/unit'
+
+class Foo
+  include Cloneable
+  def initialize
+    @bar=[]
+  end
+  def bar_id
+    @bar.object_id
+  end
+end
+
+class TestCloneable < Test::Unit::TestCase
+  def test_dup
+    a=Foo.new
+    b=a.dup
+    assert_not_equal a.bar_id,b.bar_id
+
+    a.taint
+    b=a.dup
+    assert b.tainted?, "b should be tainted"
+
+    a.freeze
+    b=a.dup
+    assert !b.frozen?, "b should not be frozen"
+  end
+  def test_clone
+    a=Foo.new
+    b=a.clone
+    assert_not_equal a.bar_id,b.bar_id
+
+    a.taint
+    b=a.dup
+    assert b.tainted?, "b should be tainted"
+
+    a.freeze
+    b=a.clone
+    assert b.frozen?, "b should be frozen"
+  end
+end

data/test/test_enumargs.rb

@@ -0,0 +1,70 @@
+require 'mixers/enumargs'
+require 'test/unit'
+
+# fixture
+
+class PlusArray
+  include Enumerable::Arguments
+  def initialize(arr)
+    @arr = arr
+  end
+  def each(n=0)
+    @arr.each{ |e| yield(e+n) }
+  end
+end
+
+class TC_Enumerable < Test::Unit::TestCase
+
+  def test_collect
+    t = PlusArray.new([1,2,3])
+    assert_equal( [5,6,7], t.collect(4){ |e| e } )
+  end
+
+  #def test_each_slice
+  #  t = PlusArray.new([1,2,3,4])
+  #  a = []
+  #  t.each_slice(2,4){ |e,f| a << [e,f] }
+  #  assert_equal( [[5,6],[7,8]], a )
+  #end
+
+  #def test_find
+  #  t = PlusArray.new([1,2,3,4])
+  #  f = t.find(2, :ifnone=>lambda{:NOPE}) { |a| a == 10 }
+  #  assert_equal(:NOPE, f)
+  #end
+
+  def test_grep
+    # TODO
+  end
+
+  def test_to_a
+    t = PlusArray.new([1,2,3])
+    assert_equal( [5,6,7], t.to_a(4) )
+  end
+
+  def test_min
+    t = PlusArray.new([1,2,3])
+    assert_equal( 5, t.min(4) )
+  end
+
+  def test_max
+    t = PlusArray.new([1,2,3])
+    assert_equal( 7, t.max(4) )
+  end
+
+  def test_include?
+    t = PlusArray.new([1,2,3])
+    assert( t.include?(7,4) )
+  end
+
+  def test_select
+    t = PlusArray.new([1,2,3])
+    assert_equal( [6], t.select(4){ |x| x == 6 } )
+  end
+
+  def test_reject
+    t = PlusArray.new([1,2,3])
+    assert_equal( [5,7], t.reject(4){ |x| x == 6 } )
+  end
+
+end

data/test/test_equitable.rb

@@ -0,0 +1,42 @@
+require 'mixers/equitable'
+require 'test/unit'
+
+class TestModuleEquatable < Test::Unit::TestCase
+
+  def test_equatable_with_arguments
+    c = Class.new
+    c.class_eval { 
+      include Equitable(:a,:b)
+      attr_accessor :a, :b
+    }
+    c1,c2 = c.new,c.new
+    c1.a = 10; c1.b = 20
+    c2.a = 10; c2.b = 20
+    assert_equal( c1, c2 )
+    c1.a = 10; c1.b = 10
+    c2.a = 10; c2.b = 20
+    assert_not_equal( c1, c2 )
+    c1.a = 10; c1.b = 20
+    c2.a = 20; c2.b = 20
+    assert_not_equal( c1, c2 )
+  end
+
+=begin
+  def test_equate_on_old
+    c = Class.new
+    c.class_eval { attr_accessor :a, :b ; equate_on :a,:b }
+    c1,c2 = c.new,c.new
+    c1.a = 10; c1.b = 20
+    c2.a = 10; c2.b = 20
+    assert_equal( c1, c2 )
+    c1.a = 10; c1.b = 10
+    c2.a = 10; c2.b = 20
+    assert_not_equal( c1, c2 )
+    c1.a = 10; c1.b = 20
+    c2.a = 20; c2.b = 20
+    assert_not_equal( c1, c2 )
+  end
+=end
+
+end
+

data/test/test_instantiable.rb

@@ -0,0 +1,37 @@
+require 'mixers/instantiable'
+require 'test/unit'
+
+class TestInstantiable < Test::Unit::TestCase
+
+  module M
+    extend Instantiable
+
+    attr :a
+
+    def initialize( a )
+      @a = a
+    end
+  end
+
+  module N
+    include Instantiable
+
+    attr :a
+
+    def initialize( a )
+      @a = a
+    end
+  end
+
+  def test_m_new
+    m = M.new( 1 )
+    assert_equal( 1, m.a )
+  end
+
+  def test_n_new
+    m = N.new( 1 )
+    assert_equal( 1, m.a )
+  end
+
+end
+

data/test/test_preinitilizable.rb

@@ -0,0 +1,35 @@
+require 'mixers/preinitilizable'
+require 'test/unit'
+
+class TC_Preinitalizable < Test::Unit::TestCase
+
+  module M
+    include Preinitializable
+    def preinitialize
+      @a = 10
+    end
+  end
+
+  class X
+    include M
+    def a; @a ; end
+  end
+
+  class Y < X
+    def initialize
+      super
+    end
+  end
+
+  def test_x
+    x = X.new
+    assert_equal(10, x.a)
+  end
+
+  def test_y
+    y = Y.new
+    assert_equal(10, y.a)
+  end
+
+end
+

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification 
+name: mixers
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: []
+
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-27 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: |-
+  Ruby Mixers is collection mixin modules for the Ruby
+  programming language. Mixers is a spin-off of Ruby
+  Facets. When Ruby Facets scaled back to extensions
+  only project, it's mixin modules were gathered to
+  create this new project.
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- lib/mixers/advisable.rb
+- lib/mixers/cloneable.rb
+- lib/mixers/enumargs.rb
+- lib/mixers/equitable.rb
+- lib/mixers/expirable.rb
+- lib/mixers/hook.rb
+- lib/mixers/instantiable.rb
+- lib/mixers/ostructable.rb
+- lib/mixers/preinitilizable.rb
+- lib/mixers/registerable.rb
+- meta/contact
+- meta/description
+- meta/homepage
+- meta/name
+- meta/resource/development
+- meta/resource/homepage
+- meta/suite
+- meta/summary
+- meta/version
+- test/test_advisable.rb
+- test/test_cloneable.rb
+- test/test_enumargs.rb
+- test/test_equitable.rb
+- test/test_instantiable.rb
+- test/test_preinitilizable.rb
+- LICENSE
+- README
+- HISTORY
+has_rdoc: true
+homepage: http://rubyworks.github.com/mixers
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --title
+- Mixers API
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: mixers
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Collection of helpful mixin modules
+test_files: 
+- test/test_advisable.rb
+- test/test_cloneable.rb
+- test/test_enumargs.rb
+- test/test_equitable.rb
+- test/test_instantiable.rb
+- test/test_preinitilizable.rb