call_me_maybe 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.pryrc

@@ -0,0 +1,34 @@
+require 'call_me_maybe'
+
+begin
+  require 'awesome_print'
+  Pry.config.print = proc { |output, value| output.puts value.ai }
+rescue LoadError => err
+  puts "no awesome_print :("
+end
+
+class New
+  def apple
+    puts "Apples are tasty ^_^"
+  end
+
+  def self.orange
+    puts "Oranges are too sweet for me ^.^'"
+  end
+
+  call_me_maybe klass: "#{self}", method: :apple, event: :before do
+    puts "Before Callback: Instance Level"
+  end
+
+  call_me_maybe klass: "#{self}", method: :orange, type: :class, event: :before do
+    puts "Before Callback: Class Method"
+  end
+
+  call_me_maybe method: :apple, event: :after do
+    puts "After Callback: Instance Level"
+  end
+
+  call_me_maybe klass: "New.orange", type: :class, event: :after do
+    puts "After Callback: Class Method"
+  end
+end

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gem 'activesupport', '>= 3.2.12', require: [
+  'active_support/core_ext/module/attribute_accessors',
+  'active_support/inflector'
+]
+
+# Specify your gem's dependencies in call_me_maybe.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Kelly Becker
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,84 @@
+# Call Me Maybe
+
+Call Me Maybe is a simple event engine for Ruby. This event engine was modeled a little after the event engine from EvolutionSDK 3.0 and then taking it a step further. The idea here is that you can capture the call of any method as well as bind any method to listen for an event trigger and fire events. It's simply awesome!
+
+## Dependencies
+
+    * activesupport
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'call_me_maybe'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install call_me_maybe
+
+## Usage - Catching Method Calls
+
+So this is really awesome. When it comes to use. So the real logic for awesome callbacks is this `call_me_maybe` method. This method is actually attached to the Module object so it's extremely versitile and is not instance or class specific.
+
+The arguments for `call_me_maybe` are:
+
+    - klass: Klass is the object that owns the method you are planning to track. If the method is on the same object as where you are executing `call_me_maybe`, then you do not need to pass this argument. Klass also accepts methods on the klass name if klass is provided as a string (i.e. "New.other"; where New is the class and other is the method).
+    - method: Method is the method that you would like to call. Just the name of the method it does not matter whether or not the method is a singelton method or a instance method.
+    - type: Type tells `call_me_maybe` which method to watch; the instance method or the singleton method. The acceptable options are either :class or :instance, :instance is set by default.
+    - event: The method you would like to capture. The only supported events that the `call_me_maybe` method supports are :before and :after.
+    - me: Me is hash arguments that refer to what should be run when the method you are tracking is called and the event is fired.
+        * when: When is the event you want your task to run on. It is synonymous with the event: option
+        * event: When is the event you want your task to run on. It is synonymous with the when: option
+        * block: Block a Proc object that will be called when the event is fired. You can also pass a block to `call_me_maybe` and it will be used here instead. If you pass a block then the klass-method pairing for the callbacks will not be fired.
+        * klass: So this klass is the reference to the object that you want to run the method on when the event fires. This accepts a klass object, klass string name or a klass string name with a method attached (see example above).
+        * method: Method is the method you wish to run on the klass provided to to be used when the event fires.
+
+```ruby
+class New
+  def apple
+    puts "Apples are tasty ^_^"
+  end
+
+  def self.orange
+    puts "Oranges are too sweet for me ^.^'"
+  end
+
+  call_me_maybe klass: "#{self}", method: :apple, event: :before do
+    puts "Before Callback: Instance Level"
+  end
+
+  call_me_maybe klass: "#{self}", method: :orange, type: :class, event: :before do
+    puts "Before Callback: Class Method"
+  end
+
+  call_me_maybe method: :apple, event: :after do
+    puts "After Callback: Instance Level"
+  end
+
+  call_me_maybe klass: "New.orange", type: :class, event: :after do
+    puts "After Callback: Class Method"
+  end
+end
+```
+
+## Usage - Registering Events and Triggers
+
+Coming Soon
+
+```ruby
+CallMeMaybe::Exchange.add_listener
+
+CallMeMaybe::Exchange.trigger
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

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

data/call_me_maybe.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'call_me_maybe/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "call_me_maybe"
+  spec.version       = CallMeMaybe::VERSION
+  spec.authors       = ["Kelly Becker"]
+  spec.email         = ["kellylsbkr@gmail.com"]
+  spec.description   = %q{Event handler and listener for Ruby}
+  spec.summary       = %q{Listens and captures event comings from objects}
+  spec.homepage      = "http://kellybecker.me"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "awesome_print"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "pry"
+
+  spec.add_development_dependency "activesupport", ">= 3.2.12"
+end

data/lib/call_me_maybe.rb

@@ -0,0 +1,21 @@
+# Load our specificly requested AS components
+require "active_support/core_ext/module/attribute_accessors"
+require "active_support/inflector"
+require 'awesome_print'
+
+# Load in the Call Me Maybe files
+require "call_me_maybe/version"
+require "call_me_maybe/exchange"
+require "call_me_maybe/module"
+
+# Add in the `call_me_maybe` command
+module CallMeMaybe
+  class << self
+    def setup
+      ::Module.__send__(:include, CallMeMaybe::Module)
+    end
+  end
+end
+
+# Startup the module
+CallMeMaybe.setup

data/lib/call_me_maybe/exchange.rb

@@ -0,0 +1,121 @@
+module CallMeMaybe
+  module Exchange
+    class Careful < StandardError; end
+    class MethodDoesNotExist < StandardError; end
+    class CantCaptureMethod < StandardError; end
+
+    mattr_accessor :methods, instance_accessor: false
+    mattr_accessor :listeners, instance_accessor: false
+
+    class << self
+      def add_method(args = {})
+        id, name = get_id(args)
+
+        # Create the cache
+        CallMeMaybe::Exchange.methods ||= {}
+
+        # Create the method if needed
+        if CallMeMaybe::Exchange.methods[id] && ! CallMeMaybe::Exchange.methods[id].has_key?(:method_obj)
+          CallMeMaybe::Exchange.methods[id].merge!(args)
+          true
+        elsif ! methods[id]
+          CallMeMaybe::Exchange.methods[id] = args.merge(name: name)
+          true
+        else
+          false
+        end
+      end
+
+      def get_method(args = {})
+        # Ensure the cache's presence
+        CallMeMaybe::Exchange.methods ||= {}
+        raise MethodDoesNotExist unless method_exists?(args)
+        CallMeMaybe::Exchange.methods[get_id(args).first][:method_obj]
+      end
+
+      def method_exists?(args = {})
+        # Ensure the cache's presence
+        CallMeMaybe::Exchange.methods ||= {}
+        CallMeMaybe::Exchange.methods.has_key?(get_id(args).first)
+      end
+
+      def del_method(args = {})
+        raise Careful, "Please use `del_method!` if you really want to do this."
+      end
+
+      def del_method!(args = {})
+        # Ensure the cache's presence
+        CallMeMaybe::Exchange.methods ||= {}
+        CallMeMaybe::Exchange.methods.delete(get_id(args).first)
+        true
+      end
+
+      def trigger(event, obj, args = {}, &block)
+        id = get_id(args).first
+
+        # Prepare the cache
+        CallMeMaybe::Exchange.listeners ||= {}
+        CallMeMaybe::Exchange.listeners[event] ||= {}
+        CallMeMaybe::Exchange.listeners[event][id] ||= []
+
+        # Run the listening events
+        CallMeMaybe::Exchange.listeners[event][id].map do |callback|
+          if callback[:block] && callback[:block].is_a?(Proc)
+            callback[:block].call(obj, args, &block)
+          else
+            callback[:klass].constantize.__send__(callback[:method], obj, args[:meta], &block)
+          end
+        end
+
+        CallMeMaybe::Exchange.listeners[event][id].count
+      end
+
+      def add_listener(args = {}, &block)
+
+        # Prepare the listeners data
+        args[:me]         ||= {}
+        args[:me][:when]  ||= args.delete(:when)  if args.has_key?(:when)
+        args[:me][:when]  ||= args.delete(:event) if args.has_key?(:event)
+        args[:me][:block] ||= args.delete(:block) if args.has_key?(:block)
+        args[:me][:block] ||= block               if block_given?
+
+        # Ensure that our event name we are capturing is in the right format
+        args[:me][:when] = "#{args[:me][:when]}".underscore.to_sym if args[:me].has_key?(:when)
+
+        # Get id
+        id = get_id(args).first
+
+        # Prepare the cache
+        CallMeMaybe::Exchange.listeners ||= {}
+        CallMeMaybe::Exchange.listeners[args[:me][:when]] ||= {}
+        CallMeMaybe::Exchange.listeners[args[:me][:when]][id] ||= []
+
+        # Add the details to the cache
+        if args[:block].is_a?(Proc)
+          CallMeMaybe::Exchange.listeners[args[:me][:when]][id] << args[:me][:block]
+        else
+          CallMeMaybe::Exchange.listeners[args[:me][:when]][id] << args[:me]
+        end
+
+        # Unique on the callbacks
+        a = CallMeMaybe::Exchange.listeners[args[:me][:when]][id].uniq
+        CallMeMaybe::Exchange.listeners[args[:me][:when]][id] = a
+        true
+      end
+
+      private
+
+      # Return the cache id.
+      def get_id(args = {})
+        if args.has_key?(:type) && args.has_key?(:klass) && args.has_key?(:method)
+          name = "#{args[:type]}: #{args[:klass]}.#{args[:method]}".to_sym
+          [name.object_id, name]
+        elsif args.has_key?(:name)
+          ["#{args[:name]}".downcase.to_sym]
+        else
+          raise CantCaptureMethod, "We need name; or type, klass and method passed in order to generate an id properly."
+        end
+      end
+    end
+  end
+end

data/lib/call_me_maybe/module.rb

@@ -0,0 +1,117 @@
+module CallMeMaybe
+  class MissingArgs < StandardError; end
+
+  module Module
+    def call_me_maybe(args = {}, &block)
+
+      ###################
+      #= Listener Data =#
+      ###################
+
+      # Prepare the listeners data
+      args[:me]         ||= {}
+      args[:me][:when]  ||= args.delete(:when)  if args.has_key?(:when)
+      args[:me][:when]  ||= args.delete(:event) if args.has_key?(:event)
+      args[:me][:block] ||= args.delete(:block) if args.has_key?(:block)
+      args[:me][:block] ||= block               if block_given?
+
+      # Ensure that our event name we are capturing is in the right format
+      args[:me][:when] = "#{args[:me][:when]}".underscore.to_sym if args[:me].has_key?(:when)
+
+      #####################
+      #= Capture Wrapper =#
+      #####################
+
+      # Default to catching instance methods
+      # and ensure klass is present and a string
+      args[:type]  ||= :instance
+      args[:klass] ||= self
+      args[:klass]   = "#{args[:klass]}"
+
+      # If the method was attached to the klass name
+      # then go ahead and parse it out
+      if args[:klass].include?('.')
+        klass, method = args[:klass].split('.')
+
+        args[:klass]  = klass
+        args[:method] = method
+      end
+
+      # Ensure we have the klass and method we are capturing
+      raise MissingArgs, "We need the klass we are capturing" unless args[:klass]
+      raise MissingArgs, "We need the method we are capturing" unless args[:method]
+
+      # Prepare the format for the klass, method, type and event firing time
+      args[:klass]  = "#{args[:klass]}".camelize
+      args[:method] = "#{args[:method]}".underscore.to_sym
+      args[:type]   = "#{args[:type]}".downcase.to_sym
+
+      # Don't bother re-adding the method if it is already added
+      unless CallMeMaybe::Exchange.method_exists?(args)
+
+        # Constantize the klass
+        klass = args[:klass].constantize
+
+        # Add method args
+        margs = args.dup
+        margs.delete(:me)
+
+        # Proc for setting up the capturing of the method in question
+        capture_proc = Proc.new do
+          gmethod = args[:type] == :instance ? :instance_method : :method
+          cmethod = args[:type] == :instance ? :define_method : :define_singleton_method
+          CallMeMaybe::Exchange.add_method(margs.merge(method_obj: klass.__send__(gmethod, args[:method])))
+
+          klass.__send__(cmethod, args[:method]) do |*a, &b|
+
+            # Trigger before method is called callback
+            CallMeMaybe::Exchange.trigger(:before, self, args.merge(meta: {args: a, block: b}))
+
+            # Run the actual method using the CallMeMaybe cache
+            result = CallMeMaybe::Exchange.get_method(args)
+            result = (result.is_a?(UnboundMethod) ? result.bind(self) : result).call(*a, &b)
+
+            # Trigger after method is called callback
+            CallMeMaybe::Exchange.trigger(:after, self, args.merge(meta: {args: a, block: b, result: result}))
+
+            # Return the result
+            result
+          end
+        end
+
+        # Apply capture_proc to the klasses that we need to use
+        if args[:type] == :class && klass.singleton_methods.include?(args[:method])
+          klass.class.__send__(:class_exec, &capture_proc)
+        elsif args[:type] == :instance && klass.instance_methods.include?(args[:method])
+          klass.__send__(:class_exec, &capture_proc)
+        end
+      end
+
+      ####################
+      #= Listener Stuff =#
+      ####################
+
+      # If we need to add a listener as well go ahead and start that implementation
+      if args.has_key?(:me) && ! args[:me].empty?
+
+        # We need an event to listen to.
+        raise MissingArgs, "We need the event that we are capturing." unless args[:me][:when] || args[:me][:event]
+
+        # We need information on who to call when the event occurs
+        unless args[:me][:block] || (args[:me][:klass] && args[:me][:method])
+          raise MissingArgs, "We need the a proc, block or information on what to run when the event occurs."
+        end
+
+        # Faking some arguments
+        args[:me][:klass] ||= args[:klass]
+        if args[:me][:block] && ( ! args[:me][:klass] || ! args[:me][:method])
+          args[:me][:klass]  = 'Proc'
+          args[:me][:method] = 'call'
+        end
+
+        # Add a listener for the method declared here
+        CallMeMaybe::Exchange.add_listener(args)
+      end
+    end
+  end
+end

data/lib/call_me_maybe/version.rb

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

metadata

@@ -0,0 +1,154 @@
+--- !ruby/object:Gem::Specification
+name: call_me_maybe
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Kelly Becker
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.12
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.12
+description: Event handler and listener for Ruby
+email:
+- kellylsbkr@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .pryrc
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- call_me_maybe.gemspec
+- lib/call_me_maybe.rb
+- lib/call_me_maybe/exchange.rb
+- lib/call_me_maybe/module.rb
+- lib/call_me_maybe/version.rb
+homepage: http://kellybecker.me
+licenses:
+- MIT
+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: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Listens and captures event comings from objects
+test_files: []
+has_rdoc: