mixin 0.7.1 → 1.0.0

data/README

@@ -24,17 +24,17 @@ Mixin comes in handy in following situations:
   (similar to defining a hierarchy of abstract base classes). This includes calls
   to +super+ to invoke a "super-mixin's" implementation of a given class method.
 
-* When you wish that certian module methods would get 'inherited' by including
-  modules in the same manner that class methods get inherited by subclasses.
-
 * When you simply get tired of writing the same old "<tt>def self.inherited(base);
   base.extend(ClassMethods)</tt>" method (or some variation of it) over and over
   again, thereby violating the sacred DRY principle ;)
 
-== Example
+== Examples
 
   require 'mixin'
 
+
+  # Some common uses:
+
   module FooBase
     @@foo_class_attr = "FooBase's class attribute"
 
@@ -44,6 +44,10 @@ Mixin comes in handy in following situations:
         @@foo_class_attr + " accessed from FooBase's class mixin"
       end
 
+      def about_foo
+        "Some Base Foo"
+      end
+
     end
   end
 
@@ -57,6 +61,10 @@ Mixin comes in handy in following situations:
         @@foo_class_attr + " accessed from FooExtended's class mixin"
       end
 
+      def about_foo
+        super + " Extended"
+      end
+
     end
   end
 
@@ -67,18 +75,32 @@ Mixin comes in handy in following situations:
 
   FooBar.foo_class_method         -> "FooBase's class attribute accessed from FooBase's class mixin"
   FooBar.another_foo_class_method -> "FooBase's class attribute accessed from FooExtended's class mixin"
+  FooBar.about_foo                -> "Some Base Foo Extended"
+
+
+  # Get'n clever:
+
+  module Me
+    class_extend self
+
+    def me
+      self
+    end
+  end
+
+  class Bob
+    include Me
+  end
+
+  Bob.new.me -> #<Bob:0x801b0a7d0>
+  Bob.me     -> Bob
+
 
+  # Get'n meta:
 
-== Extra Stuff
+  (module Fud; class_mixin; end).inspect -> "#<ClassMixin:Fud>"
 
-As briefly mentioned above, Mixin also provides a way to define module methods
-on a mixin that get 'inherited' by including modules, but that are not extended
-to classes. The semantics for defining such methods are identical to defining
-class methods via +_class_mixin_+ (see +module_mixin+).
 
-Also packaged with Mixin is the bonus mixin Metable which provides a fistful
-of useful metaprogramming-friendly methods such as +alias_singleton_method+ and
-+define_class_method+.
 
 == Installation
 

data/lib/mixin.rb

@@ -1,32 +1,21 @@
-require 'metable/class_methods'
-
-
 module Mixin
-  include Metable::InstanceMethods
-  extend Metable::ClassMethods
-
 
-  class ModuleMixin < SingletonMixin = Class.new(Module) # :nodoc:
-    include Metable::InstanceMethods
+  class ClassMixin < Module # :nodoc:
 
     def initialize(mixin)
-      define_private_singleton_method(:mixin) { mixin }
-      super()
+      (class << self; self; end).instance_eval do
+        define_method(:instance_mixin) { mixin }
+      end
+      super() # just in case
     end
 
-    def module_eval(*args, &block)
-      mixin.eigenclass.module_eval *args, &block
-      super
+    def to_s
+      "#<ClassMixin:#{instance_mixin.to_s}>"
     end
 
-    alias class_eval module_eval
   end
 
 
-  lazy_attr(:__class_mixin__) { SingletonMixin.new }
-  lazy_attr(:__module_mixin__) { ModuleMixin.new(self) }
-
-
   # Extends the given modules to the classes that subsequently include the
   # invoking module or one of its submodules.
   #
@@ -40,15 +29,7 @@ module Mixin
   #   end
   #
   def class_extend(*modules)
-    class_mixin { include *modules }
-  end
-
-
-  # Works like +class_extend+ 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 module_extend(*modules)
-    module_mixin { include *modules }
+    class_mixin { include *modules } # told you
   end
 
 
@@ -86,51 +67,24 @@ module Mixin
   #   class_mixin                    -> <em>module</em>
   #
   def class_mixin(&block) # :doc:
-    __class_mixin__.module_eval(&block) if block_given?
+    __class_mixin__.module_eval(&block) if block
     __class_mixin__
   end
 
 
-  # Works the same as +class_mixin+ except that the invoking module's
-  # +module_mixin+ is instead extended to the invoking module itself 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__
+  def __class_mixin__
+    cm = ClassMixin.new(self)
+    (class << self; self; end).module_eval do
+      define_method(:__class_mixin__) { cm }
+      private :__class_mixin__
+    end
+    return cm
   end
 
-  # Call the DRY Police! ;)
 
-
-  def included(submodule)
-    if submodule.kind_of?(Class) || submodule.kind_of?(SingletonMixin)
-      submodule.extend __class_mixin__
-    else
-      submodule.module_extend __module_mixin__
-      submodule.class_extend __class_mixin__
+  def included(mixin)
+    unless ClassMixin === self && ClassMixin === mixin
+      Class === mixin ? mixin.extend(__class_mixin__) : mixin.class_extend(__class_mixin__)
     end
     super
   end
@@ -139,12 +93,18 @@ end
 
 
 
-[:module_mixin, :module_extend, :class_mixin, :class_extend].each do |name|
-  Module.class_eval %Q{
-    def #{name}(*args, &block)
-      extend ::Mixin
-      send :#{name}, *args, &block
-    end
-  }
+class Module # :nodoc:
+
+  def class_extend(*modules)
+    extend ::Mixin
+    class_extend *modules
+  end
+
+  private
+
+  def class_mixin(&block)
+    extend ::Mixin
+    class_mixin &block
+  end
+
 end
-Module.class_eval { private :module_mixin, :class_mixin }

data/test/mixin_case.rb

@@ -25,31 +25,23 @@ class MixinTest < Test::Unit::TestCase
   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?, :meep].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 Meeper, :active_meeper?
     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? }
+    assert_respond_to HyperMeeperCls, :hyper_meeper?
+    meeper_mxns[0..-2].each { |mxn| assert_no_response mxn, :hyper_meeper? }
     meeper_clss[0..-2].each { |cls| assert_no_response cls, :hyper_meeper? }
   end
 
@@ -60,15 +52,14 @@ class MixinTest < Test::Unit::TestCase
     assert M.class_variables.empty?
     assert M.instance_variables.empty?
 
-    [M::Scoper, M::XScoper, M::ScoperCls, M::XScoperCls].each do |mod|
+    [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_nil M::ScoperCls.inst_attr
     assert_same :xinst, M::XScoperCls.inst_attr
-    M::XScoper.instance_variable_set :@inst_attr, :woot
-    assert_same :woot, M::XScoper.inst_attr
+    M::ScoperCls.instance_variable_set :@inst_attr, :woot
+    assert_same :woot, M::ScoperCls.inst_attr
   end
 
 
@@ -77,37 +68,30 @@ class MixinTest < Test::Unit::TestCase
     load 'hopons.rb'
 
     Meeper.module_eval do
-      module_mixin do
-        def newb
-          :newbie
-        end
-      end
       class_mixin do
         def noob
-          :nooby
+          :newbie
         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
+    meeper_clss.each do |cls|
+      assert_no_response cls, :quack
+      assert_no_response cls, :flavor
     end
+
+    Meepian.send :include, Meeper
+    assert_respond_to Meepian, :quack
+    assert_respond_to Meepian, :flavor
   end
 
 
@@ -115,26 +99,19 @@ class MixinTest < Test::Unit::TestCase
     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
+    assert_same :xing, Xtended.ping
+    assert_same :pong, Xtended.pong
+    assert_same :nudge, Xtended.nudge
+    assert_same :xing, Xtendedr.ping
+    assert_same :pong, Xtendedr.pong
+    assert_same :nudge, Xtendedr.nudge
 
-    Xtendr.module_extend Plain
     Xtendr.class_extend Plain
-
-    assert_same :vanilla, Xtendr.flavor
-    assert_no_response Xtendrer, :flavor
     assert_no_response Xtended, :flavor
+    assert_no_response Xtendedr, :flavor
 
-    xhaustv = Module.new { include Xtendr }
-    xhausted = Class.new { include Xtendr }
+    xhaustv = Class.new { include Xtendr }
     assert_same :vanilla, xhaustv.flavor
-    assert_same :vanilla, xhausted.flavor
   end
 
 
@@ -142,89 +119,70 @@ class MixinTest < Test::Unit::TestCase
     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
+    assert_same :ding, Included.ping
+    assert_same :pong, Included.pong
+    assert_same :nudge, Included.nudge
+    assert_same :ding, Includedr.ping
+    assert_same :pong, Includedr.pong
+    assert_same :nudge, Includedr.nudge
 
-    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
+    assert_no_response Includedr, :flavor
 
-    xhaustv = Module.new { include Includr }
-    xhausted = Class.new { include Includr }
+    xhaustv = 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
+    assert_equal [1,0], SooprC1.giv_er
+    assert_equal [2,1,0], SooprC2.giv_er
+    assert_equal [3,2,1,0], SooprC3.giv_er
+    assert_equal [666,9,7,3,2,1,0], SooprC4.giv_er
   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_kind_of Mixin, LazyExt
+    assert_kind_of Mixin, LazyMxn
+
+    assert SansMxn.public_methods.include?('class_extend')
     assert SansMxn.private_methods.include?('class_mixin')
     assert !SansMxn.kind_of?(Mixin)
     SansMxn.class_extend Module.new
     assert_kind_of Mixin, SansMxn
+    assert !SansMxn.public_methods.include?('class_mixin')
+    assert !SansMxn.protected_methods.include?('class_mixin')
   end
 
 
-  def test_module_mixin_module_eval
-    load 'meepers.rb'
+  def test_tips_and_tricks
+    load 'clevers.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?
+    assert_respond_to Adroit, :trick?
+    assert_respond_to Adroit.new, :technique?
+
+    dcm = Deft.send(:class_mixin)
+    assert_same Deft, dcm.instance_mixin
+    assert_equal "#<ClassMixin:Deft>", dcm.to_s
+    assert_equal "#<ClassMixin:Deft>", dcm.inspect
+    assert_equal "", dcm.name
   end
 
 
-  def test_tips_and_tricks
-    load 'clevers.rb'
+  def test_weirdos
+    load 'weirdos.rb'
 
-    assert Clever.trick?
-    assert Adroit.trick?
-    assert Deft.technique?
-    assert Adroit.technique?
+    assert_respond_to Epsilon, :cloned?
+    assert_respond_to Brave.new, :world
   end
 
 end

data/test/test_subjects/clevers.rb

@@ -1,20 +1,19 @@
 module Clever
-  module_extend class_mixin
+  class_extend self
 
-  class_mixin do
-    def trick?
-      true
-    end
+  def trick?
+    true
   end
 end
 
 
 module Deft
-  module_extend self
-  class_extend self
+  include class_mixin
 
-  def technique?
-    true
+  class_mixin do
+    def technique?
+      true
+    end
   end
 end
 

data/test/test_subjects/extenders.rb

@@ -2,18 +2,11 @@ require 'nudgers'
 
 
 module Xtendr
-  module_extend ModNudgr
-  class_extend ClsNudgr
-
-  module_mixin do
-    def ping
-      :mod_mxn_ping
-    end
-  end
+  class_extend Nudgr
 
   class_mixin do
     def ping
-      :cls_mxn_ping
+      :xing
     end
   end
 end

data/test/test_subjects/hopons.rb

@@ -1,13 +1,7 @@
 module Duck
-  module_mixin do
-    def quack
-      :mod_quack
-    end
-  end
-
   class_mixin do
     def quack
-      :cls_quack
+      :quack
     end
   end
 end

data/test/test_subjects/includers.rb

@@ -2,19 +2,11 @@ require 'nudgers'
 
 
 module Includr
-  module_mixin do
-    include ModNudgr
-
-    def ping
-      :mod_mxn_ping
-    end
-  end
-
   class_mixin do
-    include ClsNudgr
+    include Nudgr
 
     def ping
-      :cls_mxn_ping
+      :ding
     end
   end
 end

data/test/test_subjects/meepers.rb

@@ -6,23 +6,12 @@ end
 
 
 module Meeper
-
-  module_mixin do
-    def meeper_mixin?
-      true
-    end
-
-    def meep
-      :meep
-    end
-  end
-
   class_mixin do
-    def meeper_class?
+    def meeper?
       true
     end
 
-    def says
+    def meep
       :meep
     end
   end
@@ -32,12 +21,6 @@ end
 module ActiveMeeper
   include Meeper
 
-  module_mixin do
-    def active?
-      true
-    end
-  end
-
   class_mixin do
     def active_meeper?
       true
@@ -49,12 +32,6 @@ end
 module HyperMeeper
   include ActiveMeeper
 
-  module_mixin do
-    def hyperactive?
-      true
-    end
-  end
-
   class_mixin do
     def hyper_meeper?
       true
@@ -74,3 +51,6 @@ end
 class HyperMeeperCls
   include HyperMeeper
 end
+
+class Meepian
+end

data/test/test_subjects/nudgers.rb

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

data/test/test_subjects/scopers.rb

@@ -4,20 +4,6 @@ module M
     @@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

data/test/test_subjects/sleepers.rb

@@ -1,18 +1,10 @@
 module SansMxn
 end
 
-module LazyModExt
-  module_extend SansMxn
-end
-
-module LazyClsExt
+module LazyExt
   class_extend SansMxn
 end
 
-module LazyModMxn
-  module_mixin {}
-end
-
-module LazyClsMxn
+module LazyMxn
   class_mixin {}
 end

data/test/test_subjects/soopers.rb

@@ -1,29 +1,15 @@
-module SooprMX
+module Sooprb
   def giv_er
     [0]
   end
 end
 
-module SooprCX
-  def giv_em
-    [0]
-  end
-end
-
 
 module Soopr1
-  module_extend SooprMX
-
-  module_mixin do
-    def giv_er
-      super + [1]
-    end
-  end
+  class_extend Sooprb
 
   class_mixin do
-    include SooprCX
-
-    def giv_em
+    def giv_er
       [1] + super
     end
   end
@@ -33,14 +19,8 @@ end
 module Soopr2
   include Soopr1
 
-  module_mixin do
-    def giv_er
-      super + [2]
-    end
-  end
-
   class_mixin do
-    def giv_em
+    def giv_er
       [2] + super
     end
   end
@@ -50,14 +30,8 @@ end
 module Soopr3
   include Soopr2
 
-  module_mixin do
-    def giv_er
-      super + [3]
-    end
-  end
-
   class_mixin do
-    def giv_em
+    def giv_er
       [3] + super
     end
   end
@@ -78,14 +52,8 @@ end
 
 
 
-module DooprMX
+module DooprX
   def giv_er
-    super + [7]
-  end
-end
-
-module DooprCX
-  def giv_em
     [7] + super
   end
 end
@@ -93,19 +61,12 @@ end
 
 module Soopr4
   include Soopr3
-  class_extend DooprCX
 
   class_mixin do
-    def giv_em
-      [9] + super
-    end
-  end
-
-  module_mixin do
-    include DooprMX
+    include  DooprX
 
     def giv_er
-      super + [9]
+      [9] + super
     end
   end
 end
@@ -114,7 +75,7 @@ end
 class SooprC4
   include Soopr4
 
-  def self.giv_em
+  def self.giv_er
     [666] + super
   end
 end

data/test/test_subjects/weirdos.rb

@@ -0,0 +1,44 @@
+# A mixin includes a class_mixin
+# A class_mixin includes a mixin
+# A class_mixin has a class_mixin
+
+module Bokanovsky
+  class_mixin do
+    class_mixin do
+      def cloned?
+        true
+      end
+    end
+  end
+end
+
+
+class Epsilon
+  include Bokanovsky.send(:class_mixin)
+end
+
+
+
+module Infantilism
+end
+
+
+module Hypnopaedia
+  class_mixin # pull in Mixin
+  Infantilism.class_extend self
+
+  def world
+    :hello
+  end
+end
+
+
+module Soma
+  class_mixin
+  include Infantilism.send(:class_mixin)
+end
+
+
+class Brave
+  include Soma
+end

metadata

@@ -1,7 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: mixin
 version: !ruby/object:Gem::Version 
-  version: 0.7.1
+  hash: 23
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
 platform: ruby
 authors: 
 - Hersch Stevenson (xian)
@@ -9,11 +15,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-10-11 00:00:00 -07:00
+date: 2011-03-09 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
-description: 
+description: Mixins made classier!
 email: stevenson@persapient.com
 executables: []
 
@@ -23,48 +29,54 @@ extra_rdoc_files:
 - README
 - LICENSE
 files: 
-- lib/metable/instance_methods.rb
-- lib/metable/class_methods.rb
 - lib/mixin.rb
-- lib/metable.rb
 - test/mixin_case.rb
+- test/test_subjects/clevers.rb
 - test/test_subjects/extenders.rb
-- test/test_subjects/scopers.rb
 - test/test_subjects/hopons.rb
+- test/test_subjects/includers.rb
 - test/test_subjects/meepers.rb
 - test/test_subjects/nudgers.rb
-- test/test_subjects/includers.rb
-- test/test_subjects/soopers.rb
+- test/test_subjects/scopers.rb
 - test/test_subjects/sleepers.rb
-- test/test_subjects/clevers.rb
+- test/test_subjects/soopers.rb
+- test/test_subjects/weirdos.rb
 - README
 - LICENSE
 - Rakefile
 has_rdoc: true
 homepage: http://api.persapient.com/mixin
+licenses: []
+
 post_install_message: 
 rdoc_options: []
 
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: mixin
-rubygems_version: 1.0.1
+rubygems_version: 1.6.2
 signing_key: 
-specification_version: 2
+specification_version: 3
 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

data/lib/metable.rb

@@ -1,54 +0,0 @@
-require 'mixin'
-
-
-# == Metable - The Bonus Mixin
-#
-# Metable is a mixin that provides a bundle of handy methods for the aspiring
-# ruby metaprogrammer.
-#
-# Have you ever wanted an easy way to alias a class method? Check out
-# +alias_class_method+. Have you ever desired a clean way to dynamically define
-# a class method in the same manner you would an instance method using
-# +define_method+ ? Well feast your eyes on +define_class_method+. In fact, you can
-# dynamically define a singleton method on any object the same way with
-# +define_singleton_method+.
-#
-# Metable provides those and many more (see the full list bellow).
-#
-# === Public Instance Methods
-# * eigen_eval
-# * eigenclass <em>(aliased as metaclass)</em>
-# * private_singleton_method
-# * protected_singleton_method
-# * public_singleton_method
-#
-# === Private Instance Methods
-# * alias_singleton_method
-# * define_singleton_method <em>(aliased as define_public_singleton_method)</em>
-# * define_private_singleton_method
-# * define_protected_singleton_method
-#
-# === Public Module Mixin & Class Mixin Methods
-# * class_method_defined?
-# * eigen_eval
-# * eigenclass <em>(aliased as metaclass)</em>
-# * private_class_method_defined?
-# * private_singleton_method
-# * protected_class_method
-# * protected_class_method_defined?
-# * protected_singleton_method <em>(aliased as protected_class_method)</em>
-# * public_class_method_defined?
-# * public_singleton_method
-#
-# === Private Module Mixin & Class Mixin Methods
-# * alias_singleton_method <em>(aliased as alias_class_method)</em>
-# * define_singleton_method <em>(aliased as define_class_method, define_public_class_method, define_public_singleton_method)</em>
-# * define_private_singleton_method <em>(aliased as define_private_class_method)</em>
-# * define_protected_singleton_method <em>(aliased as define_protected_class_method)</em>
-# * lazy_attr
-#
-module Metable
-  include Metable::InstanceMethods
-  class_extend Metable::ClassMethods
-  module_extend Metable::ClassMethods
-end

data/lib/metable/class_methods.rb

@@ -1,83 +0,0 @@
-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 evaluates the _thunk_ the
-    # first time it is invoked on a given instance and returns the resulting
-    # object, and then returns that same object on each subsequent call. The
-    # _thunk_ block is evaluated within the context of the invoking instance
-    # object using +instance_eval+.
-    #
-    # The _access_ argument can be a symbol or string representing the access
-    # level for the defined method (public, private, or protected). The default
-    # access level is +private+.
-    #
-    #   class Foo
-    #     include Metable
-    #     lazy_attr(:time_of_evaluation, :public) { Time.now }
-    #   end
-    #
-    #   foo = Foo.new
-    #   sleep 7
-    #   Time.now                -> Fri Sep 05 16:20:00 -0700 2008
-    #   foo.time_of_evaluation  -> Fri Sep 05 16:20:00 -0700 2008
-    #   sleep 86407
-    #   foo.time_of_evaluation  -> Fri Sep 05 16:20:00 -0700 2008
-    #   foo.instance_variables  -> []
-    #
-    def lazy_attr(name, access = :private, &thunk) # :doc:
-      define_method name do
-        result = instance_eval &thunk
-        eigen_eval do
-          method_defined?(name) && undef_method(name)
-          define_method(name) { result } && __send__(access, name)
-        end
-        result
-      end
-      __send__ access, name
-    end
-
-  end
-end

data/lib/metable/instance_methods.rb

@@ -1,93 +0,0 @@
-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