hammock 0.2.11.2

data/History.txt

@@ -0,0 +1,67 @@
+== 0.2.11.2 2009-03-24
+Loosened Rails dependency from ~> 2.2.2 to 2.2.
+
+
+== 0.2.11.1 2009-03-24
+Fixed 'railslol' typo in Rakefile preventing installation. (lol)
+
+
+== 0.2.11 2009-03-23
+Added hammock include hook to hammock.rb, to sidestep changed ApplicationController load behaviour in Rails 2.3.
+Added pagination support to the index route.
+Changed #mdl and #mdl_name implementations to class methods, and re-aliased them as instance methods.
+
+
+== 0.2.10 2009-03-17
+Added AR::Base.suggest_scope for narrowing the scope in the suggest action.
+Changed identifier in AR::Base#concise_inspect from #id to #to_param.
+Fixed raise condition for entities arg to RouteNode#for, and improved exception message.
+Changed squash! to compact! in route_for, to only remove nil elements (and not, say, models with no records that respond true to blank?).
+
+
+== 0.2.9 2009-03-13
+Updated partial_exists? to default format to the current request format instead of html, and accept format instead of extension as a parameter.
+
+
+== 0.2.8 2009-03-10
+Renamed @current_account to current_user.
+Removed AC::Base#nestable_by declaration in favour of the new approach involving AC::Base#route_by and #nest_within, along with the corresponding reader.
+Added #set_new_or_deleted_before_save controller method, and before_create and before_undestroy hooks.
+Revert "Removed unneeded param to specify the finder method in retrieve_record." - the param was actually needed for #find_deleted_record.
+
+
+== 0.2.7 2009-03-05
+hamlink_to with implied verbs no longer raises in route_for.
+
+
+== 0.2.6 2009-03-05
+Access current_nested_records in nested_route_for through the method instead of directly.
+Replaced #assign_nestable_resources with #assign_nesting_entities, to separately kick and assign an ivar for each of the current rou
+Added nesting_scope_list to encapsulate what @hammock_nesting_scopes was set to before.
+Updated nested_within? to use methods instead of ivars, removed duping from current_nested_[record,resource]s, and added add_nested_en
+Updated empty_scope for sqlite, to bring it in line with public_scope.
+Updated current_scope to fail gracefully if current_verb_scope (renamed from verb_scope along with [current_]nest_scope) returns nil.
+Replaced RouteNode#nesting_scope_for with nesting_scope_list_for, and changed nest_scope call appropriately. The scopes are returned s
+Replaced AR::Base#id_or_description with #description, added .description, and use in link_class_for for more consistent class names.
+Split Hammock::Callback (previously HammockCallback) out into its own file.
+Split RouteNode and RouteStep (previously HammockResource and HammockRoutePiece) out into their own files.
+Reject Hammock:: classes from hammock load. Classes are modules. Who knew?
+Changed inheritable_attribute keys from strings to symbols.
+Caching the model within HammockResource was causing stale class fails in development mode.
+retrieve_record uses mdl.routing_attribute now instead of the old find_column_name.
+Default routing_attribute to :id.
+Fixed the 'no valid AR reflections' message to be a user error instead of an internal hammock error (they just need to add a reflection)
+HammockRoutePiece erroneously had a root? check instead of a parent.nil? check - fixed.
+Only set creator_id if someone is logged in.
+Updated #nest_scope to use #nesting_scope_for instead of manually recursively selecting within a single context, and updated #curren
+Re-enabled logging of Ambition queries as they are assigned as entities.
+Replaced the questionable #current_route with #current_hammock_resource, which uses HammockResource#base_for.
+Added HammockResource#base_for, #nesting_scope_for and #nesting_scope_segment_for.
+Added HammockResource#determine_routing_parent, to determine which ActiveRecord reflection to use to generate joins for route queryi
+Added Hash#selekt, to sidestep the ruby-1.8/1.9 #select changes.
+Commented current_route-dependent code in hamlink_to until that is sorted out.
+Test if obj is defined before attempting to select .spinner within it.
+
+== 0.2.4 2009-02-25
+
+* Initial gem release

data/LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2008 Ben Hoskings <ben@hoskings.net>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of Ben Hoskings nor the names of any of the software's
+      contributors may be used to endorse or promote products derived from
+      this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER "AS IS" AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/Manifest.txt

@@ -0,0 +1,46 @@
+History.txt
+LICENSE
+Manifest.txt
+README.rdoc
+Rakefile
+hammock.gemspec
+lib/hammock.rb
+lib/hammock/ajaxinate.rb
+lib/hammock/callback.rb
+lib/hammock/callbacks.rb
+lib/hammock/canned_scopes.rb
+lib/hammock/constants.rb
+lib/hammock/controller_attributes.rb
+lib/hammock/export_scope.rb
+lib/hammock/hamlink_to.rb
+lib/hammock/javascript_buffer.rb
+lib/hammock/logging.rb
+lib/hammock/model_attributes.rb
+lib/hammock/model_logging.rb
+lib/hammock/monkey_patches/action_pack.rb
+lib/hammock/monkey_patches/active_record.rb
+lib/hammock/monkey_patches/array.rb
+lib/hammock/monkey_patches/hash.rb
+lib/hammock/monkey_patches/logger.rb
+lib/hammock/monkey_patches/module.rb
+lib/hammock/monkey_patches/numeric.rb
+lib/hammock/monkey_patches/object.rb
+lib/hammock/monkey_patches/route_set.rb
+lib/hammock/monkey_patches/string.rb
+lib/hammock/overrides.rb
+lib/hammock/resource_mapping_hooks.rb
+lib/hammock/resource_retrieval.rb
+lib/hammock/restful_actions.rb
+lib/hammock/restful_rendering.rb
+lib/hammock/restful_support.rb
+lib/hammock/route_drawing_hooks.rb
+lib/hammock/route_for.rb
+lib/hammock/route_node.rb
+lib/hammock/route_step.rb
+lib/hammock/scope.rb
+lib/hammock/suggest.rb
+lib/hammock/utils.rb
+misc/scaffold.txt
+misc/template.rb
+tasks/hammock_tasks.rake
+test/hammock_test.rb

data/README.rdoc

@@ -0,0 +1,105 @@
+= hammock
+
+http://github.com/benhoskings/hammock
+
+
+== DESCRIPTION:
+
+Hammock is a Rails plugin that eliminates redundant code in a very RESTful manner. It does this in lots in lots of different places, but in one manner: it encourages specification in place of implementation.
+
+
+Hammock enforces RESTful resource access by abstracting actions away from the controller in favour of a clean, model-like callback system.
+
+Hammock tackles the hard and soft sides of security at once with a scoping security system on your models. Specify who can verb what resources under what conditions once, and everything else - the actual security, link generation, index filtering - just happens.
+
+Hammock inspects your routes and resources to generate a routing tree for each resource. Parent resources in a nested route are handled transparently at every point - record retrieval, creation, and linking.
+
+It makes more sense when you see how it works though, so check out the screencast!
+
+
+== REQUIREMENTS:
+
+benhoskings-ambition
+benhoskings-ambitious-activerecord
+
+
+== INSTALL:
+
+sudo gem install benhoskings-hammock --source http://gems.github.com
+
+class ApplicationController
+  include Hammock
+  ...
+
+
+== LICENSE:
+
+Hammock is licensed under the BSD license, which can be found in full in the LICENSE file.
+
+
+== SYNOPSIS
+
+At the moment, you can do this with Hammock:
+
+  class ApplicationController < ActionController::Base
+    include Hammock
+  end
+
+  class BeersController < ApplicationController
+  end
+
+  class Person < ActiveRecord::Base
+  end
+
+  class Beer < ActiveRecord::Base
+    belongs_to :creator, :class_name => 'Person'
+    belongs_to :recipient, :class_name => 'Person'
+
+    def read_scope_for account
+      proc {|beer| beer.creator_id == account.id || beer.recipient_id == account.id }
+    end
+    export_scope :read
+    export_scope :read, :as => :index
+    
+    def write_scope_for account
+      proc {|beer| record.creator_id == account.id }
+    end
+    export_scope :write
+  end
+
+  <% @beers.each do |beer| %>
+    From <%= beer.creator.name %> to <%= beer.recipient.name %>, <%= beer.reason %>, rated <%= beer.rating %>
+    <%= hamlink_to :edit, beer %>
+  <% end %>
+
+The scope methods above require just one thing -- a context-free proc object that takes an ActiveRecord record as its argument, and returns true iff that record is within the scope for the specified account. Hammock uses the method (e.g. Beer.read_scope_for) to define resource and record scopes for the model:
+
+  Beer.readable_by(account): the set of Beer records whose existence can be known by account
+  Beer#readable_by?(account): returns true if the existence of this Beer instance can be known by account
+
+You define the logic for read, index and write scopes in Beer.[read,index,write]_scope_for, and the rest just works.
+
+These scope definitions are exploited extensively, to provide index selection, scoping for record selection, and post-selection object checks.
+
+- They provide the conditions that should be applied to retrieve the index of each resource. The scope is used transperently by Hammock on /beers -> BeersController#index, and is available for use through Beer.indexable_by(account).
+
+- They provide a scope within which records are searched for on single-record actions. For example, given the request /beers/5 -> BeersController#show{:id => 5}, Rails would generate the following SQL:
+
+  SELECT * FROM "beers" WHERE (beers."id" = 5) LIMIT 1
+
+Hammock uses the conditions specified in Beer.read_scope_for to generate (assuming an account_id of 3):
+
+  SELECT * FROM "beers" WHERE ((beers.creator_id = 3 OR beers.recipient_id = 3) AND beers."id" = 5) LIMIT 1
+
+Hammock uses Beer.read_scope_for on #show, and write_scope_for on #edit, #update and #destroy. These scopes can be accessed as above through Beer.readable_by(account) and Beer.writeable_by(account). This eliminates authorization checks from the action, because if the ID of a Beer is provided that the user doesn't have access to it will fall outside the scope and will not be found in the DB at all.
+
+- They are used to discover credentials for already-queried ActiveRecord objects, without touching the database again. Just as Beer.readable_by(account) returns the set of Beer records whose existence can be known by account, @beer.readable_by?(account) returns true iff @beer's existence can be known by account. This is employed by hamlink_to.
+
+These three uses of the scope, plus another as-yet unimplemented bit, provide the entire security model of the application.
+
+== THE MASTER PLAN
+
+Lots of functionality is planned that will take this much further.
+
+
+

data/Rakefile

@@ -0,0 +1,29 @@
+%w[rubygems rake rake/clean fileutils newgem rubigen].each { |f| require f }
+%w[action_controller].each { |f| require f }
+require File.dirname(__FILE__) + '/lib/hammock'
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.new('hammock', Hammock::VERSION) do |p|
+  p.developer('Ben Hoskings', 'ben@hoskings.net')
+  p.changes              = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  p.rubyforge_name       = p.name
+  p.extra_deps         = [
+    ['rails','~> 2.2'],
+    ['benhoskings-ambitious-activerecord','~> 0.1.3.5'],
+  ]
+  p.extra_dev_deps = [
+    ['newgem', ">= #{::Newgem::VERSION}"]
+  ]
+  
+  p.clean_globs |= %w[**/.DS_Store tmp *.log]
+  path = (p.rubyforge_name == p.name) ? p.rubyforge_name : "\#{p.rubyforge_name}/\#{p.name}"
+  p.remote_rdoc_dir = File.join(path.gsub(/^#{p.rubyforge_name}\/?/,''), 'rdoc')
+  p.rsync_args = '-av --delete --ignore-errors'
+end
+
+require 'newgem/tasks' # load /tasks/*.rake
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+# TODO - want other tests/tasks run by default? Add them to the list
+# task :default => [:spec, :features]

data/hammock.gemspec

@@ -0,0 +1,43 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{hammock}
+  s.version = "0.2.11.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Ben Hoskings"]
+  s.date = %q{2009-03-24}
+  s.description = %q{Hammock is a Rails plugin that eliminates redundant code in a very RESTful manner. It does this in lots in lots of different places, but in one manner: it encourages specification in place of implementation.   Hammock enforces RESTful resource access by abstracting actions away from the controller in favour of a clean, model-like callback system.  Hammock tackles the hard and soft sides of security at once with a scoping security system on your models. Specify who can verb what resources under what conditions once, and everything else - the actual security, link generation, index filtering - just happens.  Hammock inspects your routes and resources to generate a routing tree for each resource. Parent resources in a nested route are handled transparently at every point - record retrieval, creation, and linking.  It makes more sense when you see how it works though, so check out the screencast!}
+  s.email = ["ben@hoskings.net"]
+  s.extra_rdoc_files = ["History.txt", "Manifest.txt", "README.rdoc", "misc/scaffold.txt"]
+  s.files = ["History.txt", "LICENSE", "Manifest.txt", "README.rdoc", "Rakefile", "hammock.gemspec", "lib/hammock.rb", "lib/hammock/ajaxinate.rb", "lib/hammock/callback.rb", "lib/hammock/callbacks.rb", "lib/hammock/canned_scopes.rb", "lib/hammock/constants.rb", "lib/hammock/controller_attributes.rb", "lib/hammock/export_scope.rb", "lib/hammock/hamlink_to.rb", "lib/hammock/javascript_buffer.rb", "lib/hammock/logging.rb", "lib/hammock/model_attributes.rb", "lib/hammock/model_logging.rb", "lib/hammock/monkey_patches/action_pack.rb", "lib/hammock/monkey_patches/active_record.rb", "lib/hammock/monkey_patches/array.rb", "lib/hammock/monkey_patches/hash.rb", "lib/hammock/monkey_patches/logger.rb", "lib/hammock/monkey_patches/module.rb", "lib/hammock/monkey_patches/numeric.rb", "lib/hammock/monkey_patches/object.rb", "lib/hammock/monkey_patches/route_set.rb", "lib/hammock/monkey_patches/string.rb", "lib/hammock/overrides.rb", "lib/hammock/resource_mapping_hooks.rb", "lib/hammock/resource_retrieval.rb", "lib/hammock/restful_actions.rb", "lib/hammock/restful_rendering.rb", "lib/hammock/restful_support.rb", "lib/hammock/route_drawing_hooks.rb", "lib/hammock/route_for.rb", "lib/hammock/route_node.rb", "lib/hammock/route_step.rb", "lib/hammock/scope.rb", "lib/hammock/suggest.rb", "lib/hammock/utils.rb", "misc/scaffold.txt", "misc/template.rb", "tasks/hammock_tasks.rake", "test/hammock_test.rb"]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/benhoskings/hammock}
+  s.rdoc_options = ["--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{hammock}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{Hammock is a Rails plugin that eliminates redundant code in a very RESTful manner}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rails>, ["~> 2.2"])
+      s.add_runtime_dependency(%q<benhoskings-ambitious-activerecord>, ["~> 0.1.3.5"])
+      s.add_development_dependency(%q<newgem>, [">= 1.3.0"])
+      s.add_development_dependency(%q<hoe>, [">= 1.8.0"])
+    else
+      s.add_dependency(%q<rails>, ["~> 2.2"])
+      s.add_dependency(%q<benhoskings-ambitious-activerecord>, ["~> 0.1.3.5"])
+      s.add_dependency(%q<newgem>, [">= 1.3.0"])
+      s.add_dependency(%q<hoe>, [">= 1.8.0"])
+    end
+  else
+    s.add_dependency(%q<rails>, ["~> 2.2"])
+    s.add_dependency(%q<benhoskings-ambitious-activerecord>, ["~> 0.1.3.5"])
+    s.add_dependency(%q<newgem>, [">= 1.3.0"])
+    s.add_dependency(%q<hoe>, [">= 1.8.0"])
+  end
+end

data/lib/hammock/ajaxinate.rb

@@ -0,0 +1,154 @@
+module Hammock
+  module Ajaxinate
+    MixInto = ActionView::Base
+    
+    def self.included base # :nodoc:
+      base.send :include, InstanceMethods
+      base.send :extend, ClassMethods
+    end
+
+    module ClassMethods
+    end
+
+    module InstanceMethods
+
+      def ajax_button verb, record, opts = {}
+        ajax_link verb, record, opts.merge(:class => [opts[:class], 'button'].squash.join(' '))
+      end
+
+      def ajax_link verb, record, opts = {}
+        if can_verb_entity?(verb, record)
+          route = ajaxinate verb, record, opts
+
+          content_tag :a,
+            opts[:text] || route.verb.to_s.capitalize,
+            :class => [opts[:class], link_class_for(route.verb, record)].squash.join(' '),
+            :href => route.path,
+            :onclick => 'return false;',
+            :style => opts[:style]
+        end
+      end
+
+      def ajaxinate verb, record, opts = {}
+        record_attributes = {record.base_model => record.unsaved_attributes}
+        link_params = {record.base_model => (opts.delete(:record) || {}) }.merge(opts[:params] || {})
+        route = route_for verb, record
+        attribute = link_params[:attribute]
+        link_class = link_class_for route.verb, record, attribute
+
+        link_params[:_method] = route.http_method
+        link_params[:format] = opts[:format].to_s
+
+        form_elements_hash = if route.get?
+          '{ }'
+        elsif attribute.blank?
+          "jQuery('form').serializeHash()"
+        else
+          "{ '#{record.base_model}[#{attribute}]': $('.#{link_class}').val() }"
+        end
+
+        response_action = case link_params[:format].to_s
+        when 'js'
+          "eval(response)"
+        else
+          "jQuery('.#{opts[:target] || link_class + '_target'}').before(response).remove()"
+        end
+
+        # TODO check the response code in the callback, and replace :after with :success and :failure.
+        js = %Q{
+          jQuery('.#{link_class}').#{opts[:on] || 'click'}(function() {
+            /*if (#{attribute.blank? ? 'false' : 'true'} && (jQuery('.#{link_class}_target .original_value').html() == jQuery('.#{link_class}_target .modify input').val())) {
+              eval("#{clean_snippet opts[:skipped]}");
+            } else*/ if (false == eval("#{clean_snippet opts[:before]}")) {
+              // before callback failed
+            } else { // fire the request
+              jQuery.#{route.fake_http_method}(
+                '#{route.path}',
+                jQuery.extend(
+                  #{record_attributes.to_flattened_json},
+                  #{form_elements_hash},
+                  #{link_params.to_flattened_json},
+                  #{forgery_key_json(route.http_method)}
+                ),
+                function(response) {
+                  #{response_action};
+                  eval("#{clean_snippet opts[:after]}");
+                }
+              );
+            }
+          });
+        }
+
+        append_javascript js
+        route
+      end
+      
+      def status_callback
+        %Q{
+          if ('success' == textStatus) {
+            jQuery('.success', jQuery('#' + jQuery(data).attr("id"))).show().fadeOut(4000);
+          } else {
+            jQuery('.statuses .failure', obj).hide();
+            jQuery('.statuses .failure', obj).show().parents('obj').BlindUp();
+          }
+        }
+      end
+
+      def jquery_xhr verb, record, opts = {}
+        route = route_for verb, record
+        params = if opts[:params].is_a?(String)
+          opts[:params].chomp(',').start_with('{').end_with('}')
+        else
+          (opts[:params] || {}).merge(record.base_model => (opts[:record] || {})).to_flattened_json
+        end
+
+        response_action = case opts[:format].to_s
+        when 'js'
+          "eval(data);"
+        else
+          "obj.replaceWith(data);"
+        end
+
+        %Q{
+          if (typeof(obj) != 'undefined') {
+            jQuery('.spinner', obj).show();
+          }
+
+          jQuery.#{route.fake_http_method}(
+            '#{route.path}',
+            jQuery.extend(
+              #{params},
+              {format: '#{opts[:format] || 'html'}', _method: '#{route.http_method}'},
+              #{forgery_key_json(route.http_method)}
+            ),
+            function(data, textStatus) {
+              #{response_action}
+              #{status_callback}
+              #{(opts[:callback] || '').end_with(';')}
+            }
+          );
+        }
+      end
+
+      private
+
+      def link_class_for verb, record, attribute = nil
+        [verb, record.description, attribute].compact.join('_')
+      end
+
+      def clean_snippet snippet
+        report "Double quote detected in snippet '#{snippet}'" if snippet['"'] unless snippet.nil?
+        (snippet || '').gsub("\n", '\n').end_with(';')
+      end
+
+      def forgery_key_json request_method = nil
+        if !protect_against_forgery? || (:get == (request_method || request.method))
+          '{ }'
+        else
+          "{ '#{request_forgery_protection_token}': encodeURIComponent('#{escape_javascript(form_authenticity_token)}') }"
+        end
+      end
+
+    end
+  end
+end

data/lib/hammock/callback.rb

@@ -0,0 +1,16 @@
+module Hammock
+
+  class Callback < ActiveSupport::Callbacks::Callback
+    private
+
+    def evaluate_method method, *args, &block
+      if method.is_a? Proc
+        # puts "was a Hammock::Callback proc within #{args.first.class}."
+        method.bind(args.shift).call(*args, &block)
+      else
+        super
+      end
+    end
+  end
+
+end

data/lib/hammock/callbacks.rb

@@ -0,0 +1,94 @@
+module Hammock
+  module Callbacks
+    LoadFirst = true
+
+    def self.included base # :nodoc:
+      base.send :include, InstanceMethods
+      base.send :extend, ClassMethods
+
+      base.class_eval {
+        include ActiveSupport::Callbacks
+
+        define_hammock_callbacks *%w[
+          before_find      during_find     after_failed_find
+
+          before_index     before_show
+          before_modify    before_new      before_edit
+
+          before_save      after_save      after_failed_save
+          before_create    after_create    after_failed_create
+          before_update    after_update    after_failed_update
+          before_destroy   after_destroy
+          before_undestroy after_undestroy
+
+          before_suggest   after_suggest
+        ]
+      }
+    end
+
+    module ClassMethods
+
+      def define_hammock_callbacks *callbacks
+        callbacks.each do |callback|
+          class_eval <<-"end_eval"
+            def self.#{callback}(*methods, &block)
+              callbacks = if !block_given? || methods.length > 1
+                CallbackChain.build(:#{callback}, *methods, &block)
+              else # hammock-style callback
+                if methods.empty?
+                  log "<-- you should give this callback a description", :skip => 1
+                elsif !methods.first.is_a?(String)
+                  raise ArgumentError, "Inline callback definitions require a description as their sole argument."
+                else
+                  # logger.info "defining \#{methods.first} on \#{name} with method \#{block.inspect}."
+                  [Hammock::Callback.new(:#{callback}, block, :identifier => methods.first)]
+                end || []
+              end
+              # log callbacks
+              (@#{callback}_callbacks ||= CallbackChain.new).concat callbacks
+            end
+
+            def self.#{callback}_callback_chain
+              @#{callback}_callbacks ||= CallbackChain.new
+
+              if superclass.respond_to?(:#{callback}_callback_chain)
+                CallbackChain.new(superclass.#{callback}_callback_chain + @#{callback}_callbacks)
+              else
+                @#{callback}_callbacks
+              end
+            end
+          end_eval
+        end
+      end
+
+    end
+
+    module InstanceMethods
+      private
+
+      CallbackFail = false
+
+      def callback kind, *args
+        callback_chain_for(kind).all? {|cb|
+          # dlog "Calling #{kind} callback #{cb.method}"
+          result = cb.call(self, *args) != CallbackFail
+          log "#{self.class}.#{cb.kind} callback '#{cb.method}' failed." unless result
+          result
+        }
+      end
+
+      def required_callback kind, *args
+        callback(kind, *args) if has_callbacks_for?(kind)
+      end
+
+      def has_callbacks_for? kind
+        !callback_chain_for(kind).empty?
+      end
+
+      def callback_chain_for kind
+        self.class.send "#{kind}_callback_chain"
+      end
+
+    end
+  end
+end