joshuaclayton-sentinel 0.1.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Joshua Clayton
+
+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.textile

@@ -0,0 +1,224 @@
+h1. Sentinel
+
+Stupid-simple authorization for Rails
+
+h2. Let's Start with an Example
+
+Sentinels are objects that track permissions.  They're flexible, handy, and very easy to use.
+
+For example, here's a ForumSentinel:
+
+<code><pre>
+class ForumSentinel < Sentinel::Sentinel
+  def creatable?
+    current_user_admin?
+  end
+
+  def reorderable?
+    current_user_admin?
+  end
+
+  def viewable?
+    self.forum.public? || (current_user? && self.forum.members.include?(self.current_user)) || current_user_admin?
+  end
+
+  def editable?
+    (current_user? && self.forum.owner == self.current_user) || current_user_admin?
+  end
+
+  def destroyable?
+    editable?
+  end
+
+  private
+
+  def current_user?
+    !self.current_user.nil?
+  end
+
+  def current_user_admin?
+    current_user? && self.current_user.admin?
+  end
+end
+</pre></code>
+
+So, what's this guy do?  He personally tracks ability to essentially CRUD a forum, based on the current user.
+
+How do we instantiate something like this?
+
+  forum_sentinel = ForumSentinel.new :current_user => User.first, :forum => Forum.first
+  
+From there, you can call methods like any PORO.
+
+But, there's more.
+
+You may be asking, "What about when I'm looping through a recordset and want to determine permissions on the fly?"  That's a legitimate question, really.  I've got an easy answer for you.  Imagine your view looks something like this:
+
+<code><pre>
+<% @forums.each do |forum| %>
+  <% sentinel = ForumSentinel.new(:current_user => current_user, :forum => forum) %>
+  <% if sentinel.viewable? %>
+    <div id="<%= dom_id(forum) %>">
+      <h3><%= link_to h(forum.name), forum %></h3>
+      <%= textilize(forum.description) %>
+    </div>
+  <% end %>
+<% end %>
+</pre></code>
+
+You get the idea.  This is still pretty nasty though, since we're instantiating a new sentinel for each item in the recordset.  Let's handle this in the controller.
+
+<code><pre>
+class ForumsController < ApplicationController
+  controls_access_with do
+    ForumSentinel.new :current_user => current_user, :forum => @forum
+  end
+  
+  # ...etc
+end
+</pre></code>
+
+Here, we setup the sentinel in the controller and make a @sentinel@ view helper to access the instantiated object.  So, if `@forum` is set up in the show action, we'll have access to it.  The index action, not so much.  Not to fear.
+
+<code><pre>
+<% @forums.each do |forum| %>
+  <% if sentinel[:forum => forum].viewable? %>
+    <div id="<%= dom_id(forum) %>">
+      <h3><%= link_to h(forum.name), forum %></h3>
+      <%= textilize(forum.description) %>
+    </div>
+  <% end %>
+<% end %>
+</pre></code>
+
+Essentially the same view as before, except we're not instantiating on every line and it keeps the view nice and clean.  Notice we call `[]`, passing in a hash?  Those are _temporary_ (as in, that call only) overrides.  We assign forum to the current forum we're looping through and have the sentinel return permissions scoped to itself with whatever overrides.
+
+So, handling permissions in the views are pretty easy now; hell, testing should be pretty simple too, since stubbing out simple methods like `viewable?`, `editable?`, etc will be cake.
+
+"What about the controllers?" you may ask.  Don't worry about the controllers; this is just as easy.
+
+I introduce to you... @grants_access_to@.
+
+<code><pre>
+class ForumsController < ApplicationController
+  controls_access_with do
+    ForumSentinel.new :current_user => current_user, :forum => @forum
+  end
+  
+  grants_access_to :reorderable?, :only => [:reorder]
+  grants_access_to :creatable?, :only => [:new, :create]
+  grants_access_to :viewable?, :only => [:show]
+  grants_access_to :destroyable?, :only => [:destroy]
+end
+</pre></code>
+
+@grants_access_to@ is essentially a @before_filter@ on crack.  It uses the sentinel we've set up and calls methods on it.  So, if the sentinel returns true when :reorderable? is called, it won't deny the request.  Other filters, however, may.
+
+You need not call methods on the sentinel if you don't want to.  Let's say you want to check if a user is logged in and an admin (contrived example, I know).
+
+<code><pre>
+class ForumsController < ApplicationController
+  controls_access_with do
+    ForumSentinel.new :current_user => current_user, :forum => @forum
+  end
+  
+  grants_access_to :only => [:search] do
+    current_user && current_user.admin? && sentinel.creatable
+  end
+  
+  grants_access_to :only => [:weird] do |s|
+    s.creatable? && s.forum.private?
+  end
+end
+</pre></code>
+
+The first @grants_access_to@ evaluates in the scope of the controller.  If the block passed has an arity of 1 (one required block-level variable), it evaluates in the context of the sentinel.
+
+When granting access, you may want to handle different checks differently.  You can essentially how the controller handles how things are denied.  For example, you may want to include a couple basics within @ApplicationController@.
+
+<code><pre>
+class ApplicationController < ActionController::Base
+  on_denied_with :forbid_access do
+    respond_to do |wants|
+      wants.html { render :text => "You're forbidden to do this", :status => :forbidden }
+      wants.any { head :forbidden }
+    end
+  end
+  
+  on_denied_with :redirect_home do
+    redirect_to root_path
+  end
+  
+  # this would override the default denial handler
+  on_denied_with do
+    respond_to do |wants|
+      wants.html { render :text => "Unauthorized request", :status => :unauthorized }
+      wants.any { head :unauthorized }
+    end
+  end
+end
+</pre></code>
+  
+If these are set up, you can then have your actions deny with whatever you want, like so: 
+
+<code><pre>
+class ForumsController < ApplicationController
+  controls_access_with do
+    ForumSentinel.new :current_user => current_user, :forum => @forum
+  end
+  
+  grants_access_to :reorderable?, :only => [:reorder], :denies_with => :redirect_home
+  grants_access_to :creatable?, :only => [:new, :create]
+  grants_access_to :viewable?, :only => [:show], :denies_with => :unauthorized
+  grants_access_to :destroyable?, :only => [:destroy], :denies_with => :forbidden
+end
+</pre></code>
+
+Testing the sentinels themselves are fairly easy to do; I won't go into detail with that.
+
+Testing the controllers, however, can be a bit tricky.  Luckily, there are a handful of Shoulda macros (easily grok'able, in case you want to port to RSpec or the like).
+
+Here's a short example of what you may want to test:
+
+<code><pre>
+class SentinelControllerTest < ActionController::TestCase
+  include ActionView::Helpers::UrlHelper
+  include ActionView::Helpers::TagHelper
+  
+  def setup
+    @controller = ForumsController.new
+  end
+  
+  sentinel_context do
+    should_not_guard "get :index"
+  end
+  
+  sentinel_context({:viewable? => true}) do
+    should_grant_access_to "get :show"
+  end
+  
+  sentinel_context({:creatable? => false}) do
+    should_deny_access_to "get :new", :with => :redirect_to_index
+    should_deny_access_to "post :create, :forum => {:name => 'My New Forum'}", :with => :redirect_to_index
+  end
+  
+  sentinel_context({:creatable? => true}) do
+    should_grant_access_to "get :new"
+    should_grant_access_to "post :create, :forum => {:name => 'My New Forum'}"
+  end
+end
+</pre></code>
+
+@sentinel_context@ allows you to stub out responses for whatever methods you want on the sentinel.  Assign attributes (`:current_user`, `:forum`, etc) or stub the permission methods themselves (that's what I would recommend, since your sentinel unit tests should check what the permissions return).
+
+@should_not_guard@ ensures that @grants_access_to@ never gets called on that action.  @should_grant_access_to@ and @should_deny_access_to@ are fairly straightforward.  If @grants_access_to@ denies with a certain handler, you'll want to pass that handler name in (otherwise, you'll have failing tests).
+
+h2. Why?
+
+I'm all for putting permissions stuff like this in "presenters":http://htmltimes.com/presenters-in-Ruby-on-Rails-applications.php.  However, my presenters have been getting fat, a bit harder to test, and in my mind, that's just not cool.  I also hate trying to test controllers with a ton of contrived examples that are a pain in the ass to set up.  This plugin provides the best of all worlds; encapsulated, easy-to-test permissions (controller, unit, AND view) that are simple to set up, extensible with different handlers, and easy to read.
+
+h2. Questions or Comments?
+
+If you like this plugin but have ideas, tweaks, fixes, or issues, shoot me a message on Github or fork/send a pull request.  This is alpha software, so I'm pretty open to change.
+
+Copyright (c) 2009 Joshua Clayton, released under the MIT license

data/Rakefile

@@ -0,0 +1,22 @@
+require 'rubygems'
+require 'rake'
+require 'echoe'
+require 'rake/rdoctask'
+
+Echoe.new("sentinel", "0.1.0") do |p|
+  p.description = "Simple authorization for Rails"
+  p.url = "http://github.com/joshuaclayton/sentinel"
+  p.author = "Joshua Clayton"
+  p.email = "joshua.clayton@gmail.com"
+  p.ignore_pattern = ["tmp/*"]
+  p.development_dependencies = ["actionpack >= 2.1.0"]
+end
+
+desc 'Generate documentation for the sentinel plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Sentinel'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/sentinel/controller.rb

@@ -0,0 +1,68 @@
+module Sentinel
+  module Controller
+    
+    def self.included(base)
+      base.send :include, InstanceMethods
+      base.extend ClassMethods
+      
+      base.class_eval do
+        helper_method :sentinel
+      end
+      
+      base.class_inheritable_accessor :sentinel, :access_denied, :access_granted
+      
+      base.on_denied_with do
+        respond_to do |format|
+          format.html { render :text => "You do not have the proper privileges to access this page.", :status => :unauthorized }
+          format.any  { head :unauthorized }
+        end
+      end
+      
+      base.with_access do
+        true
+      end
+    end
+    
+    module InstanceMethods
+      def sentinel
+        self.instance_eval(&self.class.sentinel)
+      end
+    end
+    
+    module ClassMethods
+      def controls_access_with(&block)
+        self.sentinel = block
+      end
+      
+      def on_denied_with(name = :default, &block)
+        self.access_denied ||= {}
+        self.access_denied[name] = block
+      end
+      
+      def with_access(&block)
+        self.access_granted = block
+      end
+      
+      def grants_access_to(*args, &block)
+        options = args.extract_options!
+        block = args.shift if args.first.respond_to?(:call)
+        sentinel_method = args.first
+        denied_handler = options.delete(:denies_with) || :default
+        
+        before_filter(options) do |controller|
+          if block
+            if (block.arity == 1 ? controller.sentinel : controller).instance_eval(&block)
+              controller.instance_eval(&controller.class.access_granted)
+            else
+              controller.instance_eval(&controller.class.access_denied[denied_handler])
+            end
+          elsif sentinel_method && controller.sentinel && controller.sentinel.send(sentinel_method)
+            controller.instance_eval(&controller.class.access_granted)
+          else
+            controller.instance_eval(&controller.class.access_denied[denied_handler])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sentinel/sentinel.rb

@@ -0,0 +1,29 @@
+module Sentinel
+  class Sentinel
+    def initialize(*args)
+      attributes = args.extract_options!
+      attributes.keys.each do |key|
+        create_accessor_for_attribute(key)
+        self.send("#{key}=", attributes[key]) if self.respond_to?("#{key}=")
+      end
+    end
+    
+    def [](temporary_overrides)
+      temporary_overrides.keys.each do |key|
+        create_accessor_for_attribute(key)
+      end
+      
+      returning self.clone do |duplicate|
+        temporary_overrides.keys.each do |key|
+          duplicate.send("#{key}=", temporary_overrides[key]) if self.respond_to?("#{key}=")
+        end
+      end
+    end
+    
+    private
+    
+    def create_accessor_for_attribute(attribute)
+      self.class_eval { attr_accessor attribute } unless self.respond_to?(attribute) || self.respond_to?("#{attribute}=")
+    end
+  end
+end

data/lib/sentinel.rb

@@ -0,0 +1,4 @@
+require File.join(File.dirname(__FILE__), "sentinel", "controller")
+require File.join(File.dirname(__FILE__), "sentinel", "sentinel")
+
+ActionController::Base.send :include, Sentinel::Controller

data/rails/init.rb

@@ -0,0 +1 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), "..", "lib", "sentinel")

data/sentinel.gemspec

@@ -0,0 +1,35 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{sentinel}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Joshua Clayton"]
+  s.date = %q{2009-04-06}
+  s.description = %q{Simple authorization for Rails}
+  s.email = %q{joshua.clayton@gmail.com}
+  s.extra_rdoc_files = ["lib/sentinel/controller.rb", "lib/sentinel/sentinel.rb", "lib/sentinel.rb", "README.textile"]
+  s.files = ["lib/sentinel/controller.rb", "lib/sentinel/sentinel.rb", "lib/sentinel.rb", "Manifest", "MIT-LICENSE", "rails/init.rb", "Rakefile", "README.textile", "sentinel.gemspec", "shoulda_macros/sentinel.rb", "test/functional/sentinel_controller_test.rb", "test/partial_rails/controllers/application_controller.rb", "test/partial_rails/controllers/forums_controller.rb", "test/partial_rails/forum_sentinel.rb", "test/test_helper.rb", "test/unit/sentinel_test.rb"]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/joshuaclayton/sentinel}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Sentinel", "--main", "README.textile"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{sentinel}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{Simple authorization for Rails}
+  s.test_files = ["test/functional/sentinel_controller_test.rb", "test/test_helper.rb", "test/unit/sentinel_test.rb"]
+
+  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_development_dependency(%q<actionpack>, [">= 0", "= 2.1.0"])
+    else
+      s.add_dependency(%q<actionpack>, [">= 0", "= 2.1.0"])
+    end
+  else
+    s.add_dependency(%q<actionpack>, [">= 0", "= 2.1.0"])
+  end
+end

data/shoulda_macros/sentinel.rb

@@ -0,0 +1,63 @@
+module Sentinel
+  module Shoulda
+    
+    def sentinel_context(options = {}, &block)
+      context "When sentinel is set up to #{options.inspect}" do
+        setup do
+          options.keys.each do |key|
+            @controller.sentinel.stubs(key).returns(options[key])
+          end
+          options.keys.each do |key|
+            assert_equal options[key], @controller.sentinel.send(key)
+          end
+        end
+        
+        merge_block(&block)
+      end
+    end
+    
+    def denied_with(denied_name, &block)
+      context "denied_with #{denied_name}" do
+        setup do
+          action = "action_#{Digest::MD5.hexdigest(Time.now.to_s.split(//).sort_by {rand}.join)}"
+          @controller.class.grants_access_to lambda { false }, :only => [action.to_sym], :denies_with => denied_name
+          get action.to_sym
+        end
+        
+        merge_block(&block)
+      end
+    end
+    
+    def should_grant_access_to(command)
+      context "performing `#{command}`" do
+        should "allow access" do
+          @controller.class.expects(:access_granted)
+          eval command
+        end
+      end
+    end
+    
+    def should_deny_access_to(*args)
+      options = args.extract_options!
+      command = args.shift
+      
+      context "performing `#{command}`" do
+        should "call the proper denied handler" do
+          @controller.class.access_denied.expects(:[]).with(options[:with] || :default)
+          eval command
+        end
+      end
+    end
+    
+    def should_not_guard(command)
+      context "performing `#{command}`" do
+        should "not use guard with a sentinel" do
+          @controller.class.expects(:access_granted).never
+          @controller.class.expects(:access_denied).never
+        end
+      end
+    end
+  end
+end
+
+Test::Unit::TestCase.extend(Sentinel::Shoulda)

data/test/functional/sentinel_controller_test.rb

@@ -0,0 +1,44 @@
+require 'test_helper'
+
+class SentinelControllerTest < ActionController::TestCase
+  include ActionView::Helpers::UrlHelper
+  include ActionView::Helpers::TagHelper
+  
+  def setup
+    @controller = ForumsController.new
+  end
+  
+  sentinel_context do
+    should_not_guard "get :index"
+  end
+  
+  sentinel_context({:viewable? => true}) do
+    should_grant_access_to "get :show"
+  end
+  
+  sentinel_context({:creatable? => false}) do
+    should_deny_access_to "get :new", :with => :redirect_to_index
+    should_deny_access_to "post :create, :forum => {:name => 'My New Forum'}", :with => :redirect_to_index
+  end
+  
+  sentinel_context({:creatable? => true}) do
+    should_grant_access_to "get :new"
+    should_grant_access_to "post :create, :forum => {:name => 'My New Forum'}"
+  end
+  
+  sentinel_context({:viewable? => false}) do
+    should_deny_access_to "get :show", :with => :sentinel_unauthorized
+  end
+  
+  denied_with :redirect_to_index do
+    should_redirect_to("forums root") { url_for(:controller => "forums")}
+  end
+  
+  denied_with :sentinel_unauthorized do
+    should_respond_with :forbidden
+    
+    should "render text as response" do
+      assert_equal "This is an even more unique default restricted warning", @response.body
+    end
+  end
+end

data/test/partial_rails/controllers/application_controller.rb

@@ -0,0 +1,2 @@
+class ApplicationController < ActionController::Base
+end

data/test/partial_rails/controllers/forums_controller.rb

@@ -0,0 +1,51 @@
+class ForumsController < ApplicationController
+  controls_access_with do
+    ForumSentinel.new :current_user => current_user, :forum => @forum
+  end
+  
+  grants_access_to :reorderable?, :only => [:reorder]
+  grants_access_to :creatable?, :only => [:new, :create], :denies_with => :redirect_to_index
+  grants_access_to :viewable?, :only => [:show], :denies_with => :sentinel_unauthorized
+  grants_access_to :destroyable?, :only => [:destroy]
+  
+  on_denied_with :redirect_to_index do
+    redirect_to url_for(:controller => "forums")
+  end
+  
+  on_denied_with :sentinel_unauthorized do
+    respond_to do |wants|
+      wants.html { render :text => "This is an even more unique default restricted warning", :status => :forbidden }
+      wants.any { head :forbidden }
+    end
+  end
+  
+  def index
+    handle_successfully
+  end
+  
+  def new
+    handle_successfully
+  end
+  
+  def show
+    handle_successfully
+  end
+  
+  def edit
+    handle_successfully
+  end
+  
+  def update
+    handle_successfully
+  end
+  
+  def delete
+    handle_successfully
+  end
+  
+  private
+  
+  def handle_successfully
+    render :text => "forums"
+  end
+end

data/test/partial_rails/forum_sentinel.rb

@@ -0,0 +1,31 @@
+class ForumSentinel < Sentinel::Sentinel
+  def creatable?
+    current_user_admin?
+  end
+  
+  def reorderable?
+    current_user_admin?
+  end
+  
+  def viewable?
+    self.forum.public? || (current_user? && self.forum.members.include?(self.current_user)) || current_user_admin?
+  end
+  
+  def editable?
+    (current_user? && self.forum.owner == self.current_user) || current_user_admin?
+  end
+  
+  def destroyable?
+    editable?
+  end
+  
+  private
+  
+  def current_user?
+    !self.current_user.nil?
+  end
+  
+  def current_user_admin?
+    current_user? && self.current_user.admin?
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,21 @@
+require 'rubygems'
+require 'test/unit'
+require 'active_support'
+require 'active_support/test_case'
+
+require 'action_controller'
+require 'action_controller/test_case'
+
+require File.join(File.dirname(__FILE__), "../rails/init")
+
+require File.join(File.dirname(__FILE__), "partial_rails", "controllers", "application_controller")
+require File.join(File.dirname(__FILE__), "partial_rails", "controllers", "forums_controller")
+require File.join(File.dirname(__FILE__), "partial_rails", "forum_sentinel")
+require File.join(File.dirname(__FILE__), "..", "shoulda_macros", "sentinel")
+
+require 'redgreen'
+require 'shoulda/rails'
+
+ActionController::Routing::Routes.clear!
+ActionController::Routing::Routes.draw {|m| m.connect ':controller/:action/:id' }
+ActionController::Routing.use_controllers! "forums"

data/test/unit/sentinel_test.rb

@@ -0,0 +1,56 @@
+require 'test_helper'
+
+class SentinelTest < ActiveSupport::TestCase
+  context "When assigning attributes" do
+    setup do
+      @sentinel = Sentinel::Sentinel
+    end
+    
+    should "create attr_accessor's for each valid key" do
+      sentinel = @sentinel.new(:user => {:name => "John", :active => true}, :forum => {:name => "My Forum"})
+      assert_equal({:name => "John", :active => true}, sentinel.user)
+      assert_equal({:name => "My Forum"}, sentinel.forum)
+      
+      sentinel.user = sentinel.forum = nil
+      assert_nil sentinel.user
+      assert_nil sentinel.forum
+    end
+    
+    should "not create attr_accessors for methods that already exist" do
+      sentinel = @sentinel.new(:class => "fake", :to_s => "one", :user => "real")
+      assert_equal sentinel.user, "real"
+      assert_equal sentinel.class, Sentinel::Sentinel
+      assert_not_equal sentinel.to_s, "one"
+    end
+    
+    should "reassign predefined attribute values if set" do
+      @sentinel.attr_accessor_with_default :message, "simple message"
+      assert_equal "simple message", @sentinel.new.message
+      assert_equal "complex message", @sentinel.new(:message => "complex message").message
+    end
+  end
+  
+  context "When overriding attributes" do
+    setup do
+      @sentinel = Sentinel::Sentinel
+    end
+    
+    should "only override for that specific instance" do
+      sentinel = @sentinel.new(:user => "assigned", :forum => nil)
+      assert_equal "assigned", sentinel.user
+      assert_nil sentinel.forum
+      assert_nil sentinel[:user => nil].user
+      assert_equal "forum", sentinel[:forum => "forum"].forum
+    end
+    
+    should "define an attr_accessor if the attribute doesn't exist" do
+      sentinel = @sentinel.new
+      assert_raise NoMethodError do
+        sentinel.name
+      end
+      
+      assert_equal "taken", sentinel[:name => "taken"].name
+      assert_nil sentinel.name
+    end
+  end
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification 
+name: joshuaclayton-sentinel
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Joshua Clayton
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-06 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: actionpack
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 2.1.0
+    version: 
+description: Simple authorization for Rails
+email: joshua.clayton@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- lib/sentinel/controller.rb
+- lib/sentinel/sentinel.rb
+- lib/sentinel.rb
+- README.textile
+files: 
+- lib/sentinel/controller.rb
+- lib/sentinel/sentinel.rb
+- lib/sentinel.rb
+- Manifest
+- MIT-LICENSE
+- rails/init.rb
+- Rakefile
+- README.textile
+- sentinel.gemspec
+- shoulda_macros/sentinel.rb
+- test/functional/sentinel_controller_test.rb
+- test/partial_rails/controllers/application_controller.rb
+- test/partial_rails/controllers/forums_controller.rb
+- test/partial_rails/forum_sentinel.rb
+- test/test_helper.rb
+- test/unit/sentinel_test.rb
+has_rdoc: true
+homepage: http://github.com/joshuaclayton/sentinel
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Sentinel
+- --main
+- README.textile
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "1.2"
+  version: 
+requirements: []
+
+rubyforge_project: sentinel
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Simple authorization for Rails
+test_files: 
+- test/functional/sentinel_controller_test.rb
+- test/test_helper.rb
+- test/unit/sentinel_test.rb