glue 0.29.0 → 0.30.0

data/lib/glue/aspects.rb

@@ -1,230 +0,0 @@
-require 'facet/inheritor'
-
-module Glue
-
-# An Aspect is a class that defines advices.
-
-class Aspect
-  class << self 
-    def wrap(target, methods = target.instance_methods, pre = :pre, post = :post)
-      target.send(:include, Glue::Aspects) unless target.ancestors.include?(Glue::Aspects)
-      target.wrap(self, :pre => pre, :post => post)
-    end
-
-    alias_method :observe, :wrap
-  end
-
-  def wrap(target, methods = target.instance_methods, pre = :pre, post = :post)
-    target.send(:include, Glue::Aspects) unless target.ancestors.include?(Glue::Aspects)
-    target.wrap(self, :pre => pre, :post => post)
-  end
-  alias_method :observe, :wrap
-end
-
-# Add support for Aspect Oriented Programming (AOP).
-#
-# === Examples
-#
-# class Controller
-#   pre :force_login, :where => :prepend
-#   wrap Benchmark, :on => :index
-#   post :taraa, :on => login
-# end
-# 
-# module Timestamped
-#   pre :on => :og_insert { |this| this.create_time = Time.now }
-#   pre :on => :og_update { |this| this.update_time = Time.now }
-#   pre :on => [:og_insert, :og_update] { |this| this.create_time = Time.now }
-# end
-
-module Aspects
-
-  # Store the code and the metadata (options) for
-  # an Advice.
-
-  Advice = Struct.new(:code, :options)
-
-  # Apply the advices to the target class.
-
-  def self.wrap(target, methods = target.instance_methods)
-    include_advice_modules(target)
-    
-    for m in [methods].flatten
-      args = []
-      target.instance_method(m).arity.times { |i| args << "a#{i}" }
-      args = args.join(',')
-      
-      target.module_eval <<-end_eval, __FILE__, __LINE__ 
-        alias_method :__unwrapped_#{m}, :#{m}
-        def #{m}(#{args})  
-          #{gen_advice_code(m, target.advices, :pre)}
-          __unwrapped_#{m}(#{args})
-          #{gen_advice_code(m, target.advices, :post)}
-        end
-      end_eval
-    end
-  end
-
-  class << self
-    alias_method :apply_advices, :wrap
-  end
-
-  # Include Modules that define advices.
-
-  def self.include_advice_modules(target)
-    add_advices = []
-    del_advices = []
-    
-    for a in target.advices
-      if a.code.is_a?(Module) and (!a.code.class.ancestors.include?(Class))
-        target.module_eval %{ include #{a.code} }
-        
-        options = a.options.reject { |k,v| k == :pre || k == :post }
-
-        method = (a.options[:pre] || 'pre').to_s
-        if a.code.instance_methods.include?(method)
-          options.update(:where => :prepend, :join => :pre)
-          add_advices <<  Advice.new(method.to_sym, options)
-        end
-        
-        method = (a.options[:post] || 'post').to_s
-        if a.code.instance_methods.include?(method)
-          options.update(:where => :append, :join => :post)
-          add_advices <<  Advice.new(method.to_sym, options)
-        end
-        
-        del_advices << a
-      end
-    end
-
-    # Delete the original advices.
-    
-    for a in del_advices
-      target.advices!.delete(a)
-    end
-    
-    # Add the new advices.
-    
-    target.advices!.concat(add_advices)
-  end
-
-  # Generates the code to call the aspects.
-  
-  def self.gen_advice_code(method, advices, join = :pre) # :nodoc: 
-    code = '' 
-
-    advices.each_with_index do |advice, idx|
-      o = options = advice.options
-
-      if only = options[:only] || options[:on]
-        next unless [only].flatten.include?(method.to_sym)
-      elsif except = options[:except]
-        next if [except].flatten.include?(method.to_sym)
-      end
-      
-      advice = advice.code
-
-      if advice.is_a?(Symbol) or advice.is_a?(String)
-        next if o[:join] != join
-        code << "#{advice}; "
-      elsif advice.respond_to?('call')
-        next if o[:join] != join 
-        code << "self.class.advices[#{idx}].code.call(self); "
-      elsif advice.is_a?(Class)
-        if advice.class.ancestors.include?(Class)
-          if m = o[join] and advice.methods.include?(m.to_s)
-            code << "#{advice}.#{m}(self); "
-          end
-        else
-          # Module, allready handled.
-        end
-      else
-        if m = o[join] and advice.methods.include?(m.to_s)
-          code << "self.class.advices[#{idx}].code.#{m}(self); "
-        end
-      end
-    end
-    
-    return code
-  end  
-
-  def self.append_features(base)
-    super
-    base.extend(ClassMethods)
-    base.inheritor :advices, [], :+
-  end
-
-  module ClassMethods
-  
-    # Add a pre (before) advice.
-
-    def pre(*args, &block)
-      o = options = { 
-        :join => :pre,
-        :where => :prepend, 
-      }
-      options.update(args.pop) if args.last.is_a?(Hash)
-
-      if block_given?
-        new_advices = [ Advice.new(block, options) ]
-      else
-        new_advices = args.collect { |a| Advice.new(a, options) }
-      end
-=begin      
-      if options[:where] == :prepend
-        self.advices = advices + self.advices
-      else
-        self.advices = self.advices + advices
-      end
-=end
-      self.advices!.concat(new_advices)
-    end
-    alias_method :before, :pre
-    
-    # Add a post (after) advice.
-
-    def post(*args, &block)
-      o = options = { 
-        :join => :post,
-        :where => :append, 
-      }
-      options.update(args.pop) if args.last.is_a?(Hash)
-
-      if block_given?
-        new_advices = [ Advice.new(block, options) ]
-      else
-        new_advices = args.collect { |a| Advice.new(a, options) }
-      end
-=begin      
-      if options[:where] == :prepend
-        self.advices = advices + self.advices
-      else
-        self.advices = self.advices + advices
-      end
-=end      
-      self.advices!.concat(new_advices)
-    end
-    alias_method :after, :post
-
-    # Add a wrap (arround) aspect. An aspect is a class that 
-    # responds to the before and after advices.  
-  
-    def wrap(*args)
-      o = options = {
-        :pre => :pre,
-        :post => :post
-      }
-      options.update(args.pop) if args.last.is_a?(Hash)
-
-      for aspect in args
-        self.advices! << Advice.new(aspect, options)
-      end
-    end
-    alias_method :around, :wrap
-    alias_method :observer, :wrap
-
-  end  
-
-end
-
-end

data/lib/glue/expirable.rb

@@ -1,39 +0,0 @@
-module Glue 
-
-# Generic expiring functionality 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
-
-end
-
-# * George Moschovitis  <gm@navel.gr>

data/lib/glue/on_included.rb

@@ -1,48 +0,0 @@
-# George Moschovitis <gm@navel.gr>
-
-class Module
-
-  # A useful macro for dynamic modules.
-  #--
-  # FIXME: quick and easy implementation, should
-  # come up with something better. The name 
-  # sucks too.
-  #++
-  def on_included(code)
-    tag = caller[0].split(' ').first.split(/\/|\\/).last.gsub(/:|\.|\(|\)/, '_')
-    old = "__included_#{tag}"
-    module_eval %{
-      class << self
-        alias_method :#{old}, :included
-        def included(base)
-          #{old}(base)
-          #{code}
-        end
-      end
-    }
-  end
-end
-
-=begin Testing
-
-module M
-  on_included %{
-    puts 'hello'
-  }
-end
-
-module Q
-  on_included %{
-    puts 'world'
-  }
-  on_included %{
-    puts 'it works'
-  }
-end
-
-class C 
-  include M
-  include Q
-end
-
-=end

data/lib/glue/paramix.rb

@@ -1,233 +0,0 @@
-# gmosx: replaces gems/facet_more-1.0.1/lib/facet/paramix.rb 
-# to make Nitro work, till we come up with a better solution.
-# 
-# This is a temporary solution until the Facets version is 
-# fixed.
-
-#--
-# Parametric Mixins
-#
-# Copyright (c) 2005 Thomas Sawyer and George Moschovitis
-#
-# Ruby 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.
-#
-# ==========================================================================
-#  Revision History
-# --------------------------------------------------------------------------
-#  2005-12-02  trans     * Simplified into fine elegance.
-#  2005-09-19  trans     * Cleaned up and renamed.
-#  2005-04-28  trans     * Added to Calibre.
-# ==========================================================================
-#
-#++
-
-require 'facet/module/basename'
-
-#:title: Parametric Mixins
-#
-# Parametric Mixins provides parameters for mixin modules.
-# Module parameters can be set at the time of inclusion or extension,
-# then accessed via an instance method of the same name as the included
-# module.
-#
-# == Synopsis
-#
-#   module Mixin
-#     def hello
-#       puts "Hello from #{Mixin(:name)}"
-#     end
-#   end
-#
-#   class MyClass
-#     include Mixin, :name => 'Ruby'
-#   end
-#
-#   m = MyClass.new
-#   m.hello -> 'Hello from Ruby'
-#
-# You can view the full set of parameters via the #mixin_parameters
-# class method, which returns a hash keyed on the included modules.
-#
-#   MyClass.mixin_parameters         #=> {Mixin=>{:name=>'Ruby'}}
-#   MyClass.mixin_parameters[Mixin]  #=> {:name=>'Ruby'}
-#
-# To create _dynamic mixins_ you can use the #included callback
-# method along with mixin_parameters method like so:
-#
-#   module Mixin
-#     def included( base )
-#       parms = base.mixin_parameters[self]
-#       base.class_eval {
-#         def hello
-#           puts "Hello from #{parms(:name)}"
-#         end
-#       }
-#     end
-#   end
-#
-# More conveniently a new callback has been added, #included_with_parameters,
-# which passes in the parameters in addition to the base class/module.
-#
-#   module Mixin
-#     def included_with_parameters( base, parms )
-#       base.class_eval {
-#         def hello
-#           puts "Hello from #{parms(:name)}"
-#         end
-#       }
-#     end
-#   end
-#
-# We would prefer to have passed the parameters through the #included callback
-# method itself, but implementation of such a feature is much more complicated.
-# If a reasonable solution presents itself in the future however, we will fix.
-#
-# == Author(s)
-#
-# * George Moschovitis
-# * Thomas Sawyer
-#
-
-class Module
-
-  # Store for module parameters. This is local per module
-  # and indexed on module/class included-into.
-  def mixin_parameters ; @mixin_parameters ||= {} ; end
-
-  alias_method :include_without_parameters, :include
-
-  def include(*args)
-    params = args.last.is_a?(Hash) ? args.pop : {}    
-=begin
-    for mod in args
-      mixin_parameters[mod] = params
-      define_method( mod.basename ) do |key|
-        if params.key?(key)
-          params[key]
-        else
-          super if defined?( super )
-        end
-      end
-    end
-=end
-    r = include_without_parameters(*args)
-    for mod in args
-      mod.included_with_parameters( self, params ) if mod.respond_to?(:included_with_parameters)
-    end
-    r
-  end
-
-  alias_method :extend_without_parameters, :extend
-
-  def extend(*args)
-    params = args.last.is_a?(Hash) ? args.pop : nil
-=begin    
-    for mod in args
-      (class << self; self; end).class_eval do
-        mixin_parameters[mod] = params
-        define_method( mod.basename ) do |key|
-          if params.key?(key)
-            params[key]
-          else
-            super if defined?( super )
-          end
-        end
-      end
-    end
-=end
-    r = extend_without_parameters(*args)
-    extended_with_parameters( self, params ) if method_defined?(:extended_with_parameters)
-    r
-  end
-
-end
-
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-
-=begin test
-
-  require 'test/unit'
-  require 'facet/kernel/adhoc'
-
-  class TC01 < Test::Unit::TestCase
-
-    module M
-      def f
-        M(:p)
-      end
-      def self.included_with_parameters( base, parms )
-      end
-    end
-
-    class C
-      include M, :p => "check"
-    end
-
-    class D
-      include M, :p => "steak"
-    end
-
-    def test_01_001
-      c = C.new
-      assert_equal( "check", c.f )
-    end
-
-    def test_01_002
-      d = D.new
-      assert_equal( "steak", d.f )
-    end
-
-    def test_01_003
-      assert_equal( {M=>{:p => "check"}}, C.mixin_parameters )
-      assert_equal( {M=>{:p => "steak"}}, D.mixin_parameters )
-    end
-
-  end
-
-
-  class TC02 < Test::Unit::TestCase
-
-    module M
-      def f
-        M(:p)
-      end
-    end
-
-    class C
-      extend M, :p => "mosh"
-    end
-
-    class D
-      extend M, :p => "many"
-    end
-
-    def test_02_001
-      assert_equal( "mosh", C.f )
-    end
-
-    def test_02_002
-      assert_equal( "many", D.f )
-    end
-
-    def test_02_003
-      assert_equal( {M=>{:p => "mosh"}}, C.adhoc.mixin_parameters )
-      assert_equal( {M=>{:p => "many"}}, D.adhoc.mixin_parameters )
-    end
-
-  end
-
-=end