benhoskings-hammock 0.3.3 → 0.3.5

data/History.txt

@@ -1,22 +1,42 @@
+== 0.3.5 2009-06-03
+Converted README back to rdoc, for rubyforge rake tasks.
+
+
+== 0.3.4 2009-06-03
+Converted lambda and proc to L.
+Include exception message on error in Hammock.load_models.
+Fixed lambda -> L alias, by adding initialize_for_load on hammock init.
+Added Hammock::Mutex, containing AR::Base#mutex, to run a closure within a column-based mutex.
+Added Hammock::Aliases, initially with lambda aliased as L.
+Removed model-loading logging.
+README formatting updates, converted to Markdown.
+Updated README to match current code state.
+Updated the bit about the screencast in the README.
+
+
 == 0.3.3 2009-05-28
 On suggest, :limit => 0 means no limit now, as it should.
 
 
 == 0.3.2 2009-05-28
-Accidentally pushed 0.3.1 in an unknown state - bumped to 0.3.2 to be safe.
-
-
-== 0.3.1 2009-05-28
 Added Hammock.load_models, along with call in draw_with_hammock_route_map_init.
 Refactored Hammock.included out into load_hammock_components and related methods, and made them all private.
 Only extract record_attributes from records - not resources too.
 Fixed http status entry in log_hit.
 
 
+== 0.3.1 2009-05-26
+Check for a specific scope for the current action before checking for a default-named scope.
+Commented ambition query logging.
+Moved index rendering to restful_rendering.
+Wrap pending -> success notification within obj null test.
+
+
 == 0.3.0 2009-05-25
 Updated ajax_link, ajaxinate and related methods to accept explicit args instead of a splatted list - this makes it a lot easier to handle different amounts of entities.
 Only do obj replacement in jquery_xhr callback if it's set.
 
+
 == 0.2.25 2009-05-25
 Added String#clean_email[!].
 Moved set_new_or_deleted_before_save callback from controller to model.

data/README.rdoc

@@ -14,22 +14,34 @@ Hammock tackles the hard and soft sides of security at once with a scoping secur
 
 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!
+It makes more sense when you see how it works though. There's a screencast coming soon.
 
 
 == REQUIREMENTS:
 
-benhoskings-ambition
-benhoskings-ambitious-activerecord
+    benhoskings-ambition
+    benhoskings-ambitious-activerecord
+    
+These gems will install automatically as long as you've added the GitHub gem source:
+
+    gem sources -a http://gems.github.com
 
 
 == INSTALL:
 
-sudo gem install benhoskings-hammock --source http://gems.github.com
+    sudo gem install hammock
+
+in config/environment.rb:
+
+    Rails::Initializer.run do |config|
+      config.gem 'hammock'
+      ...
 
-class ApplicationController
-  include Hammock
-  ...
+in app/controllers/application_controller.rb:
+
+    class ApplicationController
+      include Hammock::RestfulActions
+      ...
 
 
 == LICENSE:
@@ -41,59 +53,67 @@ Hammock is licensed under the BSD license, which can be found in full in the LIC
 
 At the moment, you can do this with Hammock:
 
-  class ApplicationController < ActionController::Base
-    include Hammock
-  end
+    class ApplicationController < ActionController::Base
+      include Hammock::RestfulActions
+    end
 
-  class BeersController < ApplicationController
-  end
+    class BeersController < ApplicationController
+    end
 
-  class Person < ActiveRecord::Base
-  end
+    class Person < ActiveRecord::Base
+    end
 
-  class Beer < ActiveRecord::Base
-    belongs_to :creator, :class_name => 'Person'
-    belongs_to :recipient, :class_name => 'Person'
+    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 }
+      def self.read_scope_for account
+        L{|beer| beer.creator_id == account.id || beer.recipient_id == account.id }
+      end
+      export_scope :read
+
+      # TODO - Duplication, yuck. There's a proper DSL in the pipes.
+      def self.index_scope_for account
+        L{|beer| beer.creator_id == account.id || beer.recipient_id == account.id }
+      end
+      export_scope :index
+
+      creator_scope_for :write
     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 %>
+    <% @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:
+The scope methods above require just one thing -- a context-free lambda 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
+    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 the conditions that should be applied to retrieve the index of each resource. 
 
-- 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:
+The scope is used transperently by Hammock on /beers -> BeersController#index, and is available for use through Beer.indexable_by(account).
 
-  SELECT * FROM "beers" WHERE (beers."id" = 5) LIMIT 1
+- 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
+    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.
+- 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.
 

data/hammock.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{hammock}
-  s.version = "0.3.3"
+  s.version = "0.3.5"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Ben Hoskings"]
-  s.date = %q{2009-05-28}
+  s.date = %q{2009-06-03}
   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.
 
 
@@ -16,7 +16,7 @@ Hammock tackles the hard and soft sides of security at once with a scoping secur
 
 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!}
+It makes more sense when you see how it works though. There's a screencast coming soon.}
   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"]

data/lib/hammock.rb

@@ -4,10 +4,11 @@ require 'ambition'
 require 'ambition/adapters/active_record'
 
 module Hammock
-  VERSION = '0.3.3'
+  VERSION = '0.3.5'
 
   def self.included base # :nodoc:
     puts "Loading Hammock from #{loaded_from_gem? ? 'gem' : 'plugin'}"
+    initialize_for_load
     load_hammock_components base
   end
 
@@ -23,9 +24,8 @@ module Hammock
       klass = File.basename(model_file, '.rb').classify
       begin
         Object.const_get klass
-        puts "Loaded #{klass} from #{model_file}."
       rescue
-        puts "Couldn't load #{klass} from #{model_file}."
+        puts "Couldn't load #{klass} from #{model_file}: #{$!}."
       end
     }
   end
@@ -33,6 +33,10 @@ module Hammock
 
   private
 
+  def self.initialize_for_load
+    Hammock::Aliases.alias_lambda
+  end
+
   def self.load_hammock_components base
     require_hammock_components
     mixin_hammock_components base

data/lib/hammock/ajaxinate.rb

@@ -79,8 +79,10 @@ module Hammock
                 ),
                 function(response, textStatus) {
                   #{response_action}
-                  if (obj) obj.children('.spinner').hide();
-                  #{"if ('success' == textStatus) obj.children('.success').show().fadeOut(4000);" if opts[:spinner] != :pending}
+                  if (obj) {
+                    obj.children('.spinner').hide();
+                    #{"if ('success' == textStatus) obj.children('.success').show().fadeOut(4000);" if opts[:spinner] != :pending}
+                  }
                   eval("#{clean_snippet opts[:after]}");
                 }
               );

data/lib/hammock/canned_scopes.rb

@@ -89,24 +89,24 @@ module Hammock
 
       def public_scope account = nil
         if sqlite?
-          lambda {|record| 1 }
+          L{|record| 1 }
         else
-          lambda {|record| true }
+          L{|record| true }
         end
       end
 
       def authed_scope account
         has_account = !account.nil?
-        lambda {|record| has_account }
+        L{|record| has_account }
       end
 
       def creator_scope account
-        lambda {|record| record.creator_id == account.id }
+        L{|record| record.creator_id == account.id }
       end
       
       def partitioned_scope account
         if account.is_a? self
-          lambda {|record| record.id == account.id }
+          L{|record| record.id == account.id }
         else
           empty_scope
         end
@@ -114,9 +114,9 @@ module Hammock
 
       def empty_scope account = nil
         if sqlite?
-          lambda {|record| 0 } # TODO check what this should be
+          L{|record| 0 } # TODO check what this should be
         else
-          lambda {|record| false }
+          L{|record| false }
         end
       end
 

data/lib/hammock/monkey_patches/active_record.rb

@@ -35,7 +35,7 @@ module Hammock
 
       def sorter
         # TODO updated_at DESC
-        proc {|record| record.id }
+        L{|record| record.id }
       end
 
       def resource

data/lib/hammock/restful_actions.rb

@@ -6,14 +6,7 @@ module Hammock
       #
       # Lists the current resource's records that are visible within the current index scope, defined by +index_scope+ and +index_scope_for+ on the current model.
       def index
-        if tasks_for_index
-          respond_to do |format|
-            format.html
-            format.xml { render :xml => @records.kick }
-            format.json { render :json => @records.kick }
-            format.yaml { render :text => @records.kick.to_yaml }
-          end
-        end
+        render_for_index if tasks_for_index
       end
 
       # The +new+ action. (GET, safe, idempotent)

data/lib/hammock/restful_rendering.rb

@@ -28,6 +28,15 @@ module Hammock
         end
       end
 
+      def render_for_index
+        respond_to do |format|
+          format.html
+          format.xml { render :xml => @records.kick }
+          format.json { render :json => @records.kick }
+          format.yaml { render :text => @records.kick.to_yaml }
+        end
+      end
+
       def render_for_safe_actions result = true, opts = {}
         if request.xhr?
           if params[:attribute]

data/lib/hammock/restful_support.rb

@@ -77,7 +77,7 @@ module Hammock
         elsif record_or_records.is_a? ActiveRecord::Base
           instance_variable_set "@#{mdl_name}", (@record = record_or_records)
         elsif record_or_records.is_a? Ambition::Context
-          log "Unkicked query: #{record_or_records.to_hash.inspect}"
+          # log "Unkicked query: #{record_or_records.to_hash.inspect}"
           instance_variable_set "@#{mdl_name.pluralize}", (@records = record_or_records)
         elsif record_or_records.is_a? Array
           instance_variable_set "@#{mdl_name.pluralize}", (@records = record_or_records)

data/lib/hammock/scope.rb

@@ -116,10 +116,10 @@ module Hammock
       end
 
       def account_verb_scope?
-        mdl.has_account_scope? scope_name_for_action
+        mdl.has_account_scope?(action_name) || mdl.has_account_scope?(scope_name_for_action)
       end
       def public_verb_scope?
-        mdl.has_public_scope? scope_name_for_action
+        mdl.has_public_scope?(action_name) || mdl.has_public_scope?(scope_name_for_action)
       end
 
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: benhoskings-hammock
 version: !ruby/object:Gem::Version 
-  version: 0.3.3
+  version: 0.3.5
 platform: ruby
 authors: 
 - Ben Hoskings
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-28 00:00:00 -07:00
+date: 2009-06-03 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -52,7 +52,7 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 1.8.0
     version: 
-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!"
+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. There's a screencast coming soon."
 email: 
 - ben@hoskings.net
 executables: []