callbacks 0.0.1

data/History.txt

@@ -0,0 +1,5 @@
+== 0.0.1 / 2008-05-10
+
+* First release
+  * API not yet stable
+  * Only supports adding hooks to classes not instances. Instances are planned for 0.2

data/Manifest.txt

@@ -0,0 +1,29 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+Version.txt
+bin/callbacks
+ext/metaid.rb
+lib/callback.rb
+lib/callbacks.rb
+lib/classmethods.rb
+lib/instancemethods.rb
+spec/callbacks_spec.rb
+spec/spec_helper.rb
+tasks/ann.rake
+tasks/bones.rake
+tasks/gem.rake
+tasks/manifest.rake
+tasks/notes.rake
+tasks/post_load.rake
+tasks/rdoc.rake
+tasks/rubyforge.rake
+tasks/setup.rb
+tasks/spec.rake
+tasks/svn.rake
+tasks/test.rake
+test/profile.rb
+test/test_callbacks.rb
+test/test_helper.rb
+test/tester_class.rb

data/README.txt

@@ -0,0 +1,65 @@
+callbacks
+    by Leon Bogaert
+    http://github.com/LeonB/callbacks
+    http://callbacks.rubyforge.com
+    http://www.vanutsteen.nl
+
+== DESCRIPTION:
+
+This package makes it simple to add callbacks a.k.a. "hooks" to ruby classes
+
+== FEATURES/PROBLEMS:
+
+* It now only supports adding callbacks to classes
+* Different callbacks for instances comes with version 0.2
+* I haven't decided yet on the API, maybe I'll swap "callback_methods" with "hooks"
+
+== SYNOPSIS:
+
+    require 'callbacks'
+
+    Object.send(:include, Callbacks)
+    Object.add_callback_methods :inspect
+    Object.before_inspect do
+    print "Going to inspect #{self.class}\n"
+    end
+
+    o = Object.new
+    o.inspect #will print "Going to inspect Object"
+
+== REQUIREMENTS:
+
+* ruby 1.8 (might work with ruby1.9)
+
+== INSTALL:
+
+* gem install callbacks
+
+== THANKS:
+    * RDoc [http://www.ruby-doc.org/core/classes/RDoc.html]
+    * Bones [http://codeforpeople.rubyforge.org/bones]
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008
+
+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/Rakefile

@@ -0,0 +1,25 @@
+# Look in the tasks/setup.rb file for the various options that can be
+# configured in this Rakefile. The .rake files in the tasks directory
+# are where the options are used.
+
+load 'tasks/setup.rb'
+
+ensure_in_path 'lib'
+require 'callbacks'
+
+task :default => 'spec:run'
+
+PROJ.name = 'callbacks'
+PROJ.authors = 'Leon Bogaert'
+PROJ.email = 'leon@vanutsteen.nl'
+PROJ.url = 'www.vanutsteen.nl'
+PROJ.rubyforge.name = 'callbacks'
+PROJ.version = File.read('Version.txt').strip
+PROJ.exclude = %w(.git pkg/ nbproject/ doc/ ^test[0-9]*.rb$ website/ )
+
+PROJ.rdoc.exclude = %w(Version.txt)
+PROJ.rdoc.remote_dir = 'docs/'
+
+PROJ.spec.opts << '--color'
+
+# EOF

data/Version.txt

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

data/bin/callbacks

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(
+    File.join(File.dirname(__FILE__), '..', 'lib', 'callbacks'))
+
+# Put your code here
+
+# EOF

data/ext/metaid.rb

@@ -0,0 +1,18 @@
+#The well know file made by why (http://redhanded.hobix.com/inspect/seeingMetaclassesClearly.html)
+class Object
+  # The hidden singleton lurks behind everyone
+  def metaclass; class << self; self; end; end
+  def meta_eval &blk
+    metaclass.instance_eval(&blk)
+  end
+
+  # Adds methods to a metaclass
+  def meta_def name, &blk
+    meta_eval { define_method name, &blk }
+  end
+
+  # Defines an instance method within a class
+  def class_def name, &blk
+    class_eval { define_method name, &blk }
+  end
+end

data/lib/callback.rb

@@ -0,0 +1,43 @@
+class Callback
+  attr_accessor :method, :input
+  attr_writer :proc
+  ACCEPTED = [Symbol, Proc, String, Method]
+  
+  def initialize(method, input, &block)
+    #self.method = method
+    self.input = input
+    self.input = block if block_given?
+    
+    if not ACCEPTED.include? self.input.class
+      raise "Callbacks must be a symbol denoting the method to call, a string to be evaluated, a block to be invoked, or an object responding to the callback method. #{self.input} is none of those."
+    end
+  end
+  
+  def proc
+    @proc ||= self.generate_proc
+  end
+  
+  def block
+    @block ||= self.generate_block
+  end
+  
+  def generate_proc
+    case self.input
+    when String
+      Proc.new { eval(self.input) }
+    #else if self.input.respond_to?(self.method)
+    #    Proc.new { callback.send(method, self) }
+    #  end
+    end
+  end
+  
+  def generate_block
+    case self.input
+    when Symbol
+      symbol = self.input.to_sym
+      Proc.new { self.send(symbol) }
+    when Proc, Method
+      self.input
+    end
+  end
+end

data/lib/callbacks.rb

@@ -0,0 +1,27 @@
+#Idea stolen from rails/activerecord
+module Callbacks
+  require 'observer'
+  require 'ext/metaid.rb'
+  require 'instancemethods.rb'
+  require 'classmethods.rb'
+  require 'callback.rb'
+  
+  #  CALLBACKS = [
+  #    'song_halfway',
+  #    'song_end',
+  #    'boot',
+  #    'shutdown',
+  #  ]
+  
+  CALLBACKS = []
+
+  #Sets all things right
+  def self.included(base) #:nodoc:
+    base.extend Observable
+    base.extend Callbacks::ClassMethods
+    base.send(:include, Callbacks::InstanceMethods)
+  end
+end
+
+#TODO: add aliases like add_hook(), callbacks(), et cetera
+#TODO: feature to add hooks/callbacks to instances instead of only classes

data/lib/classmethods.rb

@@ -0,0 +1,78 @@
+module Callbacks
+  module ClassMethods
+    
+    def callback_methods
+      #Use one @, else it gets stored in the module and then it will be avaiable in every class that uses callback
+      @callback_methods ||= []
+    end 
+   
+    def callback_actions
+      #Use one @, else it gets stored in the module and then it will be avaiable in every class that uses callback
+      @callback_actions ||= {}
+    end
+   
+    def add_callback_methods(*callbacks)
+      callbacks.each do |callback|
+        self.callback_methods << callback.to_sym
+        self.build_callback_method(callback)
+      end
+    end
+    
+    def remove_callback_method(method)      
+      self.meta_eval do
+        remove_method("before_#{method}")
+        remove_method("after_#{method}")
+      end
+      
+      remove_method("#{method}_with_callbacks")
+      remove_method(method) #This is the method_with_callbacks
+      alias_method(method, "#{method}_without_callbacks")
+      self.callback_methods.delete(method.to_sym)
+    end
+    
+    def build_callback_method(method)
+        
+      #instance_eval do
+      instance_eval <<-"end_eval"
+
+          def before_#{method}(*callbacks, &block)
+            add_callback_action :before, :#{method}, *callbacks, &block
+          end
+
+          def after_#{method}(*callbacks, &block)
+            add_callback_action :after, :#{method}, *callbacks, &block
+          end
+
+      end_eval
+      #end
+      
+      class_eval <<-"end_eval"
+        def #{method}_with_callbacks
+          trigger_callback_actions(:#{method}, :before)
+          retval = self.send("#{method}_without_callbacks")
+          trigger_callback_actions(:#{method}, :after)
+          return retval
+        end
+      end_eval
+      
+      send :alias_method, "#{method}_without_callbacks", method
+      send :alias_method, method, "#{method}_with_callbacks"
+    end
+
+    def add_callback_action(type, method, *code, &block)
+      ca = self.callback_actions
+      
+      ca[method] = {} if ca[method].nil?
+      ca[method][type] = [] if ca[method][type].nil?
+      
+      if block_given?
+        ca[method][type] << Callback.new(method, nil, &block)
+      else
+        code.each do |c|
+          ca[method][type] << Callback.new(method, c)
+        end
+      end
+    end
+    
+  end
+end

data/lib/instancemethods.rb

@@ -0,0 +1,38 @@
+module Callbacks
+  module InstanceMethods
+    
+    def callback_actions(show_classvars = true)
+      return self.class_callback_actions
+      #return self.instance_callbacks if show_classvars == false
+      #return self.class_callback_actions + self.instance_callback_actions if show_classvars == true
+    end
+    
+    #Really don't know what this does :p But it works!
+    #I'm really, really bad at metaprogramming
+    def callback_actions_for(method, type)
+      begin
+        return self.callback_actions[method] if type.nil?
+        return self.callback_actions[method][type] ||= []
+      rescue NoMethodError
+        return []
+      end
+    end
+    
+    def class_callback_actions
+      self.class.callback_actions
+    end
+
+    def trigger_callback_actions(method, type)
+      
+      self.callback_actions_for(method, type).each do |callback|
+        if callback.block
+          return instance_eval(&callback.block)
+        else
+          callback.proc.call
+        end
+      end
+    
+      #Should I return something?
+    end
+  end
+end

data/spec/callbacks_spec.rb

@@ -0,0 +1,8 @@
+# $Id$
+
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe Callbacks do
+end
+
+# EOF

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+# $Id$
+
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. lib callbacks]))
+
+Spec::Runner.configure do |config|
+  # == Mock Framework
+  #
+  # RSpec uses it's own mocking framework by default. If you prefer to
+  # use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+end
+
+# EOF

data/tasks/ann.rake

@@ -0,0 +1,81 @@
+# $Id$
+
+begin
+  require 'bones/smtp_tls'
+rescue LoadError
+  require 'net/smtp'
+end
+require 'time'
+
+namespace :ann do
+
+  # A prerequisites task that all other tasks depend upon
+  task :prereqs
+
+  file PROJ.ann.file do
+    ann = PROJ.ann
+    puts "Generating #{ann.file}"
+    File.open(ann.file,'w') do |fd|
+      fd.puts("#{PROJ.name} version #{PROJ.version}")
+      fd.puts("    by #{Array(PROJ.authors).first}") if PROJ.authors
+      fd.puts("    #{PROJ.url}") if PROJ.url.valid?
+      fd.puts("    (the \"#{PROJ.release_name}\" release)") if PROJ.release_name
+      fd.puts
+      fd.puts("== DESCRIPTION")
+      fd.puts
+      fd.puts(PROJ.description)
+      fd.puts
+      fd.puts(PROJ.changes.sub(%r/^.*$/, '== CHANGES'))
+      fd.puts
+      ann.paragraphs.each do |p|
+        fd.puts "== #{p.upcase}"
+        fd.puts
+        fd.puts paragraphs_of(PROJ.readme_file, p).join("\n\n")
+        fd.puts
+      end
+      fd.puts ann.text if ann.text
+    end
+  end
+
+  desc "Create an announcement file"
+  task :announcement => ['ann:prereqs', PROJ.ann.file]
+
+  desc "Send an email announcement"
+  task :email => ['ann:prereqs', PROJ.ann.file] do
+    ann = PROJ.ann
+    from = ann.email[:from] || PROJ.email
+    to   = Array(ann.email[:to])
+
+    ### build a mail header for RFC 822
+    rfc822msg =  "From: #{from}\n"
+    rfc822msg << "To: #{to.join(',')}\n"
+    rfc822msg << "Subject: [ANN] #{PROJ.name} #{PROJ.version}"
+    rfc822msg << " (#{PROJ.release_name})" if PROJ.release_name
+    rfc822msg << "\n"
+    rfc822msg << "Date: #{Time.new.rfc822}\n"
+    rfc822msg << "Message-Id: "
+    rfc822msg << "<#{"%.8f" % Time.now.to_f}@#{ann.email[:domain]}>\n\n"
+    rfc822msg << File.read(ann.file)
+
+    params = [:server, :port, :domain, :acct, :passwd, :authtype].map do |key|
+      ann.email[key]
+    end
+
+    params[3] = PROJ.email if params[3].nil?
+
+    if params[4].nil?
+      STDOUT.write "Please enter your e-mail password (#{params[3]}): "
+      params[4] = STDIN.gets.chomp
+    end
+
+    ### send email
+    Net::SMTP.start(*params) {|smtp| smtp.sendmail(rfc822msg, from, to)}
+  end
+end  # namespace :ann
+
+desc 'Alias to ann:announcement'
+task :ann => 'ann:announcement'
+
+CLOBBER << PROJ.ann.file
+
+# EOF