mixers 1.0.0 → 1.1.0

data/lib/mixers/advisable.rb

@@ -1,9 +1,3 @@
-# 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
@@ -11,138 +5,76 @@ require 'facets/unboundmethod/arguments'
 #
 module Advisable
 
-  def self.append_features(base)
-    base.extend self
-  end
+  require 'facets/proc/bind'
 
-  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] = []}
+  def self.append_features(base)
+    base.extend(self)
   end
 
   def before(meth, &block)
-    name = "#{meth}:before:#{block.object_id}"
-    define_method(name, &block)
-    (advice_before[meth.to_sym] ||= []) << name
+    advice_before[meth.to_sym] << block
+    method_added(meth) if method_defined?(meth)
   end
 
   def after(meth, &block)
-    name = "#{meth}:after:#{block.object_id}"
-    define_method(name, &block)
-    (advice_after[meth.to_sym] ||= []) << name
+    advice_after[meth.to_sym] << block
+    method_added(meth) if method_defined?(meth)
   end
 
   def around(meth, &block)
-    name = "#{meth}:around:#{block.object_id}"
-    define_method(name, &block)
-    (advice_around[meth.to_sym] ||= []) << name
+    advice_around[meth.to_sym] << block
+    method_added(meth) if method_defined?(meth)
   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
+  def advice_before
+    @@advice_before ||= Hash.new{|h,k| h[k] = []}
   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
+  def advice_after
+    @@advice_after ||= Hash.new{|h,k| h[k] = []}
   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_around
+    @@advice_around ||= Hash.new{|h,k| h[k] = []}
+  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
+  # TODO: Should around advice be fed the result of the last around advice?
+  def method_added(meth)
+    @method_added_stack ||= []
+    return if @method_added_stack.last == meth
+    @method_added_stack << meth
 
-    # Call with advice.
+    if advice_before.key?(meth) or advice_after.key?(meth)
 
-    def call_with_advice(obj, *args, &blk)
-      advice_before.each do |name|
-        #advice.call(*args, &blk)
-        obj.send(name, *args, &blk)
-      end
+      before = advice_before[meth]  || []
+      around = advice_around[meth]  || []
+      after  = advice_after[meth]   || []
 
-      target = lambda{ call(*args, &blk) }
-      advice_around.each do |name|
-        target = lambda_target(obj, name, target, *args, &blk)
-      end
-      ret = target.call
+      alias_method "#{meth}:advised", meth
+      target = instance_method("#{meth}:advised")
 
-      advice_after.reverse_each do |name|
-        #advice.call(*args, &blk)
-        obj.send(name, *args, &blk)
+      define_method meth do |*a, &b|
+        before.reverse_each do |block|
+          block.bind(self).call(*a,&b)
+        end
+        if around.empty?
+          result = target.bind(self).call(*a,&b)
+        else
+          around.each do |block|
+            result = block.call(target.bind(self),*a,&b)
+          end
+        end
+        after.each do |block|
+          block.bind(self).call(*a,&b)
+        end
+        result
       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
+    super(meth)
 
+    @method_added_stack.pop
   end
 
 end
 
-class Method #:nodoc:
-  include Advisable::Method
-end
-

data/lib/mixers/expirable.rb

@@ -4,25 +4,34 @@
 #
 module Expirable
 
-  attr_accessor :expires
+  attr_accessor :expiration
 
   # Set the expires timeout for this entry.
 
-  def expires_after(timeout = (60*60*24))
-    @expires = Time.now + timeout
+  def expiration=(time)
+    case time
+    when Time, Date, DateTime
+      @expiration = time
+    else
+      @expiration = Time.now + time
+    end
   end
 
-  # Set the expire timeout for this entry. The timeout happens
-  # after (base + rand(spread)) seconds.
+  #def expires_after(timeout = 86400)
+  #  @expires = Time.now + timeout
+  #end
 
-  def expires_spread(base, spread)
-    @expires = Time.now + base + rand(spread)
-  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)
+    if @expiration.nil? or (Time.now > @expiration)
       return true
     else
       return false

data/lib/mixers/{preinitilizable.rb → preinitialize.rb}

@@ -25,6 +25,7 @@
 #   end
 #
 #   class X
+#     include Preinitializable
 #     include M
 #     def a ; @a ; end
 #   end

data/lib/mixers/registerable.rb

@@ -4,9 +4,9 @@ module Registerable
 
   # Register format names.
 
-  def register(*names)
+  def register(obj, *names)
     names.each do |name|
-      registry[name.to_s] = self
+      registry[name] = obj
     end
   end
 
@@ -27,3 +27,4 @@ module Registerable
   end
 
 end
+

data/meta/authors

@@ -0,0 +1 @@
+Thomas Sawyer

data/meta/repository

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

data/meta/sites/api

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

data/meta/sites/blog

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

data/meta/sites/documentation

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

data/meta/sites/mail

@@ -0,0 +1 @@
+http://groups.google.com/group/rubyworks-mailinglist

data/meta/sites/source

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

data/meta/sites/wiki

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

data/meta/version

@@ -1 +1 @@
-1.0.0
+1.1.0

data/qed/01_advisable.rdoc

@@ -0,0 +1,71 @@
+= Advisable
+
+Require the library.
+
+    require 'mixers/advisable'
+
+We will use this fixture.
+
+    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
+
+Our results:
+
+    x = X.new
+    r = x.x
+    o = x.out
+    r.assert == "x"
+    o.assert == ["BEFORE X#x", "X#x", "AFTER X#x"]
+
+And let's see what a subclass of the example does:
+
+    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
+
+    y = Y.new
+
+The result of #x should be a bracketed "x".
+
+    y.x.assert == "{x}"
+
+Then the out variable should indicate where the call has been.
+
+    y.out.assert == ["BEFORE Y#x", "BEFORE X#x", "Y#x", "X#x", "AFTER X#x", "AFTER Y#x"]
+
+

data/qed/02_cloneable.rdoc

@@ -0,0 +1,46 @@
+= Cloneable
+
+Require the library.
+
+  require 'mixers/cloneable'
+
+We'll use this dummy class.
+
+  class Foo
+    include Cloneable
+    def initialize
+      @bar=[]
+    end
+    def bar_id
+      @bar.object_id
+    end
+  end
+
+Try #dup.
+
+  a = Foo.new
+  b = a.dup
+  b.bar_id.refute == a.bar_id
+
+  a.taint
+  b = a.dup
+  b.assert.tainted?
+
+  a.freeze
+  b = a.dup
+  b.refute.frozen?
+
+Note try #clone.
+
+  a = Foo.new
+  b = a.clone
+  b.bar_id.refute == a.bar_id
+
+  a.taint
+  b = a.dup
+  b.assert.tainted?
+
+  a.freeze
+  b = a.clone
+  b.assert.frozen?
+

data/qed/03_enumargs.rdoc

@@ -0,0 +1,75 @@
+= Enumerable::Arguments
+
+Require the library.
+
+  require 'mixers/enumargs'
+
+This will serve as our example class.
+
+  class PlusArray
+    include Enumerable::Arguments
+
+    def initialize(arr)
+      @arr = arr
+    end
+
+    def each(n=0)
+      @arr.each{ |e| yield(e+n) }
+    end
+  end
+
+Now Enumerable methods such as #map and #collect
+take an argument as well.
+
+  t = PlusArray.new([1,2,3])
+  t.collect(4){ |e| e }.assert == [5,6,7]
+
+Filtering methods such as #select and reject work
+as well.
+
+  t = PlusArray.new([1,2,3])
+  t.select(4){ |x| x == 6 }.assert == [6]
+
+  t = PlusArray.new([1,2,3])
+  t.reject(4){ |x| x == 6 }.assert == [5,7]
+
+We can covert to an array using #to_a with an argument.
+
+  t = PlusArray.new([1,2,3])
+  t.to_a(4).assert == [5,6,7]
+
+We can get the minimum value using #min.
+
+  t = PlusArray.new([1,2,3])
+  t.min(4).assert == 5
+
+And get the maximum value using #min.
+
+  t = PlusArray.new([1,2,3])
+  t.max(4).assert == 7
+
+Methods that already take and argument, now take two
+such as #include?
+
+  t = PlusArray.new([1,2,3])
+  t.assert.include?(7,4)
+
+And #each_slice.
+
+  t = PlusArray.new([1,2,3,4])
+  a = []
+  t.each_slice(2,4){ |e,f| a << [e,f] }
+  a.assert == [[5,6],[7,8]]
+
+The #find method has a slightly different interface
+than the original Enumerable.
+
+  t = PlusArray.new([1,2,3,4])
+  f = t.find(2, :ifnone=>lambda{:NOPE}) { |a| a == 10 }
+  f.assert == :NOPE
+
+The #grep method should also work.
+
+  t = PlusArray.new(['a1','b2','a3','b4'])
+  t.grep(/^b/, 'x').assert == ['b2x','b4x']
+

data/qed/04_equitable.rdoc

@@ -0,0 +1,35 @@
+= Equitqable
+
+Require the library.
+
+  require 'mixers/equitable'
+
+We will use this simple class as an example.
+
+  class C
+    include Equitable(:a,:b)
+
+    attr_accessor :a, :b
+
+    def initialize(a,b)
+      @a = a
+      @b = b
+    end
+  end
+
+Now, if two instance of our sample class +C+ have
+equal attributes +@a+ and +@b+ then they will
+be equal.
+
+  c1 = C.new(10,20)
+  c2 = C.new(10,20)
+  c2.assert == c1
+
+Otherwise they will not be equal.
+
+  c1 = C.new(10, 10)
+  c2 = C.new(10, 20)
+  c2.refute == c1
+
+
+

data/qed/05_instantiable.rdoc

@@ -0,0 +1,42 @@
+= Instantiable
+
+Require the library.
+
+  require 'mixers/instantiable'
+
+We will use this module as an example.
+
+  module M
+    include Instantiable
+
+    attr :a
+
+    def initialize(a)
+      @a = a
+    end
+  end
+
+As we can see M is now fully instantiable, as any
+class would be.
+
+    m = M.new(1)
+    m.a.assert == 1
+
+We can also use #extend rather than #include and
+get the same result.
+
+  module N
+    extend Instantiable
+
+    attr :a
+
+    def initialize( a )
+      @a = a
+    end
+  end
+
+As we saw with +M+ so too with +N+.
+
+  n = N.new( 1 )
+  n.a.assert == 1
+

data/qed/06_expirable.rdoc

@@ -0,0 +1,32 @@
+= Expirable
+
+Require the library.
+
+  require 'mixers/expirable'
+
+Example class.
+
+  class X
+    extend Expirable
+  end
+
+Now the experation can be set to a Time object, or a number of seconds
+from +Time.now+. For instance, to set the expiration for one second
+from now:
+
+  X.expiration = 1
+
+We can see the the object has not yet expired.
+
+  X.refute.expired?
+
+But if we wait one second.
+
+  sleep 1
+
+Then it will have expired.
+
+  X.assert.expired?
+
+Expiration does not invoke a trigger, it is merely queriable.
+

data/qed/08_ostructable.rdoc

@@ -0,0 +1,23 @@
+= OpenStructable
+
+Require the library.
+
+  require 'mixers/ostructable'
+
+We will use the simpliest example class:
+
+  class X
+    include OpenStructable
+  end
+
+  x = X.new
+
+So arbitrary attributes can be added to the object
+just as if it were an OpenStruct.
+
+  x.a = 1
+  x.b = 2
+
+  x.assert.a == 1
+  x.assert.a == 2
+

data/qed/09_preinitialize.rdoc

@@ -0,0 +1,28 @@
+= Preinitialize
+
+Require the library.
+
+    require 'mixers/preinitialize'
+
+Use example module.
+
+   module M
+     def preinitialize
+       @a = 23
+     end
+   end
+
+Define a class to support it.
+
+   class X
+     include Preinitializable
+     include M
+     def a ; @a ; end
+   end
+
+The result should be:
+
+   x = X.new
+   x.a.assert == 23
+
+

data/qed/10_registerable.rdoc

@@ -0,0 +1,40 @@
+= Registerable
+
+Require the library.
+
+  require 'mixers/registerable'
+
+Registerable can be used directly.
+
+  module MyStuff
+    extend Registerable
+  end
+
+  MyStuff.register(10, :x)
+
+Then the MyStuff registry will contain 10 indexed by :x.
+
+  MyStuff.registry[:x].assert == 10
+
+Registrable can also be used as a base class callback to
+track subclasses.
+
+  class Abstract
+    extend Registerable
+
+    def self.inherited(base)
+      register(base, base.name.split('::').last.downcase)
+    end
+  end
+
+Now when we inherit from Abstract, the subclass will
+be automatically registered.
+
+  class Example < Abstract
+  end
+
+We see that the class is in the Abstract registry.
+
+  Abstract.registry['example'].assert == Example
+
+

metadata

@@ -4,17 +4,17 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 1
+  - 1
   - 0
-  - 0
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
-authors: []
-
+authors: 
+- Thomas Sawyer
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2010-04-27 00:00:00 -04:00
+date: 2010-05-07 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -29,8 +29,8 @@ executables: []
 
 extensions: []
 
-extra_rdoc_files: 
-- README
+extra_rdoc_files: []
+
 files: 
 - lib/mixers/advisable.rb
 - lib/mixers/cloneable.rb
@@ -40,17 +40,33 @@ files:
 - lib/mixers/hook.rb
 - lib/mixers/instantiable.rb
 - lib/mixers/ostructable.rb
-- lib/mixers/preinitilizable.rb
+- lib/mixers/preinitialize.rb
 - lib/mixers/registerable.rb
+- meta/authors
 - meta/contact
 - meta/description
-- meta/homepage
 - meta/name
-- meta/resource/development
-- meta/resource/homepage
+- meta/repository
+- meta/sites/api
+- meta/sites/blog
+- meta/sites/development
+- meta/sites/documentation
+- meta/sites/homepage
+- meta/sites/mail
+- meta/sites/source
+- meta/sites/wiki
 - meta/suite
 - meta/summary
 - meta/version
+- qed/01_advisable.rdoc
+- qed/02_cloneable.rdoc
+- qed/03_enumargs.rdoc
+- qed/04_equitable.rdoc
+- qed/05_instantiable.rdoc
+- qed/06_expirable.rdoc
+- qed/08_ostructable.rdoc
+- qed/09_preinitialize.rdoc
+- qed/10_registerable.rdoc
 - test/test_advisable.rb
 - test/test_cloneable.rb
 - test/test_enumargs.rb
@@ -58,7 +74,7 @@ files:
 - test/test_instantiable.rb
 - test/test_preinitilizable.rb
 - LICENSE
-- README
+- README.rdoc
 - HISTORY
 has_rdoc: true
 homepage: http://rubyworks.github.com/mixers
@@ -68,8 +84,6 @@ post_install_message:
 rdoc_options: 
 - --title
 - Mixers API
-- --main
-- README
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 

data/meta/resource/homepage

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