wrapr 0.0.1

data/.gitignore

@@ -0,0 +1,7 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+vendor/*
+.idea/*
+

data/.rspec

@@ -0,0 +1,2 @@
+--colour
+--format documentation

data/Gemfile

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

data/README.md

@@ -0,0 +1,34 @@
+Wrapr
+====
+
+Modify class behavior at runtime. Similar to before/after/around filters in Rails ActionController::Base
+
+Example
+------
+
+    require 'wrapr' 
+    require 'logger'
+    log = Logger.new(STDOUT)
+
+    Wrapr::Wrapr.new(Exception).before(:initialize) do |this,*args|
+      log.debug("New exception is being created "+args.inspect)
+      args
+    end
+
+  5/0 # we can hijack any class's instance methods and inject our own functionality
+
+
+Potential Uses
+--------------
+
+Use with ruby-debug to set conditional break points
+
+    require 'ruby-debug'
+    Wrapr::Wrapr.new(Post).before(:find) do |this,*args|
+        # Open debug when a post is instantiated 
+        debugger if args[:conditions][:
+        args
+    end
+
+Use with analytics packages to track application events from a single location
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/informal_tests.rb

@@ -0,0 +1,34 @@
+  # These examples  written for samples of code in the documentation 
+
+  $: << File.dirname(__FILE__)+"/lib"
+  require 'wrapr' 
+  require 'logger'
+  log = Logger.new(STDOUT)
+
+
+
+  
+   w = Wrapr::Wrapr.new(Exception)
+   # #before can mutate the instance and args as well
+   w.before(:initialize) do |this,*args|
+     args[0].upcase!
+     args
+   end
+   puts Exception.new("foo").to_s # FOO
+   w.around(:to_s) do |this,method,*args|
+     puts "Before to_s" 
+     result = method.call() 
+     result+=" "
+  end
+  puts Exception.new("foo").to_s  # FOO, "Before to_s OOF "
+  w.after(:to_s) do |this,result|
+    result.downcase
+  end
+  puts Exception.new("foo").to_s  # FOO, "Before to_s foo"
+
+  Wrapr::Wrapr.new(Exception).before(:initialize) do |this,*args|
+    log.debug("New exception is being created "+args.inspect)
+    args
+  end
+
+  5/0

data/lib/wrapr.rb

@@ -0,0 +1,86 @@
+require "wrapr/version"
+
+module Wrapr
+
+  
+
+
+  # Allows method wrapping
+  #
+  # Usage
+  #   w = Wrapr::Wrapr.new(Exception)
+  #   # #before can mutate the instance and args as well
+  #   w.before(:initialize) do |this,*args|
+  #     args[0].upcase!
+  #     args
+  #   end
+  #   puts Exception.new("foo").to_s # FOO
+  #   w.around(:to_s) do |this,method,*args|
+  #     puts "Before to_s" 
+  #     result = method.call() 
+  #     result+=" "
+  #  end
+  #  puts Exception.new("foo").to_s  # FOO, "Before to_s OOF "
+  #  w.after(:to_s) do |this,result|
+  #    result.downcase
+  #  end
+  #  puts Exception.new("foo").to_s  # FOO, "Before to_s foo"
+
+  class Wrapr
+    def initialize(klass)
+      @klass=klass 
+    end
+    # Executes block around
+    # Call of wrapped method is responsibility of the passed block
+    #
+    # Transparently 
+    #
+    #   Wrapr.new(Exception).around(:to_s) { |self,method,*outer_args|
+    #     method.call(*outer_args) 
+    #   }
+    def around(method,&block)
+      # fetch the unbound instance method
+      unbound = @klass.instance_method(method)
+      @klass.class_eval do 
+        # create a new method with the same name
+        define_method(method) do |*outer_args|
+          # we pass the current instance and overridden method
+          block.call(self,unbound.bind(self),*outer_args)
+          # We cannot do self.send(method,...) because we are redefining @method, causes recursion
+        end
+      end
+    end
+    # Executes block before method is called
+    # Passes the return of the block to method
+    #
+    # Transparent before
+    #
+    #   Wrapr.new(Exception).before(:to_s) { |self,*outer_args| 
+    #     return outer_args  
+    #   }
+    def before(method,&block)
+      unbound = @klass.instance_method(method)
+      @klass.class_eval do
+        define_method(method) do |*outer_args|
+          unbound.bind(self).call(*block.call(self,*outer_args)) 
+        end
+      end
+    end
+    # Executes block after method is called
+    # Passes the response of method into block
+    # 
+    # Transparent after
+    #
+    #   Wrapr.new(Exception).after(:to_s) do |self,*result|
+    #     return result
+    #   end
+    def after(method,&block)
+      unbound = @klass.instance_method(method)
+      @klass.class_eval do
+        define_method(method) do |*outer_args|
+          block.call(self, *unbound.bind(self).call(*outer_args))
+        end
+      end
+    end
+  end
+end

data/lib/wrapr/version.rb

@@ -0,0 +1,3 @@
+module Wrapr
+  VERSION = "0.0.1"
+end

data/spec/wrapr_spec.rb

@@ -0,0 +1,81 @@
+require 'wrapr'
+describe Wrapr::Wrapr do
+  before do
+    class Foo
+      attr_accessor :stack
+      def initialize
+        @stack = [:initialize]
+      end
+      def instance_m
+        @stack.push([:instance_m])
+      end
+      def instance_m_arg(x)
+        @stack.push x
+      end
+      def self.static_m(stack,item)
+        stack << item
+      end
+    end
+    @wrapper = Wrapr::Wrapr.new(Foo)
+  end
+  context "around"  do
+    it "wraps something around a method" do
+      @wrapper.around(:instance_m) do |this,method,*args|
+        this.stack << :around_before
+        method.call(*args)
+        this.stack << :around_after
+      end
+      instance = Foo.new
+      instance.instance_m
+      instance.stack.should include(:around_before,:around_after)
+    end
+    it "even works with arguments" do
+      @wrapper.around(:instance_m) do |this,method,a,b|
+        this.stack << a << b
+        method.call()
+      end
+      instance = Foo.new
+      instance.instance_m(:argument_one,:argument_two)
+      instance.stack.should include(:argument_one,:argument_two)
+    end
+    it "even works with layers of arguments" do
+      @wrapper.around(:instance_m_arg) do |this,method,a,b|
+        this.stack.push(b)
+        method.call( (a.to_s+b.to_s).to_sym )
+      end
+      instance = Foo.new
+      instance.instance_m_arg(:argument_one, :argument_two) 
+      instance.stack.should_not include(:argument_one)
+      instance.stack.should include(:argument_oneargument_two)
+    end
+  end
+  context "before" do
+    it "passes through arguments to a method" do
+      @wrapper.before(:instance_m_arg) do |this,x|
+        x.to_s
+      end
+      instance = Foo.new
+      instance.instance_m_arg(:argument)
+      instance.stack.should include("argument")
+    end
+    it "works transparently" do
+      @wrapper.before(:instance_m) do |this,*args|
+        this.stack.shift
+        args
+      end
+      instance = Foo.new
+      instance.instance_m
+      instance.stack.should_not include(:initialize)
+    end
+  end
+  context "after" do
+    it "passes return values into block" do
+      @wrapper.after(:instance_m) do |this,result|
+        result.to_s.upcase 
+      end
+      instance = Foo.new
+      instance.instance_m.should == "INITIALIZE"
+    end
+  end
+  it "works with static methods"
+end

data/wrapr.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "wrapr/version"
+
+Gem::Specification.new do |s|
+  s.name        = "wrapr"
+  s.version     = Wrapr::VERSION
+  s.authors     = ["Thomas W. Devol"]
+  s.email       = ["thomas.devol@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Allows before/around/after instance method wrapping}
+  s.description = s.summary+" etc..."
+
+  s.rubyforge_project = "wrapr"
+
+  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"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: wrapr
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Thomas W. Devol
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-07 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70194634911940 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70194634911940
+description: Allows before/around/after instance method wrapping etc...
+email:
+- thomas.devol@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- README.md
+- Rakefile
+- informal_tests.rb
+- lib/wrapr.rb
+- lib/wrapr/version.rb
+- spec/wrapr_spec.rb
+- wrapr.gemspec
+homepage: ''
+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: wrapr
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Allows before/around/after instance method wrapping
+test_files:
+- spec/wrapr_spec.rb