watch_methods 0.0.4

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in watch_methods.gemspec
+gemspec

data/README.md

@@ -0,0 +1,63 @@
+watch_methods
+=============
+
+## What is this thing?
+
+  Monitor when methods are added to classes or modules and take action when they do.
+
+## Why would I want this?
+  You are:
+
+  - developing a kick-ass gem and you want your users to use your class methods before methods are actually defined (think AR validators, callback etc.)
+  - Want to monitor all methods starting with queue_ for your new awesome queueing gem.
+  - and more!
+
+##Install
+
+    [sudo] gem install method_added_hook
+
+
+### Skip all the crap, give me the examples.
+   [Examples](https://github.com/mikelewis/method_added_hook/tree/master/examples)
+
+##Usage
+   The method that you'll be interacting with is the `watch_methods` method that is defined as:
+
+    watch_methods(methods, opts={}, &blk)
+
+   Where:
+
+   - methods can be a symbol, string, array, regex or any combination. This will be all the methods you want to monitor.
+
+   - opts currently has two optional parameters `:class_methods` to watch for class methods and `:once` to
+   only run the given block once for a given method.
+
+   - a given block, which will get run after a given method to watch was added.
+
+Here are some valid uses of `watch_methods`:
+
+    watch_methods(:special_func1, :special_func2) do |meth|
+
+    end
+
+
+    # this will watch any class method starting with test_, queue_
+    watch_methods(/^test_.+$/, /^queue_.+$/, :class _methods => true) do |meth|
+
+    end
+
+    watch_methods([:meth_one, :meth_two]) do |meth|
+
+     end
+
+  or a combination of all of the above:
+
+    watch_methods(:special_func, /^test_meth$/, [:meth1, :meth2]) do |meth|
+
+    end
+
+  To see all examples/cases, see the examples directory and the spec file.
+
+###Supports
+  Ruby 1.8.7, 1.9.2, 1.9.3
+

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler'
+include Rake::DSL
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+task :test => :spec
+

data/examples/array.rb

@@ -0,0 +1,17 @@
+require 'watch_methods'
+
+
+class ArrayTest
+  watch_methods [:sing, :dance] do |meth|
+    puts "#{meth} was added!"
+  end
+
+  def dance
+
+  end
+end
+
+#
+# prints
+# dance was added!
+#

data/examples/before_and_after_declartion.rb

@@ -0,0 +1,25 @@
+require 'watch_methods'
+
+class BeforeAndAfter
+  watch_methods :yo do |meth|
+    puts "yo was added!"
+  end
+
+  def yo
+
+  end
+
+  def hey
+
+  end
+
+  watch_methods :hey do |meth|
+    puts "Hey was added!"
+  end
+end
+
+#
+# Prints
+# yo was added!
+# Hey was added!
+#

data/examples/callbacks.rb

@@ -0,0 +1,65 @@
+require 'watch_methods'
+
+module Callbacks
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    [:after, :before].each do |action|
+      define_method(action) do |*args|
+        meth, opts = args
+        watch_methods meth, :once => true do |m|
+          register_callback(action, m, opts)
+        end
+      end
+    end
+
+    def register_callback(type, meth, opts={})
+      alias_method :"old_#{meth}", meth
+      before_proc, after_proc = [proc{}] * 2
+      case type
+      when :after
+        after_proc = proc { send(opts[:do]) }
+      when :before
+        before_proc = proc { send(opts[:do]) }
+      end
+
+      define_method(meth) do |*args, &blk|
+        instance_eval &before_proc
+        send(:"old_#{meth}", *args, &blk)
+        instance_eval &after_proc
+      end
+    end
+  end
+end
+
+class Test
+  include Callbacks
+  after :jump, :do => :crawl
+  before :crawl, :do => :stretch
+
+  def jump
+    puts "I'm jumpin"
+  end
+
+  def stretch
+    puts "I'm stretchin"
+  end
+
+  def crawl
+    puts "I'm crawlin"
+  end
+end
+
+
+t = Test.new
+
+t.jump
+
+#
+# prints
+# I'm jumpin
+# I'm stretchin
+# I'm crawlin
+#

data/examples/class_methods.rb

@@ -0,0 +1,48 @@
+require 'watch_methods'
+
+class ClassMethodHook
+  watch_methods /crawl|jump|sit/, :class_methods => true do |meth|
+    puts "#{meth} was added!"
+  end
+
+  watch_methods :smile, :class_methods => true do |meth|
+    puts "Smile was added!"
+  end
+
+  class << self
+    watch_methods :scream do |meth|
+      puts "scream was added"
+    end
+  end
+
+  def self.crawl
+
+  end
+
+  def self.scream
+
+  end
+
+  def self.jump
+
+  end
+
+  def self.sit
+
+  end
+
+  class << self
+    def smile
+
+    end
+  end
+end
+
+#
+# prints
+# crawl was added!
+# scream was added
+# jump was added!
+# sit was added!
+# Smile was added!
+#

data/examples/combination.rb

@@ -0,0 +1,27 @@
+require 'watch_methods'
+
+class Combo
+  watch_methods :test, "jump", [:cry, :dance], /^sing$/ do |meth|
+    puts "#{meth} was added!"
+  end
+
+  def sing
+
+  end
+
+  def dance
+
+  end
+
+  def test
+
+  end
+end
+
+
+#
+# print
+# sing was added!
+# dance was added!
+# test was added!
+#

data/examples/regex.rb

@@ -0,0 +1,21 @@
+require 'watch_methods'
+
+class Queues
+  watch_methods /^queue_(.+)$/ do |meth|
+    puts "Queue #{meth} was added!"
+  end
+
+  def queue_jump
+
+  end
+
+  def queue_smile
+
+  end
+end
+
+#
+#prints
+# Queue queue_jump was added!
+# Queue queue_smile was added!
+#

data/examples/simple.rb

@@ -0,0 +1,13 @@
+require 'watch_methods'
+
+class MySimpleTest
+  watch_methods :jump do |meth|
+    puts "Jump added!"
+  end
+
+  def jump
+
+  end
+end
+
+# prints "Jump added!"

data/examples/test_framework.rb

@@ -0,0 +1,36 @@
+require 'watch_methods'
+
+class TestFramework
+  def self.inherited(base)
+    at_exit { instance = base.new; @tests.each{|test| instance.send(test)} }
+    base.watch_methods /^test_.+$/ do |meth|
+      (@tests ||= []) << meth
+    end
+  end
+end
+
+class TestName < TestFramework
+  def test_valid_name
+    puts "Run me! test_valid_name"
+  end
+
+  def test_invalid_name
+    puts "Run me! test_invalid_name"
+  end
+
+  def test_length
+    puts "Run me! test_length"
+  end
+
+  def test_injections
+    puts "Run me! test_injections"
+  end
+end
+
+#
+# prints
+# Run me! test_valid_name
+# Run me! test_invalid_name
+# Run me! test_length
+# Run me! test_injections
+#

data/examples/watch_only_once.rb

@@ -0,0 +1,16 @@
+require 'watch_methods'
+
+
+class ManyDeclarations
+  watch_methods :test, :once => true do |meth|
+    puts "test was added!"
+  end
+
+  100.times do
+    define_method :test do
+
+    end
+  end
+end
+
+# prints test was added! only once

data/lib/watch_methods/version.rb

@@ -0,0 +1,3 @@
+module WatchMethods
+  VERSION = "0.0.4"
+end

data/lib/watch_methods.rb

@@ -0,0 +1,76 @@
+class Module
+
+  def call_callback(method_added_hash, key, meth)
+    return unless method_added_hash.include?(key)
+    callback_hash = method_added_hash[key]
+    callback = callback_hash[:callback]
+    once = callback_hash[:once]
+    method_added_hash.delete(key) if once
+    callback.call(meth)
+
+  end
+
+  private :call_callback
+
+  def watch_methods(*watch_for, &blk)
+    class_methods = false
+    once = false
+    if watch_for.last.is_a? Hash
+      opts = watch_for.pop
+      class_methods = opts[:class_methods] || class_methods
+      once = opts[:once] || once
+    end
+
+    context = class_methods ? (class << self; self; end) : self
+
+    added_watcher = context.class_eval { @method_added_watcher ||= {} }
+
+    watch_for.each do |f|
+      key = case f
+            when Regexp
+              f
+            when Symbol
+              f.to_s
+            when String
+              f
+            when Array
+              f.each {|*sub_f| sub_f << opts if opts; watch_methods(*sub_f, &blk)}
+              nil
+            end
+
+
+      if key
+        added_watcher[key] = {:callback => blk, :once => once}
+        if meth = context.instance_methods(false).find{|m| key.match(m.to_s)}
+          call_callback(added_watcher, key, meth)
+        end
+      end
+    end
+  end
+
+  def maybe_call_callback(meth, context)
+    context.class_eval do
+      return unless @method_added_watcher
+
+      str_meth = meth.to_s
+      if found = @method_added_watcher.find{|key,value| key.match(str_meth)}
+        key, callback_hash = found
+        call_callback(@method_added_watcher, key, meth)
+      end
+    end
+  end
+
+  private :maybe_call_callback
+
+  def method_added(meth)
+    maybe_call_callback(meth, self)
+  end
+
+  def singleton_method_added(meth)
+    context = class << self; self; end
+    maybe_call_callback(meth, context)
+  end
+
+
+
+end

data/spec/method_added_hook_spec.rb

@@ -0,0 +1,364 @@
+require 'spec_helper'
+
+describe "Method Added Hook" do
+  context "Instance Methods" do
+    before do
+      if defined?(SampleObject)
+        Object.send(:remove_const, :SampleObject)
+      end
+      SampleObject = Class.new do
+        watch_methods :mike, /^test_.*/, "jump" do |method|
+        end
+      end
+    end
+
+    it "should add a class method watch_for_method_added" do
+      Module.should respond_to(:watch_methods)
+      SampleObject.should respond_to(:watch_methods)
+    end
+
+    it "should create a class instance variable with the correct hash method_added_watcher" do
+      h = SampleObject.class_eval{ @method_added_watcher }
+
+      h.each_key do |key|
+        key.should respond_to(:match)
+      end
+    end
+
+    it "should accept being called more than once" do
+      h = SampleObject.class_eval{ @method_added_watcher }
+      old_keys = h.keys
+
+      SampleObject.class_eval { watch_methods(:up) {} }
+
+      new_hash = SampleObject.class_eval{ @method_added_watcher }
+
+      new_hash.keys.should =~ (old_keys << "up")
+    end
+
+    it "should accept an optional parameter once and only monitor a method once" do
+      result = nil
+      SampleObject.class_eval do
+        watch_methods(:up, :once => true) { result = 5 }
+
+        def up
+
+        end
+      end
+
+      result.should == 5
+      result = 20
+
+      new_hash = SampleObject.class_eval { @method_added_watcher }
+      new_hash.should_not include("up")
+
+      SampleObject.class_eval do
+        def up
+
+        end
+      end
+
+      # in other words, its not 5
+      result.should == 20
+    end
+
+    it "should accept an optional parameter once and only monitor a method once (in practice)" do
+      lambda {
+      result = nil
+      SampleObject.class_eval do
+        watch_methods(:up, :once => true) do |meth|
+          alias_method :"old_#{meth}", meth
+          define_method(meth) {}
+        end
+
+        def up
+
+        end
+      end
+
+      }.should_not raise_error(SystemStackError)
+      # if we didn't pass in once, we would get into an infinite loop of defining a method
+    end
+
+    it "should expand all arrays" do
+      SampleObject.class_eval { watch_methods(["meth1", "meth2"]) {} }
+      h = SampleObject.class_eval{ @method_added_watcher }
+      h.each_key do |key|
+        key.class.should_not == Array
+      end
+    end
+
+    {:string => "my_method", :symbol => :my_method, :regex => /^my_method$/, :array => [1,2,3, "my_method"]}.each do |type, value|
+      it "should call a callback when a method is added with a #{type}" do
+        result = nil
+        SampleObject.class_eval do
+          watch_methods value do |meth|
+            result = 5
+          end
+        end
+
+        class SampleObject
+          def my_method
+
+          end
+        end
+
+        result.should == 5
+      end
+    end
+
+    {:string => "my_method", :symbol => :my_method, :regex => /^my_method$/, :array => [1,2,3, "my_method"]}.each do |type, value|
+      it "should call a callback when a method is added with a #{type} before watch_methods was called" do
+        result = nil
+        SampleObject.class_eval do
+          def my_method
+
+          end
+
+          watch_methods value do |meth|
+            result = 5
+          end
+        end
+
+        result.should == 5
+      end
+    end
+
+    it "should yield the method name (Symbol) to the block" do
+      result = nil
+      SampleObject.class_eval do
+        watch_methods /^t.*$/ do |meth|
+          result = meth
+        end
+
+        def test
+
+        end
+      end
+
+      result.should == :test
+    end
+
+  end
+
+  context "class methods" do
+    before do
+      if defined?(SampleClassObject)
+        Object.send(:remove_const, :SampleClassObject)
+      end
+      SampleClassObject = Class.new
+    end
+
+    it "should work with eigenclass methods and eigenclass watch_methods" do
+        result = nil
+        meta = class << SampleClassObject; self; end
+        meta.class_eval do
+          watch_methods :game do |meth|
+            result = 5
+          end
+        end
+
+      class SampleClassObject
+          class << self
+            def game
+
+            end
+          end
+        end
+
+      result.should == 5
+    end
+
+    it "should work with singleton methods and eigenclass" do
+      result = nil
+      meta = class << SampleClassObject; self; end
+      meta.class_eval do
+        watch_methods :game do |meth|
+          result = 5
+        end
+      end
+
+      class SampleClassObject
+        def self.game
+
+        end
+      end
+
+      result.should == 5
+    end
+
+    it "should work with singleton methods and optional parameter" do
+      result = nil
+      SampleClassObject.class_eval do
+        watch_methods :game, :class_methods => true do |meth|
+          result = 5
+        end
+      end
+
+      class SampleClassObject
+        def self.game
+
+        end
+      end
+
+      result.should == 5
+    end
+
+    it "should work with eigenclass methods and optional parameter" do
+      result = nil
+      SampleClassObject.class_eval do
+        watch_methods :game, :class_methods => true do |meth|
+          result = 5
+        end
+      end
+
+      class SampleClassObject
+        class << self
+          def game
+
+          end
+        end
+      end
+
+      result.should == 5
+    end
+
+    {:string => "my_method", :symbol => :my_method, :regex => /^my_method$/, :array => [1,2,3, "my_method"]}.each do |type, value|
+      it "should call a callback when a method is added with a #{type} before watch_methods was called" do
+        result = nil
+        SampleClassObject.class_eval do
+          class << self
+            def my_method
+
+            end
+          end
+
+          watch_methods value, :class_methods => true do |meth|
+            result = 5
+          end
+        end
+
+        result.should == 5
+      end
+    end
+
+
+    it "should work with an array and the optional parameter" do
+      result = nil
+      SampleClassObject.class_eval do
+        watch_methods [:game, :test], :class_methods => true do |meth|
+          result = 5
+        end
+      end
+
+      class SampleClassObject
+        class << self
+          def test
+
+          end
+        end
+      end
+
+      result.should == 5
+    end
+  end
+
+  context "Modules" do
+    before do
+      if defined?(SampleModuleObject)
+        Object.send(:remove_const, :SampleModuleObject)
+      end
+      SampleModuleObject = Module.new
+    end
+
+    it "should work for an instance method" do
+      result = nil
+      SampleModuleObject.module_eval do
+        watch_methods :hi do
+          result = 5
+        end
+      end
+      module SampleModuleObject
+        def hi
+
+        end
+      end
+
+      result.should == 5
+    end
+
+    it "should work for a singleton method" do
+      result = nil
+      SampleModuleObject.module_eval do
+        watch_methods :hi, :class_methods => true do
+          result = 5
+        end
+      end
+      module SampleModuleObject
+        def self.hi
+
+        end
+      end
+
+      result.should == 5
+    end
+
+
+    it "should work for an eigenclass method" do
+      result = nil
+      SampleModuleObject.module_eval do
+        watch_methods :hi, :class_methods => true do
+          result = 5
+        end
+      end
+      module SampleModuleObject
+        class << self
+          def hi
+
+          end
+        end
+      end
+
+      result.should == 5
+    end
+
+    it "should work for an eigenclass method, watched from an eigenclass" do
+      result = nil
+      meta = (class << SampleModuleObject; self; end)
+      meta.class_eval do
+        watch_methods :hi do
+          result = 5
+        end
+      end
+
+      module SampleModuleObject
+        class << self
+          def hi
+
+          end
+        end
+      end
+
+      result.should == 5
+    end
+
+    it "should work for a singleton method, watched from an eigenclass" do
+      result = nil
+      meta = (class << SampleModuleObject; self; end)
+      meta.class_eval do
+        watch_methods :hi do
+          result = 5
+        end
+      end
+
+      module SampleModuleObject
+        def self.hi
+
+        end
+      end
+
+      result.should == 5
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$:.unshift File.dirname(__FILE__) + '/../lib'
+require 'watch_methods'

data/watch_methods.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "watch_methods/version"
+
+Gem::Specification.new do |s|
+  s.name        = "watch_methods"
+  s.version     = WatchMethods::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Mike Lewis"]
+  s.email       = ["ft.mikelewis@gmail.com"]
+  s.homepage    = "http://github.com/mikelewis/method_added_hook"
+  s.summary     = %q{Easily monitor methods added within classes and modules.}
+  s.description = %q{Easily monitor methods added within classes and modules.}
+
+  s.rubyforge_project = "method_added_hook"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec"
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: watch_methods
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+  prerelease: 
+platform: ruby
+authors:
+- Mike Lewis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &2152721360 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2152721360
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2152720480 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2152720480
+description: Easily monitor methods added within classes and modules.
+email:
+- ft.mikelewis@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- README.md
+- Rakefile
+- examples/array.rb
+- examples/before_and_after_declartion.rb
+- examples/callbacks.rb
+- examples/class_methods.rb
+- examples/combination.rb
+- examples/regex.rb
+- examples/simple.rb
+- examples/test_framework.rb
+- examples/watch_only_once.rb
+- lib/watch_methods.rb
+- lib/watch_methods/version.rb
+- spec/method_added_hook_spec.rb
+- spec/spec_helper.rb
+- watch_methods.gemspec
+homepage: http://github.com/mikelewis/method_added_hook
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: method_added_hook
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Easily monitor methods added within classes and modules.
+test_files:
+- spec/method_added_hook_spec.rb
+- spec/spec_helper.rb