thelinuxlich-aegis 1.1.7 → 1.1.8

data/README.rdoc

@@ -1,195 +1,202 @@
-= Aegis - role-based permissions for your user models
-
-Aegis allows you to manage fine-grained, complex permission for user accounts in a central place.
-
-== Installation
-
-Add the following to your <tt>Initializer.run</tt> block in your <tt>environment.rb</tt>:
-    config.gem 'aegis', :source => 'http://gemcutter.org'
-Then do a 
-    sudo rake gems:install
-
-Alternatively, use
-    sudo gem sources -a http://gemcutter.org
-    sudo gem install aegis
-
-== Example 
-
-First, let's define some roles:
-
-    # app/models/permissions.rb
-    class Permissions < Aegis::Permissions
-
-      role :guest
-      role :registered_user
-      role :moderator
-      role :administrator, :default_permission => :allow
-      
-      permission :edit_post do |user, post|
-        allow :registered_user do
-          post.creator == user      # a registered_user can only edit his own posts
-        end
-        allow :moderator
-      end
-      
-      permission :read_post do |post|
-        allow :everyone
-        deny :guest do
-          post.private?             # guests may not read private posts
-        end
-      end
-
-    end
-
-
-Now we assign roles to users. For this, the users table needs to have a string
-column +role_name+.
-
-    # app/models/user.rb
-    class User
-      has_role
-    end
-
-
-These permissions may be used in views and controllers:
-    
-    # app/views/posts/index.html.erb
-    @posts.each do |post|
-      <% if current_user.may_read_post? post %>
-        <%= render post %>
-        <% if current_user.may_edit_post? post %>
-          <%= link_to 'Edit', edit_post_path(post) %>
-        <% end %>
-      <% end %>
-    <% end %>
-
-
-    # app/controllers/posts_controller.rb
-    class PostsController
-      # ...
-
-      def update
-        @post = Post.find(params[:id])
-        current_user.may_edit_post! @post    # raises an Aegis::PermissionError for unauthorized access
-        # ...
-      end
-
-    end
-
-== Details
-
-=== Roles
-
-To equip a (user) model with any permissions, you simply call *has_role* within
-the model:
-    class User < ActiveRecord::Base
-      has_role
-    end
-Aegis assumes that the corresponding database table has a string-valued column
-called +role_name+. You may override the name with the <tt>:name_accessor =>
-:my_role_column</tt> option.
-
-You can define a default role for a model by saying
-    class User < ActiveRecord::Base
-      has_role :default => :admin
-    end
-All this will do, is initialize the +role_name+ with the given default when
-<tt>User.new</tt> is called.
-
-The roles and permissions themselves are defined in a class inheriting from
-<b>Aegis::Permissions</b>. To define roles you create a model <tt>permissions.rb</tt>
-and use the *role* method:
-    class Permissions < Aegis::Permissions
-      role 'role_name'
-    end
-
-By default, users belonging to this role are not permitted anything. You may
-override this with <tt>:default_permission => :allow</tt>, e.g.
-    role 'admin', :default_permission => :allow
-
-=== Permissions
-
-Permissions are specified with the *permission* method and *allow* and *deny*
-    permission :do_something do
-        allow :role_a, :role_b
-        deny :role_c
-    end
-
-Your user model just received two methods called <b>User#may_do_something?</b>
-and <b>User#may_do_something!</b>. The first one with the ? returns true for users with
-+role_a+ and +role_b+, and false for users with +role_c+. The second one with the ! raises an
-Aegis::PermissionError for +role_c+.
-
-=== Normalization
-
-Aegis will perform some normalization. For example, the permissions
-+edit_something+ and +update_something+ will be the same, each granting both 
-<tt>may_edit_something?</tt> and <tt>may_update_something?</tt>. The following normalizations
-are active:
-* edit = update
-* show = list = view = read
-* delete = remove = destroy
-
-=== Complex permissions (with parameters)
- 
-*allow* and *deny* can also take a block that may return +true+ or +false+
-indicating if this really applies. So
-    permission :pull_april_fools_prank do
-      allow :everyone do
-        Date.today.month == 4 and Date.today.day == 1
-      end
-    end
-will generate a <tt>may_pull_april_fools_prank?</tt> method that only returns true on
-April 1.
-
-This becomes more useful if you pass parameters to a <tt>may_...?</tt> method, which
-are passed through to the permission block (together with the user object). This
-way you can define more complex permissions like
-    permission :edit_post do |current_user, post|
-      allow :registered_user do
-        post.owner == current_user
-      end
-      allow :admin
-    end
-which will permit admins and post owners to edit posts.
-
-=== For your convenience
-
-As a convenience, if you create a permission ending in a plural 's', this
-automatically includes the singular form. That is, after
-    permission :read_posts do
-      allow :everyone
-    end
-<tt>.may_read_post? @post</tt> will return true, as well.
-
-If you want to grant +create_something+, +read_something+, +update_something+
-and +destroy_something+ permissions all at once, just use
-    permission :crud_something do
-      allow :admin
-    end
-
-If several permission blocks (or several allow and denies) apply to a certain
-role, the later one always wins. That is
-    permission :do_something do
-      deny :everyone
-      allow :admin
-    end
-will work as expected.
-
-=== Our stance on multiple roles per user
-
-We believe that you should only distinguish roles that have different ways of resolving their permissions. A typical set of roles would be
-
-* anonymous guest (has access to nothing with some exceptions)
-* signed up user (has access to some things depending on its attributes and associations)
-* administrator (has access to everything)
-
-We don't do multiple, parametrized roles like "leader for project #2" and "author of post #7". 
-That would be reinventing associations. Just use a single :user role and let your permission block
-query regular associations and attributes.
-
-=== Credits
-
-Henning Koch, Tobias Kraze
-
-{link www.makandra.de}[http://www.makandra.de/]
+= Aegis - role-based permissions for your user models
+
+Aegis allows you to manage fine-grained, complex permission for user accounts in a central place.
+
+== Installation
+
+Add the following to your <tt>Initializer.run</tt> block in your <tt>environment.rb</tt>:
+    config.gem 'thelinuxlich-aegis', :lib => 'aegis'
+Then do a 
+    sudo rake gems:install
+
+Alternatively, use
+    sudo gem install thelinuxlich-aegis
+
+== Changes in this fork
+Now you can set the permission prefix with your locale(default is 'may')
+Example: in locale/en.yml:
+  aegis:
+    permission_prefix: 'should'
+
+And then you can verify authorization with current_user.should_edit_posts?
+
+== Example 
+
+First, let's define some roles:
+
+    # app/models/permissions.rb
+    class Permissions < Aegis::Permissions
+
+      role :guest
+      role :registered_user
+      role :moderator
+      role :administrator, :default_permission => :allow
+      
+      permission :edit_post do |user, post|
+        allow :registered_user do
+          post.creator == user      # a registered_user can only edit his own posts
+        end
+        allow :moderator
+      end
+      
+      permission :read_post do |post|
+        allow :everyone
+        deny :guest do
+          post.private?             # guests may not read private posts
+        end
+      end
+
+    end
+
+
+Now we assign roles to users. For this, the users table needs to have a string
+column +role_name+.
+
+    # app/models/user.rb
+    class User
+      has_role
+    end
+
+
+These permissions may be used in views and controllers:
+    
+    # app/views/posts/index.html.erb
+    @posts.each do |post|
+      <% if current_user.may_read_post? post %>
+        <%= render post %>
+        <% if current_user.may_edit_post? post %>
+          <%= link_to 'Edit', edit_post_path(post) %>
+        <% end %>
+      <% end %>
+    <% end %>
+
+
+    # app/controllers/posts_controller.rb
+    class PostsController
+      # ...
+
+      def update
+        @post = Post.find(params[:id])
+        current_user.may_edit_post! @post    # raises an Aegis::PermissionError for unauthorized access
+        # ...
+      end
+
+    end
+
+== Details
+
+=== Roles
+
+To equip a (user) model with any permissions, you simply call *has_role* within
+the model:
+    class User < ActiveRecord::Base
+      has_role
+    end
+Aegis assumes that the corresponding database table has a string-valued column
+called +role_name+. You may override the name with the <tt>:name_accessor =>
+:my_role_column</tt> option.
+
+You can define a default role for a model by saying
+    class User < ActiveRecord::Base
+      has_role :default => :admin
+    end
+All this will do, is initialize the +role_name+ with the given default when
+<tt>User.new</tt> is called.
+
+The roles and permissions themselves are defined in a class inheriting from
+<b>Aegis::Permissions</b>. To define roles you create a model <tt>permissions.rb</tt>
+and use the *role* method:
+    class Permissions < Aegis::Permissions
+      role 'role_name'
+    end
+
+By default, users belonging to this role are not permitted anything. You may
+override this with <tt>:default_permission => :allow</tt>, e.g.
+    role 'admin', :default_permission => :allow
+
+=== Permissions
+
+Permissions are specified with the *permission* method and *allow* and *deny*
+    permission :do_something do
+        allow :role_a, :role_b
+        deny :role_c
+    end
+
+Your user model just received two methods called <b>User#may_do_something?</b>
+and <b>User#may_do_something!</b>. The first one with the ? returns true for users with
++role_a+ and +role_b+, and false for users with +role_c+. The second one with the ! raises an
+Aegis::PermissionError for +role_c+.
+
+=== Normalization
+
+Aegis will perform some normalization. For example, the permissions
++edit_something+ and +update_something+ will be the same, each granting both 
+<tt>may_edit_something?</tt> and <tt>may_update_something?</tt>. The following normalizations
+are active:
+* edit = update
+* show = list = view = read
+* delete = remove = destroy
+
+=== Complex permissions (with parameters)
+ 
+*allow* and *deny* can also take a block that may return +true+ or +false+
+indicating if this really applies. So
+    permission :pull_april_fools_prank do
+      allow :everyone do
+        Date.today.month == 4 and Date.today.day == 1
+      end
+    end
+will generate a <tt>may_pull_april_fools_prank?</tt> method that only returns true on
+April 1.
+
+This becomes more useful if you pass parameters to a <tt>may_...?</tt> method, which
+are passed through to the permission block (together with the user object). This
+way you can define more complex permissions like
+    permission :edit_post do |current_user, post|
+      allow :registered_user do
+        post.owner == current_user
+      end
+      allow :admin
+    end
+which will permit admins and post owners to edit posts.
+
+=== For your convenience
+
+As a convenience, if you create a permission ending in a plural 's', this
+automatically includes the singular form. That is, after
+    permission :read_posts do
+      allow :everyone
+    end
+<tt>.may_read_post? @post</tt> will return true, as well.
+
+If you want to grant +create_something+, +read_something+, +update_something+
+and +destroy_something+ permissions all at once, just use
+    permission :crud_something do
+      allow :admin
+    end
+
+If several permission blocks (or several allow and denies) apply to a certain
+role, the later one always wins. That is
+    permission :do_something do
+      deny :everyone
+      allow :admin
+    end
+will work as expected.
+
+=== Our stance on multiple roles per user
+
+We believe that you should only distinguish roles that have different ways of resolving their permissions. A typical set of roles would be
+
+* anonymous guest (has access to nothing with some exceptions)
+* signed up user (has access to some things depending on its attributes and associations)
+* administrator (has access to everything)
+
+We don't do multiple, parametrized roles like "leader for project #2" and "author of post #7". 
+That would be reinventing associations. Just use a single :user role and let your permission block
+query regular associations and attributes.
+
+=== Credits
+
+Henning Koch, Tobias Kraze
+
+{link www.makandra.de}[http://www.makandra.de/]

data/VERSION

@@ -1 +1 @@
-1.1.7
+1.1.8

data/lib/aegis/constants.rb

@@ -1,7 +1,11 @@
 module Aegis
   module Constants
     EVERYONE_ROLE_NAME = :everyone
-    PERMISSION_PREFIX = I18n.translate('aegis.permission_prefix',:default => 'may') 
-    CRUD_VERBS = ["create", "read", "update", "destroy"]
+    PERMISSION_PREFIX = I18n.translate('aegis.permission.prefix',:default => 'may') 
+    ADMIN_PREFIX = I18n.translate('aegis.permission.admin', :default => 'admin')
+    CRUD_VERBS = [I18n.translate('aegis.permission.create', :default => 'create'),
+      I18n.translate('aegis.permission.read', :default => 'read'),
+      I18n.translate('aegis.permission.update', :default => 'update'),
+      I18n.translate('aegis.permission.destroy', :default => 'destroy')]
   end
 end

data/lib/aegis/has_role.rb

@@ -69,6 +69,14 @@ module Aegis
           end
         end
         
+        if options[:special_permissions]
+          self.class_eval do 
+            self.has_many :special_permissions, :foreign_key => "user_id"
+          end
+          @class_name = self.class_name.underscore
+          SpecialPermission.class_eval "belongs_to :#{@class_name}, :foreign_key => 'user_id'"  
+        end
+
         private
         
         # Delegate may_...? and may_...! methods to the user's role.

data/lib/aegis/permission_filter.rb

@@ -0,0 +1,32 @@
+module Aegis
+  module PermissionFilter
+    def self.extended(base)
+      base.instance_eval do
+        def authorize_first!(current_user, options = {})
+          before_filter{authorize_action(current_user,options)}
+        end
+
+        protected
+          def authorize_action(current_user,options = {})
+            options = {:except => []}.merge(options)
+            options[:except] << "application"
+            return if options[:except].include? controller_name
+            permission_type = ""
+            case action_name
+            when "index","show"
+              permission_type = Aegis::Constants::CRUD_VERBS[1]
+            when "edit","update"
+              permission_type = Aegis::Constants::CRUD_VERBS[2]
+            when "new,","create"
+              permission_type = Aegis::Constants::CRUD_VERBS[0]
+            when "destroy"
+              permission_type = Aegis::Constants::CRUD_VERBS[3]
+            else
+              permission_type = action_name
+            end
+            eval "#{current_user}.#{Aegis::Constants::PERMISSION_PREFIX}_#{permission_type}_#{controller_name}?"
+          end
+      end
+    end
+  end
+end

data/lib/aegis/permissions.rb

@@ -8,7 +8,7 @@ module Aegis
         extend ClassMethods
       end
     end    
-
+    
     module ClassMethods
  
       def role(role_name, options = {})
@@ -44,6 +44,27 @@ module Aegis
           add_split_crud_permission(permission_name, &block)
         end
       end
+
+      def restful_permissions!(options = {})
+        options = {:except => []}.merge(options)
+        options[:except] << "rails/info"
+        options[:except] << "rails_info"
+        options[:except] << "application"
+        controllers = ActionController::Routing.possible_controllers.select do |controller|
+          !options[:except].include? controller
+        end
+        controllers.each do |controller|
+          Aegis::Constants::CRUD_VERBS.zip(["writable","readable","updatable","deletable"]).each do |verb,filter|
+            permission "#{verb}_#{controller}" do |user|
+              allow :everyone do
+                user.send("#{Aegis::Constants::PERMISSION_PREFIX}_#{Aegis::Constants::ADMIN_PREFIX}_#{controller}?") ||
+                  user.special_permissions.send(filter,controller).exists?
+              end
+            end
+          end
+        end
+      end  
+
       
       define_method "#{Aegis::Constants::PERMISSION_PREFIX}?" do |role_or_role_name, permission, *args|
         role = role_or_role_name.is_a?(Aegis::Role) ? role_or_role_name : find_role_by_name(role_or_role_name)

data/lib/aegis.rb

@@ -1,5 +1,6 @@
 # Include hook code here
 require 'aegis/constants'
+require 'rails/special_permission'
 require 'aegis/has_role'
 require 'aegis/normalization'
 require 'aegis/permission_error'
@@ -7,4 +8,5 @@ require 'aegis/permission_evaluator'
 require 'aegis/permissions'
 require 'aegis/role'
 require 'rails/active_record'
-
+require 'rails/action_controller'
+require 'aegis/permission_filter'

data/lib/generators/aegis/aegis_generator.rb

@@ -0,0 +1,10 @@
+class AegisGenerator < Rails::Generator::Base
+  desc "Generate a table for special permissions with crud fields"
+  
+  def manifest
+    record do |m|
+      m.migration_template 'migration.rb', 'db/migrate', :migration_file_name => 'create_special_permissions'
+    end
+  end
+
+end

data/lib/generators/aegis/templates/migration.rb

@@ -0,0 +1,17 @@
+class CreateSpecialPermissions < ActiveRecord::Migration
+  def self.up
+    create_table :special_permissions do |t|
+      t.integer :user_id
+      t.string :permission_module
+      t.boolean :permission_read, :default => false
+      t.boolean :permission_write, :default => false
+      t.boolean :permission_destroy, :default => false
+      t.boolean :permission_update, :default => false
+      t.timestamps
+    end
+  end
+
+  def self.down
+    drop_table :special_permissions
+  end
+end

data/lib/rails/action_controller.rb

@@ -0,0 +1,3 @@
+ActionController::Base.class_eval do
+  extend Aegis::PermissionFilter
+end

data/lib/rails/special_permission.rb

@@ -0,0 +1,10 @@
+class SpecialPermission < ActiveRecord::Base
+
+  validates_presence_of :user_id, :permission_module
+  validates_uniqueness_of :permission_module, :scope => 'user_id'
+  
+  named_scope :writable, lambda {|controller| {:conditions => ['permission_module = ? and permission_write = ?', controller, true]}}
+  named_scope :readable, lambda {|controller| {:conditions => ['permission_module = ? and permission_read = ?', controller, true]}}
+  named_scope :updatable, lambda {|controller| {:conditions => ['permission_module = ? and permission_update = ?', controller, true]}}
+  named_scope :deletable, lambda {|controller| {:conditions => ['permission_module = ? and permission_destroy = ?', controller, true]}}
+end

data/thelinuxlich-aegis.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{thelinuxlich-aegis}
-  s.version = "1.1.7"
+  s.version = "1.1.8"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["thelinuxlich"]
-  s.date = %q{2010-03-23}
+  s.date = %q{2010-03-24}
   s.description = %q{Aegis is a role-based permission system, where all users are given a role. It is possible to define detailed and complex permissions for each role very easily.}
   s.email = %q{thelinuxlich@gmail.com}
   s.extra_rdoc_files = [
@@ -17,20 +17,25 @@ Gem::Specification.new do |s|
   ]
   s.files = [
     ".gitignore",
+     ":test",
      "MIT-LICENSE",
      "README.rdoc",
      "Rakefile",
      "VERSION",
-     "aegis.gemspec",
      "lib/aegis.rb",
      "lib/aegis/constants.rb",
      "lib/aegis/has_role.rb",
      "lib/aegis/normalization.rb",
      "lib/aegis/permission_error.rb",
      "lib/aegis/permission_evaluator.rb",
+     "lib/aegis/permission_filter.rb",
      "lib/aegis/permissions.rb",
      "lib/aegis/role.rb",
+     "lib/generators/aegis/aegis_generator.rb",
+     "lib/generators/aegis/templates/migration.rb",
+     "lib/rails/action_controller.rb",
      "lib/rails/active_record.rb",
+     "lib/rails/special_permission.rb",
      "test/app_root/app/controllers/application_controller.rb",
      "test/app_root/app/models/old_soldier.rb",
      "test/app_root/app/models/permissions.rb",

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 1
   - 1
-  - 7
-  version: 1.1.7
+  - 8
+  version: 1.1.8
 platform: ruby
 authors: 
 - thelinuxlich
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-23 00:00:00 -03:00
+date: 2010-03-24 00:00:00 -03:00
 default_executable: 
 dependencies: []
 
@@ -28,20 +28,25 @@ extra_rdoc_files:
 - README.rdoc
 files: 
 - .gitignore
+- ":test"
 - MIT-LICENSE
 - README.rdoc
 - Rakefile
 - VERSION
-- aegis.gemspec
 - lib/aegis.rb
 - lib/aegis/constants.rb
 - lib/aegis/has_role.rb
 - lib/aegis/normalization.rb
 - lib/aegis/permission_error.rb
 - lib/aegis/permission_evaluator.rb
+- lib/aegis/permission_filter.rb
 - lib/aegis/permissions.rb
 - lib/aegis/role.rb
+- lib/generators/aegis/aegis_generator.rb
+- lib/generators/aegis/templates/migration.rb
+- lib/rails/action_controller.rb
 - lib/rails/active_record.rb
+- lib/rails/special_permission.rb
 - test/app_root/app/controllers/application_controller.rb
 - test/app_root/app/models/old_soldier.rb
 - test/app_root/app/models/permissions.rb

data/aegis.gemspec

@@ -1,107 +0,0 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE
-# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
-# -*- encoding: utf-8 -*-
-
-Gem::Specification.new do |s|
-  s.name = %q{aegis}
-  s.version = "1.1.6"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Henning Koch"]
-  s.date = %q{2009-11-11}
-  s.description = %q{Aegis is a role-based permission system, where all users are given a role. It is possible to define detailed and complex permissions for each role very easily.}
-  s.email = %q{github@makandra.de}
-  s.extra_rdoc_files = [
-    "README.rdoc"
-  ]
-  s.files = [
-    ".gitignore",
-     "MIT-LICENSE",
-     "README.rdoc",
-     "Rakefile",
-     "VERSION",
-     "aegis.gemspec",
-     "lib/aegis.rb",
-     "lib/aegis/constants.rb",
-     "lib/aegis/has_role.rb",
-     "lib/aegis/normalization.rb",
-     "lib/aegis/permission_error.rb",
-     "lib/aegis/permission_evaluator.rb",
-     "lib/aegis/permissions.rb",
-     "lib/aegis/role.rb",
-     "lib/rails/active_record.rb",
-     "test/app_root/app/controllers/application_controller.rb",
-     "test/app_root/app/models/old_soldier.rb",
-     "test/app_root/app/models/permissions.rb",
-     "test/app_root/app/models/soldier.rb",
-     "test/app_root/app/models/trust_fund_kid.rb",
-     "test/app_root/app/models/user.rb",
-     "test/app_root/app/models/user_subclass.rb",
-     "test/app_root/app/models/veteran_soldier.rb",
-     "test/app_root/config/boot.rb",
-     "test/app_root/config/database.yml",
-     "test/app_root/config/environment.rb",
-     "test/app_root/config/environments/in_memory.rb",
-     "test/app_root/config/environments/mysql.rb",
-     "test/app_root/config/environments/postgresql.rb",
-     "test/app_root/config/environments/sqlite.rb",
-     "test/app_root/config/environments/sqlite3.rb",
-     "test/app_root/config/routes.rb",
-     "test/app_root/db/migrate/20090408115228_create_users.rb",
-     "test/app_root/db/migrate/20090429075648_create_soldiers.rb",
-     "test/app_root/db/migrate/20091110075648_create_veteran_soldiers.rb",
-     "test/app_root/db/migrate/20091110075649_create_trust_fund_kids.rb",
-     "test/app_root/lib/console_with_fixtures.rb",
-     "test/app_root/log/.gitignore",
-     "test/app_root/script/console",
-     "test/has_role_options_test.rb",
-     "test/has_role_test.rb",
-     "test/permissions_test.rb",
-     "test/test_helper.rb",
-     "test/validation_test.rb"
-  ]
-  s.homepage = %q{http://github.com/makandra/aegis}
-  s.rdoc_options = ["--charset=UTF-8"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.5}
-  s.summary = %q{Role-based permissions for your user models.}
-  s.test_files = [
-    "test/app_root/app/models/trust_fund_kid.rb",
-     "test/app_root/app/models/veteran_soldier.rb",
-     "test/app_root/app/models/permissions.rb",
-     "test/app_root/app/models/soldier.rb",
-     "test/app_root/app/models/user_subclass.rb",
-     "test/app_root/app/models/old_soldier.rb",
-     "test/app_root/app/models/user.rb",
-     "test/app_root/app/controllers/application_controller.rb",
-     "test/app_root/config/environment.rb",
-     "test/app_root/config/environments/mysql.rb",
-     "test/app_root/config/environments/postgresql.rb",
-     "test/app_root/config/environments/sqlite3.rb",
-     "test/app_root/config/environments/in_memory.rb",
-     "test/app_root/config/environments/sqlite.rb",
-     "test/app_root/config/boot.rb",
-     "test/app_root/config/routes.rb",
-     "test/app_root/db/migrate/20090429075648_create_soldiers.rb",
-     "test/app_root/db/migrate/20090408115228_create_users.rb",
-     "test/app_root/db/migrate/20091110075649_create_trust_fund_kids.rb",
-     "test/app_root/db/migrate/20091110075648_create_veteran_soldiers.rb",
-     "test/app_root/lib/console_with_fixtures.rb",
-     "test/validation_test.rb",
-     "test/test_helper.rb",
-     "test/has_role_options_test.rb",
-     "test/has_role_test.rb",
-     "test/permissions_test.rb"
-  ]
-
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-    else
-    end
-  else
-  end
-end