mixin 0.4.0

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2008 Christian Herschel Stevenson, Persapient Systems
+
+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,6 @@
+Mixin by Hersch Stevenson (xain)
+
+http://persapient.com/mixin (comming soon)
+
+
+This must be an early beta version.

data/lib/metable.rb

@@ -0,0 +1,8 @@
+require 'mixin'
+
+
+module Metable
+  include Metable::InstanceMethods
+  extend_class_mixin Metable::ClassMethods
+  extend_module_mixin Metable::ClassMethods
+end

data/lib/metable/class_methods.rb

@@ -0,0 +1,77 @@
+require 'metable/instance_methods'
+
+
+module Metable
+  module ClassMethods
+    include InstanceMethods
+
+    # Returns +true+ if the named class method is defined by the invoking class
+    # (or its extended modules or ancestors). Public and protected (yes,
+    # _protected_) class methods are matched.
+    def class_method_defined?(method_name)
+      eigenclass.method_defined? method_name
+    end
+
+    # Returns +true+ if the named public class method is defined by the invoking
+    # class (or its extended modules or ancestors).
+    def public_class_method_defined?(method_name)
+      eigenclass.public_method_defined? method_name
+    end
+
+    # Returns +true+ if the named protected class method is defined by the invoking
+    # class (or its extended modules or ancestors).
+    def protected_class_method_defined?(method_name)
+      eigenclass.protected_method_defined? method_name
+    end
+
+    # Returns +true+ if the named private class method is defined by the invoking
+    # class (or its extended modules or ancestors).
+    def private_class_method_defined?(method_name)
+      eigenclass.private_method_defined? method_name
+    end
+
+
+    alias protected_class_method protected_singleton_method
+
+
+    private
+
+    alias alias_class_method alias_singleton_method
+
+    alias define_class_method define_singleton_method
+    alias define_public_class_method define_singleton_method
+    alias define_protected_class_method define_protected_singleton_method
+    alias define_private_class_method define_private_singleton_method
+
+
+    # Defines an instance method for _name_ which becomes an enclosure around
+    # a given object. The enclosed object is the result of the given block,
+    # which is evaluated within the context of the invoking instance object
+    # using +instance_eval+ at the time in which the enclosure method is first
+    # invoked on that instance. The _access_ argument can be a symbol or string
+    # representing the access level for the enclosure method (public, private,
+    # or protected). The default access level is +private+.
+    def enclosed_attr(name, access = :private, &block) # :doc:
+      define_method name do
+        ea = instance_eval &block
+        eigen_eval { define_method(name) { ea } && __send__(access, name) }
+        ea
+      end
+      __send__ access, name
+    end
+
+
+    def public_enclosure(*names, &block) # :doc:
+      names.each { |name| enclosed_attr name, :public, &block }
+    end
+
+    def private_enclosure(*names, &block) # :doc:
+      names.each { |name| enclosed_attr name, :private, &block }
+    end
+
+    def protected_enclosure(*names, &block) # :doc:
+      names.each { |name| enclosed_attr name, :protected, &block }
+    end
+
+  end
+end

data/lib/metable/instance_methods.rb

@@ -0,0 +1,93 @@
+module Metable
+  module InstanceMethods
+
+    # Returns the invoking object's eigenclass.
+    def eigenclass
+      class << self
+        self
+      end
+    end
+
+    alias metaclass eigenclass
+
+
+    # Evaluates a string containing Ruby source code, or the given block within
+    # the context of the invoking object's eigenclass.
+    #
+    # <tt>_obj_.eigen_eval { _block_ }</tt> would be equivalent to
+    # <tt>_obj_.eigenclass.instance_eval { _block_ }</tt>
+    #
+    # :call-seq:
+    #   eigen_eval(<em>string</em> <, <em>file</em> <, <em>line</em>>>) -> <em>other_obj</em>
+    #   eigen_eval { <em>block</em> }                                   -> <em>other_obj</em>
+    #
+    def eigen_eval(*args, &block)
+      eigenclass.instance_eval(*args, &block)
+    end
+
+
+    # Makes the invoking object's existing singleton methods private.
+    def private_singleton_method(*method_ids)
+      eigen_eval { private *method_ids }
+    end
+
+    # Makes the invoking object's existing singleton methods protected.
+    def protected_singleton_method(*method_ids)
+      eigen_eval { protected *method_ids }
+    end
+
+    # Makes the invoking object's existing singleton methods public.
+    def public_singleton_method(*method_ids)
+      eigen_eval { public *method_ids }
+    end
+
+
+    private
+
+    # Makes _new_id_ an alias of the singleton method _old_id_ within the
+    # invoking object.
+    def alias_singleton_method(new_id, old_id) # :doc:
+      eigen_eval { alias_method new_id, old_id }
+    end
+
+    # Defines a public singleton method on the invoking object (similar to
+    # +define_method+).
+    #
+    # <em>Aliased as</em> +define_public_singleton_method+
+    #
+    # :call-seq:
+    #   define_singleton_method(<em>symbol</em>, <em>method</em>)   -> <em>method</em>
+    #   define_singleton_method(<em>symbol</em>) { <em>block</em> } -> <em>proc</em>
+    #
+    def define_singleton_method(*args, &block) # :doc:
+      eigen_eval { define_method(*args, &block) }
+    end
+
+    alias define_public_singleton_method define_singleton_method # :doc:
+
+    # Defines a private singleton method on the invoking object (similar to
+    # +define_method+).
+    #
+    # :call-seq:
+    #   define_private_singleton_method(<em>symbol</em>, <em>method</em>)   -> <em>method</em>
+    #   define_private_singleton_method(<em>symbol</em>) { <em>block</em> } -> <em>proc</em>
+    #
+    def define_private_singleton_method(*args, &block) # :doc:
+      define_singleton_method(*args, &block)
+      private_singleton_method(args.first)
+    end
+
+    # Defines a protected singleton method on the invoking object (similar to
+    # +define_method+).
+    #
+    # :call-seq:
+    #   define_protected_singleton_method(<em>symbol</em>, <em>method</em>)   -> <em>method</em>
+    #   define_protected_singleton_method(<em>symbol</em>) { <em>block</em> } -> <em>proc</em>
+    #
+    def define_protected_singleton_method(*args, &block) # :doc:
+      define_singleton_method(*args, &block)
+      protected_singleton_method(args.first)
+    end
+
+  end
+end

data/lib/mixin.rb

@@ -0,0 +1,152 @@
+require 'metable/class_methods'
+
+
+# Mixin is an extension to +Module+ that is intended to ease the development
+# of mixins that involve both class and instance methods.
+#
+module Mixin
+  include Metable::InstanceMethods
+  extend Metable::ClassMethods
+
+  class ModuleMixin < Module # :nodoc:
+    include Metable::InstanceMethods
+
+    def initialize(mixin)
+      define_private_singleton_method(:mixin) { mixin }
+      super()
+    end
+
+    def module_eval(*args, &block)
+      mixin.eigenclass.module_eval *args, &block
+      super
+    end
+
+    alias class_eval module_eval
+  end
+
+
+  enclosed_attr(:__class_mixin__) { Module.new }
+  enclosed_attr(:__module_mixin__) { ModuleMixin.new(self) }
+
+
+  # Extends the given modules to the classes that subsequently include the
+  # invoking module or one of its submodules.
+  #
+  # Calling <tt>SomeMixin.extend_class_mixin(SomeClassMethods)</tt>
+  # would be equivalent to:
+  #
+  #   module SomeMixin
+  #     class_mixin do
+  #       include SomeClassMethods
+  #     end
+  #   end
+  #
+  def extend_class_mixin(*modules)
+    class_mixin { include *modules }
+  end
+
+
+  # Works like +extend_class_mixin+ except that the given modules are instead
+  # extended to the invoking module and the modules that subsequently include
+  # it rather than their including classes.
+  def extend_module_mixin(*modules)
+    module_mixin { include *modules }
+  end
+
+
+  private
+
+  # Returns the invoking modules's +class_mixin+ module object. When a block is
+  # passed, it is evaluated in the context of the +class_mixin+ module.
+  #
+  # Given the module M, M's +class_mixin+ module is included by the +class_mixin+
+  # module of any module that includes M and is extended to any class that
+  # includes M.
+  #
+  #   module Active
+  #     class_mixin do
+  #       def active?; true; end
+  #     end
+  #   end
+  #
+  #   module Hyper
+  #     include Active
+  #     class_mixin do
+  #       def hyper?; true; end
+  #     end
+  #   end
+  #
+  #   class HyperClass
+  #     include Hyper
+  #   end
+  #
+  #   HyperClass.active? -> true
+  #   HyperClass.hyper?  -> true
+  #
+  # :call-seq:
+  #   class_mixin { <em>block</em> } -> <em>module</em>
+  #   class_mixin                    -> <em>module</em>
+  #
+  def class_mixin(&block) # :doc:
+    __class_mixin__.module_eval(&block) if block_given?
+    __class_mixin__
+  end
+
+
+  # Works the same as +class_mixin+ except that the invoking module's
+  # +module_mixin+ is instead extended to the invoking module its self rather
+  # than its including classes.
+  #
+  #   module Active
+  #     module_mixin do
+  #       def active_mixin?; true; end
+  #     end
+  #   end
+  #
+  #   module Hyper
+  #     include Active
+  #   end
+  #
+  #   class ActiveClass
+  #     include Active
+  #   end
+  #
+  #   Active.active_mixin?                    -> true
+  #   Hyper.active_mixin?                     -> true
+  #   ActiveClass.respond_to?(:active_mixin?) -> false
+  #
+  # :call-seq:
+  #   module_mixin { <em>block</em> } -> <em>module</em>
+  #   module_mixin                    -> <em>module</em>
+  #
+  def module_mixin(&block) # :doc:
+    __module_mixin__.module_eval(&block) if block_given?
+    __module_mixin__
+  end
+
+  # Call the DRY Police! ;)
+
+
+  def included(submodule)
+    if submodule.kind_of? Class
+      submodule.extend __class_mixin__
+    else
+      submodule.extend_module_mixin __module_mixin__
+      submodule.extend_class_mixin __class_mixin__
+    end
+    super
+  end
+
+end
+
+
+
+[:module_mixin, :extend_module_mixin, :class_mixin, :extend_class_mixin].each do |name|
+  Module.class_eval %Q{
+    def #{name}(*args, &block)
+      extend ::Mixin
+      send :#{name}, *args, &block
+    end
+  }
+end
+Module.class_eval { private :module_mixin, :class_mixin }

data/test/mixin_case.rb

@@ -0,0 +1,220 @@
+$:.unshift "#{File.dirname(__FILE__)}/../lib"
+$:.unshift "#{File.dirname(__FILE__)}/test_subjects"
+
+require 'mixin'
+require 'test/unit'
+
+
+class MixinTest < Test::Unit::TestCase
+
+
+  def meeper_mxns
+    [Meeper, ActiveMeeper, HyperMeeper]
+  end
+
+  def meeper_clss
+    [MeeperCls, ActiveMeeperCls, HyperMeeperCls]
+  end
+
+
+  def assert_no_response(obj, msg, message = nil)
+    assert !obj.respond_to?(msg), message
+  end
+
+
+  def test_respond_to
+    load 'meepers.rb'
+
+    [:meeper_mixin?, :meep].each do |meth|
+      meeper_mxns.each { |mxn| assert_respond_to mxn, meth }
+      meeper_clss.each { |cls| assert_no_response cls, meth }
+    end
+    [:meeper_class?, :says].each do |meth|
+      meeper_mxns.each { |mxn| assert_no_response mxn, meth }
+      meeper_clss.each { |cls| assert_respond_to cls, meth }
+    end
+
+    meeper_mxns[1..-1].each do |mxn|
+      assert_respond_to mxn, :active?
+      assert_no_response mxn, :active_meeper?
+    end
+    meeper_clss[1..-1].each do |cls|
+      assert_no_response cls, :active?
+      assert_respond_to cls, :active_meeper?
+    end
+    assert_no_response Meeper, :active
+    assert_no_response MeeperCls, :active_meeper?
+
+    assert_respond_to HyperMeeper, :hyperactive?
+    assert_no_response HyperMeeperCls, :hyperactive?
+    assert_respond_to HyperMeeperCls, :hyper_meeper?
+    assert_no_response HyperMeeper, :hyper_meeper?
+    meeper_mxns[0..-2].each { |mxn| assert_no_response mxn, :hyperactive? }
+    meeper_clss[0..-2].each { |cls| assert_no_response cls, :hyper_meeper? }
+  end
+
+
+  def test_scope
+    load 'scopers.rb'
+
+    assert M.class_variables.empty?
+    assert M.instance_variables.empty?
+
+    [M::Scoper, M::XScoper, M::ScoperCls, M::XScoperCls].each do |mod|
+      assert_same mod, mod.me
+      assert_same :cls, mod.cls_attr
+    end
+    assert_same :inst, M::Scoper.inst_attr
+    [M::XScoper, M::ScoperCls].each { |mod| assert_nil mod.inst_attr }
+    assert_same :xinst, M::XScoperCls.inst_attr
+    M::XScoper.instance_variable_set :@inst_attr, :woot
+    assert_same :woot, M::XScoper.inst_attr
+  end
+
+
+  def test_hopons
+    load 'meepers.rb'
+    load 'hopons.rb'
+
+    Meeper.module_eval do
+      module_mixin do
+        def newb
+          :newbie
+        end
+      end
+      class_mixin do
+        def noob
+          :nooby
+        end
+      end
+    end
+
+    meeper_mxns.each { |mxn| assert_respond_to mxn, :newb }
+    meeper_clss.each { |cls| assert_respond_to cls, :noob }
+
+    Meeper.module_eval do
+      include Duck
+      module_mixin do
+        include Plain
+      end
+      class_mixin do
+        include Plain
+      end
+    end
+
+    assert_respond_to Meeper, :quack
+    assert_respond_to Meeper, :flavor
+    (meeper_mxns[1..-1] + meeper_clss).each do |mod|
+      assert_no_response mod, :quack
+      assert_no_response mod, :flavor
+    end
+  end
+
+
+  def test_extenders
+    load 'extenders.rb'
+    load 'hopons.rb'
+
+    assert_same :module, Xtendr.nudge
+    assert_same :module, Xtendrer.nudge
+    assert_same :class, Xtended.nudge
+    assert_same :class, Xtendedr.nudge
+    assert_same :mod_mxn_ping, Xtendr.ping
+    assert_same :mod_mxn_ping, Xtendrer.ping
+    assert_same :cls_mxn_ping, Xtended.ping
+    assert_same :cls_mxn_ping, Xtendedr.ping
+
+    Xtendr.extend_module_mixin Plain
+    Xtendr.extend_class_mixin Plain
+
+    assert_same :vanilla, Xtendr.flavor
+    assert_no_response Xtendrer, :flavor
+    assert_no_response Xtended, :flavor
+
+    xhaustv = Module.new { include Xtendr }
+    xhausted = Class.new { include Xtendr }
+    assert_same :vanilla, xhaustv.flavor
+    assert_same :vanilla, xhausted.flavor
+  end
+
+
+  def test_includers
+    load 'includers.rb'
+    load 'hopons.rb'
+
+    assert_same :module, Includr.nudge
+    assert_same :module, Includrer.nudge
+    assert_same :class, Included.nudge
+    assert_same :class, Includedr.nudge
+    assert_same :mod_mxn_ping, Includr.ping
+    assert_same :mod_mxn_ping, Includrer.ping
+    assert_same :cls_mxn_ping, Included.ping
+    assert_same :cls_mxn_ping, Includedr.ping
+
+    Includr.module_eval do
+      module_mixin { include Plain }
+    end
+    Includr.module_eval do
+      class_mixin { include Plain }
+    end
+
+    assert_same :vanilla, Includr.flavor
+    assert_no_response Includrer, :flavor
+    assert_no_response Included, :flavor
+
+    xhaustv = Module.new { include Includr }
+    xhausted = Class.new { include Includr }
+    assert_same :vanilla, xhaustv.flavor
+    assert_same :vanilla, xhausted.flavor
+  end
+
+
+  def test_supers
+    load 'soopers.rb'
+
+    assert_equal [0,1], Soopr1.giv_er
+    assert_equal [0,1,2], Soopr2.giv_er
+    assert_equal [0,1,2,3], Soopr3.giv_er
+
+    assert_equal [1,0], SooprC1.giv_em
+    assert_equal [2,1,0], SooprC2.giv_em
+    assert_equal [3,2,1,0], SooprC3.giv_em
+
+    assert_equal [0,1,2,3,7,9], Soopr4.giv_er
+    assert_equal [666,9,7,3,2,1,0], SooprC4.giv_em
+  end
+
+
+  def test_laziness
+    load 'sleepers.rb'
+
+    [LazyModExt, LazyClsExt, LazyModMxn, LazyClsMxn].each do |mxn|
+      assert_kind_of Mixin, mxn
+    end
+    assert SansMxn.private_methods.include?('module_mixin')
+    assert SansMxn.private_methods.include?('class_mixin')
+    assert !SansMxn.kind_of?(Mixin)
+    SansMxn.extend_class_mixin Module.new
+    assert_kind_of Mixin, SansMxn
+  end
+
+
+  def test_module_mixin_module_eval
+    load 'meepers.rb'
+
+    Meeper.module_eval do
+      module_mixin.module_eval do
+        def rico?
+          true
+        end
+      end
+      module_mixin.class_eval %Q{
+        def suave?
+          true
+        end
+      }
+    end
+    assert Meeper.rico? && Meeper.suave?
+  end
+
+end

data/test/test_subjects/extenders.rb

@@ -0,0 +1,33 @@
+require 'nudgers'
+
+
+module Xtendr
+  extend_module_mixin ModNudgr
+  extend_class_mixin ClsNudgr
+
+  module_mixin do
+    def ping
+      :mod_mxn_ping
+    end
+  end
+
+  class_mixin do
+    def ping
+      :cls_mxn_ping
+    end
+  end
+end
+
+
+module Xtendrer
+  include Xtendr
+end
+
+
+class Xtended
+  include Xtendr
+end
+
+class Xtendedr
+  include Xtendrer
+end

data/test/test_subjects/hopons.rb

@@ -0,0 +1,20 @@
+module Duck
+  module_mixin do
+    def quack
+      :mod_quack
+    end
+  end
+
+  class_mixin do
+    def quack
+      :cls_quack
+    end
+  end
+end
+
+
+module Plain
+  def flavor
+    :vanilla
+  end
+end

data/test/test_subjects/includers.rb

@@ -0,0 +1,34 @@
+require 'nudgers'
+
+
+module Includr
+  module_mixin do
+    include ModNudgr
+
+    def ping
+      :mod_mxn_ping
+    end
+  end
+
+  class_mixin do
+    include ClsNudgr
+
+    def ping
+      :cls_mxn_ping
+    end
+  end
+end
+
+
+module Includrer
+  include Includr
+end
+
+
+class Included
+  include Includr
+end
+
+class Includedr
+  include Includrer
+end

data/test/test_subjects/meepers.rb

@@ -0,0 +1,76 @@
+[:Meeper, :MeeperCls, :ActiveMeeper, :ActiveMeeperCls, :HyperMeeper, :HyperMeeperCls].each do |mod|
+  if Object.const_defined?(mod)
+    Object.send(:remove_const, mod)
+  end
+end
+
+
+module Meeper
+
+  module_mixin do
+    def meeper_mixin?
+      true
+    end
+
+    def meep
+      :meep
+    end
+  end
+
+  class_mixin do
+    def meeper_class?
+      true
+    end
+
+    def says
+      :meep
+    end
+  end
+end
+
+
+module ActiveMeeper
+  include Meeper
+
+  module_mixin do
+    def active?
+      true
+    end
+  end
+
+  class_mixin do
+    def active_meeper?
+      true
+    end
+  end
+end
+
+
+module HyperMeeper
+  include ActiveMeeper
+
+  module_mixin do
+    def hyperactive?
+      true
+    end
+  end
+
+  class_mixin do
+    def hyper_meeper?
+      true
+    end
+  end
+end
+
+
+class MeeperCls
+  include Meeper
+end
+
+class ActiveMeeperCls
+  include ActiveMeeper
+end
+
+class HyperMeeperCls
+  include HyperMeeper
+end

data/test/test_subjects/nudgers.rb

@@ -0,0 +1,21 @@
+module Pingr
+  def ping
+    :mod_ping
+  end
+end
+
+
+module ModNudgr
+  include Pingr
+  def nudge
+    :module
+  end
+end
+
+
+module ClsNudgr
+  include Pingr
+  def nudge
+    :class
+  end
+end

data/test/test_subjects/scopers.rb

@@ -0,0 +1,50 @@
+module M
+
+  module Scoper
+    @@cls_attr = :cls
+    @inst_attr = :inst
+
+    module_mixin do
+      def cls_attr
+        @@cls_attr
+      end
+
+      def inst_attr
+        @inst_attr
+      end
+
+      def me
+        self
+      end
+    end
+
+    class_mixin do
+      def cls_attr
+        @@cls_attr
+      end
+
+      def inst_attr
+        @inst_attr
+      end
+
+      def me
+        self
+      end
+    end
+  end
+
+  module XScoper
+    include Scoper
+  end
+
+
+  class ScoperCls
+    include Scoper
+  end
+
+  class XScoperCls
+    include XScoper
+    @inst_attr = :xinst
+  end
+
+end

data/test/test_subjects/sleepers.rb

@@ -0,0 +1,18 @@
+module SansMxn
+end
+
+module LazyModExt
+  extend_module_mixin SansMxn
+end
+
+module LazyClsExt
+  extend_class_mixin SansMxn
+end
+
+module LazyModMxn
+  module_mixin {}
+end
+
+module LazyClsMxn
+  class_mixin {}
+end

data/test/test_subjects/soopers.rb

@@ -0,0 +1,120 @@
+module SooprMX
+  def giv_er
+    [0]
+  end
+end
+
+module SooprCX
+  def giv_em
+    [0]
+  end
+end
+
+
+module Soopr1
+  extend_module_mixin SooprMX
+
+  module_mixin do
+    def giv_er
+      super + [1]
+    end
+  end
+
+  class_mixin do
+    include SooprCX
+
+    def giv_em
+      [1] + super
+    end
+  end
+end
+
+
+module Soopr2
+  include Soopr1
+
+  module_mixin do
+    def giv_er
+      super + [2]
+    end
+  end
+
+  class_mixin do
+    def giv_em
+      [2] + super
+    end
+  end
+end
+
+
+module Soopr3
+  include Soopr2
+
+  module_mixin do
+    def giv_er
+      super + [3]
+    end
+  end
+
+  class_mixin do
+    def giv_em
+      [3] + super
+    end
+  end
+end
+
+
+class SooprC1
+  include Soopr1
+end
+
+class SooprC2
+  include Soopr2
+end
+
+class SooprC3
+  include Soopr3
+end
+
+
+
+module DooprMX
+  def giv_er
+    super + [7]
+  end
+end
+
+module DooprCX
+  def giv_em
+    [7] + super
+  end
+end
+
+
+module Soopr4
+  include Soopr3
+  extend_class_mixin DooprCX
+
+  class_mixin do
+    def giv_em
+      [9] + super
+    end
+  end
+
+  module_mixin do
+    include DooprMX
+
+    def giv_er
+      super + [9]
+    end
+  end
+end
+
+
+class SooprC4
+  include Soopr4
+
+  def self.giv_em
+    [666] + super
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+name: mixin
+version: !ruby/object:Gem::Version 
+  version: 0.4.0
+platform: ruby
+authors: 
+- Hersch Stevenson (xian)
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-09-04 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: stevenson@persapient.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+files: 
+- lib/metable/instance_methods.rb
+- lib/metable/class_methods.rb
+- lib/mixin.rb
+- lib/metable.rb
+- test/test_subjects/scopers.rb
+- test/test_subjects/meepers.rb
+- test/test_subjects/extenders.rb
+- test/test_subjects/sleepers.rb
+- test/test_subjects/hopons.rb
+- test/test_subjects/nudgers.rb
+- test/test_subjects/includers.rb
+- test/test_subjects/soopers.rb
+- test/mixin_case.rb
+- README
+- LICENSE
+has_rdoc: true
+homepage: http://www.persapient.com/mixin
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: mixin
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: An extention to Module that is intended to ease the development of mixins that involve both class and instance methods.
+test_files: 
+- test/mixin_case.rb