mole 1.0.5 → 1.0.6

data/Manifest.txt

@@ -15,6 +15,98 @@ lib/mole/module.rb
 lib/mole/moler.rb
 lib/mole/utils/frameworks.rb
 lib/mole/version.rb
+notes/notes.txt
+samples/merbapp/README
+samples/merbapp/Rakefile
+samples/merbapp/app/controllers/application.rb
+samples/merbapp/app/controllers/exceptions.rb
+samples/merbapp/app/controllers/moled.rb
+samples/merbapp/app/helpers/global_helper.rb
+samples/merbapp/app/mailers/views/layout/application.html.erb
+samples/merbapp/app/mailers/views/layout/application.text.erb
+samples/merbapp/app/parts/views/layout/application.html.erb
+samples/merbapp/app/views/exceptions/internal_server_error.html.erb
+samples/merbapp/app/views/exceptions/not_acceptable.html.erb
+samples/merbapp/app/views/exceptions/not_found.html.erb
+samples/merbapp/app/views/layout/application.html.erb
+samples/merbapp/app/views/moled/index.html.erb
+samples/merbapp/app/views/moled/result.html.erb
+samples/merbapp/config/boot.rb
+samples/merbapp/config/dependencies.rb
+samples/merbapp/config/environments/development.rb
+samples/merbapp/config/environments/production.rb
+samples/merbapp/config/environments/test.rb
+samples/merbapp/config/merb.yml
+samples/merbapp/config/merb_init.rb
+samples/merbapp/config/mole_config.rb
+samples/merbapp/config/router.rb
+samples/merbapp/config/upload.conf
+samples/merbapp/log/merb.4000.pid
+samples/merbapp/public/images/merb.jpg
+samples/merbapp/public/merb.fcgi
+samples/merbapp/public/stylesheets/master.css
+samples/merbapp/script/destroy
+samples/merbapp/script/generate
+samples/merbapp/script/stop_merb
+samples/merbapp/spec/spec_helper.rb
+samples/merbapp/test/test_helper.rb
+samples/railsapp/README
+samples/railsapp/Rakefile
+samples/railsapp/app/controllers/application.rb
+samples/railsapp/app/controllers/moled_controller.rb
+samples/railsapp/app/helpers/application_helper.rb
+samples/railsapp/app/views/moled/index.html.erb
+samples/railsapp/app/views/moled/result.html.erb
+samples/railsapp/config/boot.rb
+samples/railsapp/config/database.yml
+samples/railsapp/config/environment.rb
+samples/railsapp/config/environments/development.rb
+samples/railsapp/config/environments/production.rb
+samples/railsapp/config/environments/test.rb
+samples/railsapp/config/initializers/inflections.rb
+samples/railsapp/config/initializers/mime_types.rb
+samples/railsapp/config/initializers/mole.rb
+samples/railsapp/config/moles/mole_config.rb
+samples/railsapp/config/routes.rb
+samples/railsapp/doc/README_FOR_APP
+samples/railsapp/log/development.log
+samples/railsapp/log/production.log
+samples/railsapp/log/server.log
+samples/railsapp/log/test.log
+samples/railsapp/public/.htaccess
+samples/railsapp/public/404.html
+samples/railsapp/public/422.html
+samples/railsapp/public/500.html
+samples/railsapp/public/dispatch.cgi
+samples/railsapp/public/dispatch.fcgi
+samples/railsapp/public/dispatch.rb
+samples/railsapp/public/favicon.ico
+samples/railsapp/public/images/rails.png
+samples/railsapp/public/javascripts/application.js
+samples/railsapp/public/javascripts/controls.js
+samples/railsapp/public/javascripts/dragdrop.js
+samples/railsapp/public/javascripts/effects.js
+samples/railsapp/public/javascripts/prototype.js
+samples/railsapp/public/robots.txt
+samples/railsapp/script/about
+samples/railsapp/script/console
+samples/railsapp/script/destroy
+samples/railsapp/script/generate
+samples/railsapp/script/performance/benchmarker
+samples/railsapp/script/performance/profiler
+samples/railsapp/script/performance/request
+samples/railsapp/script/plugin
+samples/railsapp/script/process/inspector
+samples/railsapp/script/process/reaper
+samples/railsapp/script/process/spawner
+samples/railsapp/script/runner
+samples/railsapp/script/server
+samples/railsapp/test/test_helper.rb
+samples/rubyapp/README
+samples/rubyapp/bin/ruby_app
+samples/rubyapp/config/mole_conf.rb
+samples/rubyapp/lib/fred.rb
+spec/config/auto_mole_config.rb
 spec/config/mole_config.rb
 spec/config/moles/fred_config.rb
 spec/data/blee.rb

data/README.txt

@@ -26,6 +26,7 @@ instead.
 * Forum:      http://groups.google.com/group/mole-plugin
 * Home:       mole.rubyforge.org
 * Svn:        svn://rubyforge.org/var/svn/mole/mole/trunk
+* Git:        git://github.com/derailed/mole.git
 * Snitch Svn: svn://rubyforge.org/var/svn/mole/snitch/trunk
 * Examples:   svn://rubyforge.org/var/svn/mole/samples
 
@@ -87,19 +88,21 @@ The MOle allows you to easily
                     :log_level        => :debug,
                     :perf_threshold   => 2,
                     :mole_config      => File.join( File.dirname(__FILE__), %w[mole.rb] ) ) 
-  # Load the MOle configuration file(s)
-  ::Mole.load_configuration                  
+   # Load the MOle configuration file(s)
+   ::Mole.load_configuration                  
                     
   NOTE: The mole_config can either be a single ruby file or a directory containing multiple MOle
   configuration files. Thanks to Ian Schreuder for the suggestion !
   
-  NOTE: For rails application you can either put the MOle initialization code in a custom initializer
-  or in your environment file ie config/environments/production.rb. You will need to make the 
-  load_configuration call in your application controller as follows:
+  NOTE: For rails applications you can either put the MOle initialization code in a custom initializer
+  ie config/initializers/mole.rb or in your environment file (config/environments/production.rb). 
+  You will need to make the load_configuration call in your application controller(application.rb) as follows:
   
     ::Mole.load_mole_configuration rescue nil 
-                  
-                           
+    
+  In dev env, the MOle will reload the configuration so you can tweak your app on the fly. In production
+  env the MOle configuration will be loaded once.
+                             
 * Now you'll need to create a mole.rb specification file to specify the various aspects you'll want
   to inject. This file is specified in the initialize call via the :mole_config tag.
   

data/lib/mole.rb

@@ -191,7 +191,69 @@ unless defined? Mole
     #
     def self.load_all_moles_relative_to( mole_dir ) #:nodoc:
       search_me = ::File.join( mole_dir, '**', '*.rb')
-      Dir.glob(search_me).sort.each {|rb| logger.debug "---- Loading MOle config '#{rb}'";load rb}
+      Dir.glob(search_me).sort.each {|rb| load rb}
     end
+    
+    # Stolen from inflector
+    def self.camelize(lower_case_and_underscored_word)
+      lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+    end
+    
+    # Fetch all ruby files in the given directory and return a cltn of class names
+    def self.find_controller_classes( dir )
+      classes   = []
+      search_me = ::File.expand_path( ::File.join(dir, '*.rb'))
+      Dir.glob(search_me).sort.each {|rb| classes << camelize( File.basename( rb, ".rb") ) }
+      classes
+    end
+    
+    # Automatically setup on perf MOle on any classes within a given directory
+    # NOTE: this call assumes the controller classes are in all in the path    
+    def self.auto_perf( dir, &block )
+      controller_classes = find_controller_classes( dir )
+      controller_classes.each do |class_name|
+        clazz    = Kernel.const_get( class_name )
+        features = ::Mole::Utils::Frameworks.features_for( clazz )
+        clazz.mole_perf( :features => features, &block )
+      end
+    end
+    
+    # Automatically setup MOle untrapped exception on any classes within a given directory
+    # NOTE: this call assumes the controller classes are in all in the path
+    def self.auto_unchecked( dir, &block )
+      controller_classes = find_controller_classes( dir )
+      controller_classes.each do |class_name|
+        clazz    = Kernel.const_get( class_name )
+        features = ::Mole::Utils::Frameworks.features_for( clazz )
+        clazz.mole_unchecked( :features => features, &block )
+      end
+    end
+
+    # Automatically setup MOle after filter on any classes within a given directory
+    # NOTE: this call assumes the controller classes are in all in the path    
+    def self.auto_after( dir, &block )
+      controller_classes = find_controller_classes( dir )
+      controller_classes.each do |class_name|
+        clazz = Kernel.const_get( class_name )
+        features = ::Mole::Utils::Frameworks.features_for( clazz )
+        features.each do |feature|
+          clazz.mole_after( :feature => feature, &block )
+        end
+      end
+    end
+
+    # Automatically setup MOle after filter on any classes within a given directory
+    # NOTE: this call assumes the controller classes are in all in the path    
+    def self.auto_before( dir, &block )
+      controller_classes = find_controller_classes( dir )
+      controller_classes.each do |class_name|
+        clazz = Kernel.const_get( class_name )
+        features = ::Mole::Utils::Frameworks.features_for( clazz )
+        features.each do |feature|
+          clazz.mole_before( :feature => feature, &block )
+        end
+      end
+    end
+    
   end
 end

data/lib/mole/module.rb

@@ -93,7 +93,7 @@ class Module
   # <tt>:interceptor</tt>::   The class name of your interceptor class. If no interceptor block is specified
   # <tt>:method</tt>::        The name of the method to callback the interceptor on
   #                           once an exception condition has been trapped.     
-  def mole_before(opts={}, &interceptor)   
+  def mole_before(opts={}, &interceptor)  
     raise "Missing :feature option" if opts[:feature].nil? or opts[:feature].to_s.empty?
     opts[:interceptor] ||= interceptor
     opts[:method] ||= :call
@@ -133,142 +133,154 @@ class Module
       after_mole_filters[feature] << [opts[:interceptor], opts[:method]]
     end
   end
-          
-  # def dump
-  #   puts "Filters for class <- #{self} ->"
-  #   puts "Before filters"
-  #   before_mole_filters.each_pair do |k,v|
-  #     puts "#{k} --> #{v}"
-  #   end
-  #   puts "After filters"
-  #   after_mole_filters.each_pair do |k,v|
-  #     puts "#{k} --> #{v}"
-  #   end
-  #   puts "Unchecked filters"
-  #   unchecked_mole_filters.each_pair do |k,v|
-  #     puts "#{k} --> #{v}"
-  #   end
-  #   puts "Perf filters"
-  #   perf_mole_filters.each_pair do |k,v|
-  #     puts "#{k} --> #{v}"
-  #   end    
-  # end
+   
+  # ---------------------------------------------------------------------------
+  # Dumps moled feature info       
+  def mole_dump( msg=nil )
+    puts "\n------------------------------------------------------------------"
+    puts "From #{msg}" if msg
+    puts "MOle Info for class <- #{self} ->"
+    puts "\nBefore filters"
+    before_mole_filters.keys.sort.each { |k| puts "\t#{k} --> #{before_mole_filters[k]}" }
+    puts "\nAfter filters"
+    after_mole_filters.keys.sort.each { |k| puts "\t#{k} --> #{after_mole_filters[k]}" }
+    puts "\nUnchecked filters"
+    unchecked_mole_filters.keys.sort.each { |k| puts "\t#{k} --> #{unchecked_mole_filters[k]}" }
+    puts "\nPerf filters"
+    perf_mole_filters.keys.sort.each { |k| puts "\t#{k} --> #{perf_mole_filters[k]}" }    
+    puts "---------------------------------------------------------------------\n"    
+  end
       
   # ===========================================================================
-  # protected
+  private
+
+    # Clear MOle state for this class # Used for testing only
+    def mole_clear!
+      @before_mole_filters = nil  
+      @after_mole_filters = nil  
+      @perf_mole_filters = nil  
+      @unchecked_mole_filters = nil                    
+    end  
     
-  # ---------------------------------------------------------------------------
-  # Holds before filters
-  def before_mole_filters #:nodoc:
-    @before_mole_filters ||= Hash.new{ |h,k| h[k] = [] }
-  end
+  # ===========================================================================
+  public
+    
+    # -------------------------------------------------------------------------
+    # Holds before filters
+    def before_mole_filters #:nodoc:    
+      @before_mole_filters ||= Hash.new{ |h,k| h[k] = [] }
+    end
 
-  # ---------------------------------------------------------------------------
-  # Holds after filters
-  def after_mole_filters #:nodoc:
-    @after_mole_filters ||= Hash.new{ |h,k| h[k] = [] }
-  end
+    # -------------------------------------------------------------------------
+    # Holds after filters
+    def after_mole_filters #:nodoc:
+      @after_mole_filters ||= Hash.new{ |h,k| h[k] = [] }
+    end
   
-  # Holds perf around filters   
-  def perf_mole_filters #:nodoc:
-    @perf_mole_filters ||= Hash.new{ |h,k| h[k] = []} 
-  end
-
-  # Holds unchecked exception filters   
-  def unchecked_mole_filters #:nodoc:
-    @unchecked_mole_filters ||= Hash.new{ |h,k| h[k] = []} 
-  end
-        
-  # Attempt to find singleton class method with given name 
-  # TODO Figure out how to get method for static signature...
-  # def find_public_class_method(method)                        
-  #   singleton_methods.each { |name| puts "Looking for #{method}--#{method.class} -- #{name}#{name.class}";return name if name == method }
-  #   nil
-  # end
+    # -------------------------------------------------------------------------
+    # Holds perf around filters   
+    def perf_mole_filters #:nodoc:
+      @perf_mole_filters ||= Hash.new{ |h,k| h[k] = []} 
+    end
 
-  # Wrap method call                                
-  # TODO Add support for wrapping class methods ??
-  def wrap( method ) #:nodoc:
-    return if wrapped?( method )  
-    begin
-      between = instance_method( method )
-    rescue
-      # between = find_public_class_method( method )
-      raise "Unable to find moled feature `#{method}" unless(between)
+    # -------------------------------------------------------------------------
+    # Holds unchecked exception filters   
+    def unchecked_mole_filters #:nodoc:
+      @unchecked_mole_filters ||= Hash.new{ |h,k| h[k] = []} 
     end
-    code = <<-code
-      def #{method}_with_mole (*a, &b)
-        key                 = '#{method}'
-        klass               = self.class
-        between             = klass.wrapped[key]
-        ret_val             = nil
-        klass.apply_before_filters( klass.before_mole_filters[key], self, key, *a, &b )
-        begin                                          
-          elapsed = Benchmark::realtime do 
-            ret_val = between.bind(self).call( *a, &b ) 
-          end   
-          klass.apply_perf_filters( elapsed, klass.perf_mole_filters[key], self, key, ret_val, *a, &b )                              
-        rescue => boom   
-          klass.apply_unchecked_filters( boom, klass.unchecked_mole_filters[key], self, key, *a, &b )
-          raise boom            
-        end                                                                 
-        klass.apply_after_filters( klass.after_mole_filters[key], self, key, ret_val, *a, &b )
-        ret_val
+        
+    # -------------------------------------------------------------------------        
+    # Attempt to find singleton class method with given name 
+    # TODO Figure out how to get method for static signature...
+    # def find_public_class_method(method)                        
+    #   singleton_methods.each { |name| puts "Looking for #{method}--#{method.class} -- #{name}#{name.class}";return name if name == method }
+    #   nil
+    # end
+  
+    # -------------------------------------------------------------------------
+    # Wrap method call                                
+    # TODO Add support for wrapping class methods ??
+    def wrap( method ) #:nodoc:
+      return if wrapped?( method )  
+      begin
+        between = instance_method( method )
+      rescue
+        # between = find_public_class_method( method )
+        raise "Unable to find moled feature `#{method}" unless(between)
       end
-    code
-   
-    module_eval                code               
-    alias_method_chain method, "mole" 
-    wrapped[method.to_s]       = between
-  end    
+      code = <<-code
+        def #{method}_with_mole (*a, &b)
+          key                 = '#{method}'
+          klass               = self.class
+          between             = klass.wrapped[key]
+          ret_val             = nil
+          klass.apply_before_filters( klass.before_mole_filters[key], self, key, *a, &b ) if klass.before_mole_filters[key]
+          begin                                          
+            elapsed = Benchmark::realtime do 
+              ret_val = between.bind(self).call( *a, &b ) 
+            end   
+            klass.apply_perf_filters( elapsed, klass.perf_mole_filters[key], self, key, ret_val, *a, &b ) if klass.perf_mole_filters[key]
+          rescue => boom   
+            klass.apply_unchecked_filters( boom, klass.unchecked_mole_filters[key], self, key, *a, &b ) if klass.unchecked_mole_filters[key]
+            raise boom            
+          end                                                                 
+          klass.apply_after_filters( klass.after_mole_filters[key], self, key, ret_val, *a, &b ) if klass.after_mole_filters[key]
+          ret_val
+        end
+      code
    
-  def apply_before_filters( filters, clazz, key, *a, &b )          #:nodoc:              
-    begin
-      filters.each { |r,m| r.send( m, clazz, key, b, *a ) }
-    rescue => ca_boom
-      ::Mole.logger.error ">>> Mole Error: Before-Filter -- " + ca_boom
-      # ca_boom.backtrace.each { |l| ::Mole.logger.error l }           
+      module_eval                code               
+      alias_method_chain method, "mole" 
+      wrapped[method.to_s]       = between
     end    
-  end
+   
+    def apply_before_filters( filters, clazz, key, *a, &b )          #:nodoc:              
+      begin
+        filters.each { |r,m| r.send( m, clazz, key, b, *a ) }
+      rescue => ca_boom
+        ::Mole.logger.error ">>> MOle Failure: Before-Filter -- " + ca_boom
+        ca_boom.backtrace.each { |l| ::Mole.logger.error l }           
+      end    
+    end
                        
-  def apply_after_filters( filters, clazz, key, ret_val, *a, &b )   #:nodoc:              
-    begin  
-      filters.each { |r,m| r.send( m, clazz, key, ret_val, b, *a ) }
-    rescue => ca_boom    
-      ::Mole.logger.error ">>> Mole Error: After-Filter -- " + ca_boom
-      # ca_boom.backtrace.each { |l| ::Mole.logger.error l }           
-    end    
-  end
+    def apply_after_filters( filters, clazz, key, ret_val, *a, &b )   #:nodoc:              
+      begin  
+        filters.each { |r,m| r.send( m, clazz, key, ret_val, b, *a ) }
+      rescue => ca_boom    
+        ::Mole.logger.error ">>> MOle Failure: After-Filter -- " + ca_boom
+        ca_boom.backtrace.each { |l| ::Mole.logger.error l }           
+      end    
+    end
                        
-  def apply_perf_filters( elapsed, filters, clazz, key, ret_val, *a, &b )       #:nodoc:
-    begin
-      if ( elapsed >= Mole.perf_threshold  )
-        filters.each { |r,m| r.send( m, clazz, key, elapsed, ret_val, b, *a ) }            
-      end
-    rescue => ca_boom
-      ::Mole.logger.error ">>> Mole Error: Perf-Filter -- " + ca_boom
-      # ca_boom.backtrace.each { |l| ::Mole.logger.error l }             
-    end    
-  end
+    def apply_perf_filters( elapsed, filters, clazz, key, ret_val, *a, &b )       #:nodoc:
+      begin
+        if ( elapsed >= Mole.perf_threshold  )
+          filters.each { |r,m| r.send( m, clazz, key, elapsed, ret_val, b, *a ) }            
+        end
+      rescue => ca_boom
+        ::Mole.logger.error ">>> MOle Failure: Perf-Filter -- " + ca_boom
+        ca_boom.backtrace.each { |l| ::Mole.logger.error l }             
+      end    
+    end
                        
-  def apply_unchecked_filters( boom, filters, clazz, key, *a, &b ) #:nodoc:
-    begin
-      filters.each { |r,m| r.send( m, clazz, key, boom, b, *a ) }
-    rescue => ca_boom                               
-      ::Mole.logger.error ">>> Mole Error: Unchecked-Filter -- " + ca_boom
-      # ca_boom.backtrace.each { |l| ::Mole.logger.error l }             
-    end                                                                       
-  end
+    def apply_unchecked_filters( boom, filters, clazz, key, *a, &b ) #:nodoc:
+      begin
+        filters.each { |r,m| r.send( m, clazz, key, boom, b, *a ) }
+      rescue => ca_boom                               
+        ::Mole.logger.error ">>> MOle Failure: Unchecked-Filter -- " + ca_boom
+        ca_boom.backtrace.each { |l| ::Mole.logger.error l }             
+      end                                                                       
+    end
                           
-  # ---------------------------------------------------------------------------
-  # Log wrapped class
-  def wrapped #:nodoc:
-    @wrapped ||= {}
-  end
+    # ---------------------------------------------------------------------------
+    # Log wrapped class
+    def wrapped #:nodoc:
+      @wrapped ||= {}
+    end
 
-  # ---------------------------------------------------------------------------
-  # Check if method has been wrapped
-  def wrapped?(which) #:nodoc:
-    wrapped.has_key?(which.to_s)
-  end       
+    # ---------------------------------------------------------------------------
+    # Check if method has been wrapped
+    def wrapped?(which) #:nodoc:
+      wrapped.has_key?(which.to_s)
+    end       
 end