big_spoon 0.0.1

data/.rspec

@@ -0,0 +1 @@
+--colour

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.3@working_girl --create

data/.simplecov

@@ -0,0 +1 @@
+SimpleCov.start

data/CHANGES.md

@@ -0,0 +1,5 @@
+# CHANGELOG
+## 0.0.1
+### Basic functionality
+- Hooks / callbacks are working BEFORE OR AFTER a method gets defined
+- No :if or :unless options

data/Gemfile

@@ -0,0 +1,7 @@
+source 'http://rubygems.org'
+
+group :test do
+  gem 'guard-rspec'
+  gem 'simplecov', :require => false
+  gem 'rspec'
+end

data/Gemfile.lock

@@ -0,0 +1,41 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    ffi (1.1.5)
+    guard (1.3.0)
+      listen (>= 0.4.2)
+      thor (>= 0.14.6)
+    guard-rspec (1.2.1)
+      guard (>= 1.1)
+    listen (0.4.7)
+      rb-fchange (~> 0.0.5)
+      rb-fsevent (~> 0.9.1)
+      rb-inotify (~> 0.8.8)
+    multi_json (1.3.6)
+    rb-fchange (0.0.5)
+      ffi
+    rb-fsevent (0.9.1)
+    rb-inotify (0.8.8)
+      ffi (>= 0.5.0)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.1)
+    rspec-expectations (2.11.2)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.11.1)
+    simplecov (0.6.4)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.5.3)
+    simplecov-html (0.5.3)
+    thor (0.15.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  guard-rspec
+  rspec
+  simplecov

data/Guardfile

@@ -0,0 +1,8 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/README.md

@@ -0,0 +1,58 @@
+# Big Spoon
+Like the big spoon, **Big Spoon** wraps around your own methods.
+It adds before and after callbacks to ANY method in any Ruby class.
+
+There were those who wanted to call it "sandwich," but they were killed.
+
+**Big Spoon** adds _hooks_ around ANY method. It can do this before
+or after the methods are defined, making it awesome for fun stuff like adding extra hooks around events at the top of
+a class definition without having to worry about when the method gets defined.
+
+I think I'm going to import it into all of my libraries to avoid alias\_method_chaining anything ever again.
+
+Anyway, here's how it works for now, DON'T use it cause I haven't tested it with shit:
+
+## Usage
+
+Let's say, for example, you want to reset an instance variable in a model when it gets reloaded.
+
+For shits and giggles and real-world-clarity, I'll use an ActiveRecord model but this could be
+anything that knows about `reload`.
+
+```
+class User < ActiveRecord::Base
+  def name
+    @name ||= "#{first_name} #{last_name}"
+  end
+end
+```
+
+So now, when you do something like this:
+
+```
+user = User.new(:first_name => "Flip", :last_name => "Sasser")
+user.name #=> "Flip Sasser"
+user.first_name = "Elizabeth"
+user.name #=> "Flip Sasser"
+# OH NOE MY INSTANCE VARIABLE GOT CACHED LIKE IT SHOULD
+user.reload.name #=> "Flip Sasser"
+# OH NOE RELOAD DOESN'T RESET INSTANCE VARIABLES
+```
+
+But what if you could hook into `ActiveRecord::Base#reload`?
+
+```
+class User < ActiveRecord::Base
+  hooks do
+    before_reload { @name = nil }
+  end
+
+  def name
+    @name ||= "#{first_name} #{last_name}"
+  end
+end
+```
+
+Now you can reset the instance variable. Neat, right? Obviously this is way more awesome way more places but that's the long and short of it.
+
+Copyright © 2012 Delightful Widgets Inc. No warranty so don't sue me or my company THANKS!

data/Rakefile

@@ -0,0 +1,16 @@
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "big_spoon"
+    gemspec.summary = "Adds before and after hooks to any method, because that's just how things should be"
+    gemspec.description = %{
+      BigSpoon will add a hooks method to every class. Call that method with a block and add all kinds of fun hooks before and after your methods.
+    }
+    gemspec.email = "flip@x451.com"
+    gemspec.homepage = "http://github.com/Plinq/big_spoon"
+    gemspec.authors = ["Flip Sasser"]
+  end
+rescue LoadError
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/big_spoon.gemspec

@@ -0,0 +1,49 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "big_spoon"
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Flip Sasser"]
+  s.date = "2012-08-12"
+  s.description = "\n      BigSpoon will add a hooks method to every class. Call that method with a block and add all kinds of fun hooks before and after your methods.\n    "
+  s.email = "flip@x451.com"
+  s.extra_rdoc_files = [
+    "README.md"
+  ]
+  s.files = [
+    ".rspec",
+    ".rvmrc",
+    ".simplecov",
+    "CHANGES.md",
+    "Gemfile",
+    "Gemfile.lock",
+    "Guardfile",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "big_spoon.gemspec",
+    "lib/big_spoon.rb",
+    "lib/big_spoon/hook.rb",
+    "spec/lib/big_spoon_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = "http://github.com/Plinq/big_spoon"
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.24"
+  s.summary = "Adds before and after hooks to any method, because that's just how things should be"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/lib/big_spoon/hook.rb

@@ -0,0 +1,138 @@
+module BigSpoon
+  class Hook
+    class << self
+      def for(klass)
+        all[klass.to_s] ||= new(klass)
+      end
+
+      private
+      def all
+        @all ||= {}
+      end
+    end
+
+    attr_accessor :klass
+
+    # Define a method to execute after another
+    def after(method_to_hook, method_to_call = nil, &block)
+      hook(:after, method_to_hook, method_to_call, &block)
+    end
+
+    # Define a method to execute before another
+    def before(method_to_hook, method_to_call = nil, &block)
+      hook(:before, method_to_hook, method_to_call, &block)
+    end
+
+    # def clear!
+    #   methods.each do |method_to_hook, hooks|
+    #     unhook! method_to_hook
+    #   end
+    #   methods.clear
+    # end
+
+    # Execute after a method
+    def execute_after(method_to_hook, instance)
+      execute(:after, method_to_hook, instance)
+    end
+
+    # Execute before a method
+    def execute_before(method_to_hook, instance)
+      execute(:before, method_to_hook, instance)
+    end
+
+    # Alias a method for hookable-ness
+    def hook!(method_to_hook)
+      hooked_method = hooked_method(method_to_hook)
+      original_method = original_method(method_to_hook)
+      line = __LINE__; alias_these_hooks = <<-hooks
+        alias :#{original_method} :#{method_to_hook}
+        def #{hooked_method}(*args)
+          Hook.for(self.class).execute_before(:#{method_to_hook}, self)
+          result = #{original_method}
+          Hook.for(self.class).execute_after(:#{method_to_hook}, self)
+          result
+        end
+        alias :#{method_to_hook} :#{hooked_method}
+      hooks
+      klass.class_eval alias_these_hooks, __FILE__, line.succ
+    end
+
+    def initialize(klass)
+      self.klass = klass
+    end
+
+    def should_hook?(method_to_hook)
+      methods[method_to_hook.to_sym] && hookable?(method_to_hook) && !hooked?(method_to_hook)
+    end
+
+    def unhook!(method_to_hook)
+      hooked_method = hooked_method(method_to_hook)
+      original_method = original_method(method_to_hook)
+      line = __LINE__; alias_these_hooks = <<-hooks
+        alias :#{method_to_hook} #{original_method}
+        remove_method #{hooked_method}
+      hooks
+      klass.class_eval alias_these_hooks, __FILE__, line.succ
+    end
+
+    private
+    def execute(before_or_after, method_to_hook, instance)
+      methods[method_to_hook] ||= {}
+      methods[method_to_hook][before_or_after] ||= []
+      methods[method_to_hook][before_or_after].each do |hook_to_call|
+        case hook_to_call
+        when Proc
+          instance.instance_eval(&hook_to_call)
+        else
+          instance.send(hook_to_call)
+        end
+      end
+    end
+
+    def hook(before_or_after, method_to_hook, method_to_call = nil, &block)
+      method_to_hook = method_to_hook.to_sym
+      if block_given?
+        method_to_call = block
+      else
+        method_to_call = method_to_call.to_sym
+      end
+
+      methods[method_to_hook] ||= {}
+      methods[method_to_hook][before_or_after] ||= []
+      methods[method_to_hook][before_or_after].push(method_to_call) unless methods[method_to_hook][before_or_after].include?(method_to_call)
+
+      hook!(method_to_hook) if should_hook?(method_to_hook)
+    end
+
+    def hookable?(method_to_hook)
+      klass.method_defined?(method_to_hook)
+    end
+
+    def hooked?(method_to_hook)
+      klass.method_defined?(hooked_method(method_to_hook))
+    end
+
+	  def hooked_method(method_to_hook)
+	    "_big_spoon_alias_#{method_to_hook}"
+    end
+
+    def method_missing(method_name, *args)
+      case method_name.to_s
+      when /^after_(.+)$/
+        after $1, *args
+      when /^before_(.+)$/
+        before $1, *args
+      else
+        super
+      end
+    end
+
+    def methods
+      @methods ||= {}
+    end
+
+	  def original_method(method_to_hook)
+	    "_big_spoon_original_#{method_to_hook}"
+    end
+  end
+end

data/lib/big_spoon.rb

@@ -0,0 +1,25 @@
+require 'big_spoon/hook'
+
+module BigSpoon
+  module ClassMethods
+    def hooks(options = {}, &block)
+      @hooks ||= Hook.for(self)
+      @hooks.instance_eval(&block) if block_given?
+
+      unless respond_to?(:_big_spoon_original_method_added)
+        class << self
+          alias :_big_spoon_original_method_added :method_added
+          def _big_spoon_alias_method_added(method_to_hook, *args)
+            if @hooks.should_hook?(method_to_hook)
+              @hooks.hook! method_to_hook
+            end
+          end
+          alias :method_added :_big_spoon_alias_method_added
+        end
+      end
+      @hooks
+    end # `hooks` method
+  end # `ClassMethods` module
+end # `BigSpoon` module
+
+Object.extend BigSpoon::ClassMethods

data/spec/lib/big_spoon_spec.rb

@@ -0,0 +1,91 @@
+require 'big_spoon'
+
+class BigSpoonTest
+  hooks do
+    before :foo!, :hook_1
+  end
+
+  def foo!
+    :foo
+  end
+
+  def bar!
+    :bar
+  end
+
+  private
+  def by_all_means_hook
+    true
+  end
+
+  def dont_hook
+    false
+  end
+
+  def hook_1
+    :hook_1
+  end
+
+  def hook_2
+    :hook_2
+  end
+
+  def hook_3
+    :hook_3
+  end
+end
+
+describe BigSpoon do
+  before :each do
+    @big_spoon_test = BigSpoonTest.new
+  end
+
+  it "should monkeypatch Object" do
+    Object.should respond_to(:hooks)
+  end
+
+  it "should allow me to add a hook before an object's methods BEFORE THEY EXIST" do
+    @big_spoon_test.should_receive(:hook_1)
+    @big_spoon_test.foo!
+  end
+
+  it "should allow me to add a hook after an object's methods AFTER THEY EXIST" do
+    BigSpoonTest.hooks do
+      after :bar!, :hook_2
+    end
+    @big_spoon_test.should_receive(:hook_2)
+    @big_spoon_test.bar!
+  end
+
+  it "should allow me to add a hook lambda" do
+    BigSpoonTest.hooks do
+      after :bar! do
+        puts self.inspect
+      end
+    end
+    @big_spoon_test.should_receive(:puts)
+    @big_spoon_test.should_receive(:inspect)
+    @big_spoon_test.bar!
+  end
+
+  it "should still return the appropriate method's value" do
+    @big_spoon_test.should_receive(:hook_1)
+    @big_spoon_test.foo!.should == :foo
+  end
+
+  it "should allow me to metaprogram before_* hooks" do
+    @big_spoon_test.should_receive(:hook_2)
+    BigSpoonTest.hooks do
+      before_foo! :hook_2
+    end
+    @big_spoon_test.foo!
+  end
+
+  it "should allow me to metaprogram after_* hooks" do
+    @big_spoon_test.should_receive(:hook_3)
+    BigSpoonTest.hooks do
+      after_foo! :hook_3
+    end
+    @big_spoon_test.foo!
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+# Add lib/ to the load path
+$LOAD_PATH.unshift(File.expand_path(File.join('..', 'lib'), File.dirname(__FILE__)))
+
+# Load up our Gemfile
+require 'rubygems'
+require 'bundler/setup'
+Bundler.require(:default, :test)
+
+# Enable coverage reporting
+require 'simplecov'

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: big_spoon
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Flip Sasser
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-12 00:00:00.000000000 Z
+dependencies: []
+description: ! "\n      BigSpoon will add a hooks method to every class. Call that
+  method with a block and add all kinds of fun hooks before and after your methods.\n
+  \   "
+email: flip@x451.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- .rspec
+- .rvmrc
+- .simplecov
+- CHANGES.md
+- Gemfile
+- Gemfile.lock
+- Guardfile
+- README.md
+- Rakefile
+- VERSION
+- big_spoon.gemspec
+- lib/big_spoon.rb
+- lib/big_spoon/hook.rb
+- spec/lib/big_spoon_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/Plinq/big_spoon
+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'
+      segments:
+      - 0
+      hash: 4152067215125062110
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Adds before and after hooks to any method, because that's just how things
+  should be
+test_files: []