paramix 1.1.0 → 2.0.0

data/README.rdoc

@@ -1,66 +1,49 @@
 = Paramix
 
-* http://rubyworks.github.com/paramix
-* http://death.rubyforge.org (old site)
+* home: http://rubyworks.github.com/paramix
+* work: http://github.com/rubyworks/paramix
 
 
 == DESCRIPTION
 
-Parametric Mixins provides parameters for mixin modules.
-
-
-== FEATURES/ISSUES
-
-* Include mixins with class level parameterization.
-* Light-weight --it does not resort to cloned anonymous modules.
+Parametric Mixins provides an easy means to "functionalize" modules.
+The module can then be differentiated upon usage according to the
+parameters provided.
 
 
 == RELEASE NOTES
 
-Please see RELEASE file.
-
-
-== SYNOPSIS
-
-   module MyMixin
-     include Paramix
-
-     def hello
-       puts "Hello from #{mixin_parameters[MyMixin][:name]}!"
-     end
-   end
-
-   class MyClass
-     include MyMixin[:name => 'Ruby']
-   end
-
-   m = MyClass.new
-   m.hello   #=> 'Hello from Ruby!'
-
+Please see HISTORY.rdoc file.
 
-== HOW TO INSTALL
 
-Describe your installation procedure here.
+== EXAMPLE
 
-To install with RubyGems simply open a console and type:
+Here is a simple example that uses a a parameter 
+to define a method and another parameter to define
+it's return value.
 
-  gem install paramix
+  module M
+    include Paramix::Parametric
 
-Local installation requires Setup.rb (gem install setup),
-then download the tarball package and type:
+    paramaterized do |params|
+      define_method params[:name] do
+        params[:value]
+      end
+    end
+  end
 
-  tar -xvzf paramix-1.0.0.tgz
-  cd paramix-1.0.0.tgz
-  sudo setup.rb all
+  class X
+    include M[:name=>'foo', :value='bar']
+  end
 
-Windows users use 'ruby setup.rb all'.
+  X.new.foo  #=> 'bar'
 
 
-== LICENSE
+== COPYRIGHTS
 
-Copyright (c) 2006 Coding Dead
+Copyright (c) 2006,2010 Thomas Sawyer
 
-This program is ditributed unser the terms of the LGPLv3 license.
+This program is ditributed unser the terms of the MIT license.
 
 See LICENSE file for details.
 

data/Syckfile

@@ -0,0 +1,87 @@
+---
+announce:
+  service : Email
+  file    : ~
+  subject : ~
+  mailto  : ruby-talk@ruby-lang.org
+  active  : true
+
+grancher:
+  service: grancher
+  active:  true
+
+box:
+  service: Box
+  types  : [gem, tar]
+  active : true
+
+mast:
+  service: Mast
+  include: [bin, demo, lib, meta, test, "[A-Z]*"]
+  exclude: ~
+  active:  true
+
+rdoc:
+  service  : RDoc
+  template : redfish
+  include  : ~
+  exclude  : ~
+  main     : ~
+  extra    : ~
+  active   : true
+
+ridoc:
+  service: RIDoc
+  include: ~
+  exclude: ~
+  active : true
+
+notes:
+  service  : DNotes
+  loadpath : ~
+  labels   : ~
+  output   : ~
+  format   : ~
+  active   : false
+
+stats:
+  service  : Stats
+  title    : ~
+  loadpath : ~
+  exclude  : ~
+  output   : ~
+  active   : true
+
+testrb:
+  service  : testrb
+  tests    : ~
+  exclude  : ~
+  loadpath : ~
+  requires : ~
+  live     : false   
+  active   : true
+
+syntax:
+  service  : Syntax
+  loadpath : ~
+  exclude  : ~
+  active   : false
+
+vclog:
+  service  : VClog
+  format   : html   # xml, txt
+  layout   : rel    # gnu
+  typed    : false
+  output   : ~
+  active   : false
+
+
+#rubyforge:
+#  service : Rubyforge
+#  unixname: <%= project %>
+#  groupid : ~
+#  package : <%= package %>
+#  sitemap:
+#    doc/rdoc: <%= package %>
+#  active  : false
+

data/lib/paramix.rb

@@ -1,190 +1,116 @@
-# = Parametric Mixin
-#
-# Parametric Mixins provides parameters for mixin modules.
-# Module parameters can be set at the time of inclusion 
-# or extension using Module#[] method, then parameters
-# can be accessed via the #mixin_param and #mixin_parameters
-# methods.
-#
-#   module MyMixin
-#     include Paramix
-#
-#     def hello
-#       puts "Hello from #{ mixin_param(MyMixin, :name) }!"
-#     end
-#   end
-#
-#   class MyClass
-#     include MyMixin[:name => 'Ruby']
-#   end
-#
-#   m = MyClass.new
-#   m.hello   #=> 'Hello from Ruby!'
-#
-# You can view the full set of parameters via the +mixin_parameters+ method.
-#
-#   MyClass.mixin_parameters  #=> {MyMixin => {:name => 'ruby'}}
-#
-# Including Paramix into a module is essentially equivalent to defining
-# a module method:
-#
-#   def [](parameters)
-#     Paramix::Proxy.new(self, parameters)
-#   end
-#
-# Paramix::Proxy.new can also take a block that injects code into the
-# mixin. This is useful as an alternative to using the #included
-# callback for creating metaclass dynamics based on mixin parameters.
-# For example:
-#
-#   module MyMixin
-#     def self.[](parameters)
-#       Paramix::Mixin.new(self, parameters) do
-#         attr_accessor parameters[MyMixin][:name]
-#       end
-#     end
-#   end
-#
-# As opposed to:
-#
-#   module MyMixin
-#     include Paramix
-#
-#     def self.included(base)
-#       base.class_eval do
-#         attr_accessor base.mixin_parameters[:name]
-#       end
-#       super(base)
-#     end
-#   end
+# paramix.rb, Copyright (c)2010 Thomas Sawyer [MIT License]
+
+# Paramix project namespace.
 #
 module Paramix
 
+  # = Parametric
   #
-  def self.included(base)
-    base.extend(ClassMethods)
-    super(base)
-  end
-
+  # Parametric mixins provides parameters for mixin modules.
+  # Module parameters can be set at the time of inclusion 
+  # or extension using Module#[] method, then parameters
+  # can be accessed via the #mixin_parameters method.
   #
-  module ClassMethods
-    def [](parameters)
-      Proxy.new(self, parameters)
-    end
-
-    def included(base)
-      base.extend(ClassMethods)
-      super(base)
-    end
-  end
-
-  class Proxy < Module
-    attr :mixin
-    attr :parameters
-    attr :block
+  #   module MyMixin
+  #     include Paramix::Parametric
+  #
+  #     parameterized |params|
+  #       define_method :hello do
+  #         puts "Hello from #{params[:name]}!"
+  #       end
+  #     end
+  #   end
+  #
+  #   class MyClass
+  #     include MyMixin[:name => 'Ruby']
+  #   end
+  #
+  #   MyClass.new.hello   #=> 'Hello from Ruby!'
+  #
+  #
+  module Parametric
 
     #
-    def initialize(mixin, parameters, &block)
-      @mixin      = mixin
-      @parameters = parameters || {}
-      @block      = block
+    def self.included(base)
+      base.extend(Extensions)
     end
 
     #
-    def append_features(base)
-      mixin = @mixin
-
-      base.mixin_parameters[mixin] ||= {}
-      base.mixin_parameters[mixin].update(@parameters)
+    module Extensions
+      #
+      def [](parameters={})
+        Mixin.new(self, parameters)
+      end
 
-      mixin.module_eval{ append_features(base) }
+      #
+      def parameterized(&code)
+        @code ||= []
+        if block_given?
+          @code << code
+        else
+          @code
+        end
+      end
 
-      base.module_eval{ include InstanceParameterize }
-      #base.extend ClassParameterize
+      def append_features(base)
+        return super(base) if Mixin === base || Mixin === self
 
-      mixin.module_eval{ included(base) }
+        base.extend(Extensions)
 
-      base.module_eval(&@block) if @block
-    end
+        anc = ancestors.find{ |a| a.respond_to?(:parameterized) }
+        base.parameterized.concat(anc.parameterized)
 
-    #
-    def extend_object(base)
-      mixin = @mixin
+        super(base)
+      end
 
-      metabase = (class << base; self; end)
+      #
+      def extend_object(base)
+        return super(base) if Mixin === base || Mixin === self
 
-      metabase.mixin_parameters[mixin] ||= {}
-      metabase.mixin_parameters[mixin].update(@parameters)
+        base.extend(Extensions)
 
-      mixin.module_eval{ extend_object(base) }
+        anc = ancestors.find{ |a| a.respond_to?(:parameterized) }
+        base.parameterized.concat(anc.parameterized)
 
-      base.extend ClassParameterize
+        super(base)
+      end
 
-      metabase.module_eval(&@block) if @block
     end
 
+    # An instance of the Mixin module class is what is porduced
+    # when parameters are applied to a parametric module.
     #
-    module InstanceParameterize
-      #
-      def mixin_param(m, n)
-        h = {}; r = nil
-        self.class.ancestors.each do |a|
-          break if Paramix == a
-          break if m == a
-          q = a.mixin_parameters
-          #if q = Paramix.mixin_params[a]
-            if q[m] && q[m].key?(n)
-              r = q[m][n]
-            else
-              q.each do |k,v|
-                h.update(v)
-              end
-            end
-          #end
+    class Mixin < Module
+
+      def initialize(base, parameters)
+        include(base)
+        #base.append_features(self)
+        base.parameterized.each do |code|
+          instance_exec(parameters, &code)
         end
-        r ? r : h[n]
+        #base.parameterized.clear
       end
-    end
 
-    #
-    module ClassParameterize
       #
-      def mixin_param(m, n)
-        h = {}; r = nil
-        ancestors.each do |a|
-          break if Paramix==a
-          if q = a.meta_class.mixin_parameters #[class << a; self ; end]
-          #if q = Paramix.mixin_params[class << a; self ; end]
-            if q[m] && q[m].key?(n)
-              r = q[m][n]
-            else
-              q.each do |k,v|
-                h.update(v)
-              end
-            end
-          end
-        end
-        r ? r : h[n]
+      def public(name, &code)
+        define_method(name, &code)
+        super(name)
       end
-    end
 
-  end
+      #
+      def private(name, &code)
+        define_method(name, &code)
+        super(name)
+      end
 
-end
+      #
+      def protected(name, &code)
+        define_method(name, &code)
+        super(name)
+      end
 
-#
-class Module
+    end
 
-  def mixin_parameters
-    @mixin_params ||= {}
   end
 
-  alias_method :mixin_params, :mixin_parameters
-
-end
-
-module Kernel
-  def meta_class
-    (class << self; self; end)
-  end
 end