revo-lockdown 1.6.2.2 → 1.7.0

data/lib/lockdown/frameworks/rails/controller.rb

@@ -32,15 +32,30 @@ module Lockdown
 
           def check_request_authorization
             unless authorized?(path_from_hash(params))
-              raise SecurityError, "Authorization failed! \nparams: #{params.inspect}\nsession: #{session.inspect}"
+              raise SecurityError, "Lockdown Authorization failed! \nparams: #{params.inspect}\nsession: #{session.inspect}"
             end
           end
 
-          protected 
-  
-          def path_allowed?(url)
-            session[:access_rights] ||= Lockdown::System.public_access
-            session[:access_rights].include?(url)
+          protected
+          def path_allowed?(path, user)
+            if user
+              return user_groups_allowed_on_path?(path, user.user_groups)
+            else
+              return path_part_of_public_access?(path)
+            end
+          end
+
+          def user_groups_allowed_on_path?(path, user_groups)
+            user_groups.each do |user_group|
+              user_group_sym = user_group.name.underscore.tr(' ','_').to_sym
+              rights = (Lockdown::System.public_access + Lockdown::System.access_rights_for_user_group(user_group_sym))
+              return true if rights.include?(path)
+            end
+            return false
+          end
+
+          def path_part_of_public_access?(path)
+            return Lockdown::System.public_access.include?(path)         
           end
     
           def check_session_expiry
@@ -76,11 +91,11 @@ module Lockdown
 
             path = url_parts[5]
 
-            return true if path_allowed?(path)
+            return true if path_allowed?(path, current_user)
 
             begin
               hash = ActionController::Routing::Routes.recognize_path(path, :method => method)
-              return path_allowed?(path_from_hash(hash)) if hash
+              return path_allowed?(path_from_hash(hash), current_user) if hash
             rescue Exception => e
               # continue on
             end

data/lib/lockdown/frameworks/rails.rb

@@ -40,7 +40,7 @@ module Lockdown
             c.set_current_user
             c.configure_lockdown
             c.check_request_authorization
-            c.check_model_authorization
+#            c.check_model_authorization
           end
 
           klass.filter_parameter_logging :password, :password_confirmation

data/lib/lockdown/rules.rb

@@ -349,18 +349,18 @@ module Lockdown
 
       methods = controller.
                   access_methods.
-                    collect do |am| 
+                    collect do |am|
                       am[am.index('/') + 1..-1].to_sym if am.index('/')
                     end.compact.inspect
 
       return <<-RUBY
-        if controller_name == "#{controller.name}" 
+        if controller_name == "#{controller.name}"
           if #{methods}.include?(action_name.to_sym)
             unless instance_variable_defined?(:@#{model.name})
               @#{model.name} = #{model.class_name}.find(params[#{model.param.inspect}])
             end
-            # Need to make sure we find the model first before checking admin status. 
-            return true if current_user_is_admin? 
+            # Need to make sure we find the model first before checking admin status.
+            return true if current_user_is_admin?
             unless @#{model.name}.#{model.model_method}.#{model.association}(#{model.controller_method})
               raise SecurityError, "Access to #\{action_name\} denied to #{model.name}.id #\{@#{model.name}.id\}"
             end

data/lib/lockdown/session.rb

@@ -7,10 +7,8 @@ module Lockdown
       user ||= current_user
 
       if user
-        session[:access_rights] = Lockdown::System.access_rights_for_user(user)
         session[:current_user_id] = user.id
-      else
-        session[:access_rights] = Lockdown::System.public_access
+        session[:access_rights] = :all if user.user_group.name.downcase == Lockdown.administrator_group_symbol.to_s
       end
     end
 
@@ -26,28 +24,6 @@ module Lockdown
       session[:access_rights] == :all
     end
 
-    def current_user_access_in_group?(grp)
-      return true if current_user_is_admin?
-        Lockdown::System.user_groups[grp].each do |perm|
-          return true if access_in_perm?(perm)
-        end
-      false
-    end
-
-    def access_in_perm?(perm)
-      if Lockdown::System.permissions[perm]
-        Lockdown::System.permissions[perm].each do |ar|
-          return true if session_access_rights_include?(ar)
-        end 
-      end
-      false
-    end
-
-    def session_access_rights_include?(str)
-      return false unless session[:access_rights]
-      session[:access_rights].include?(str)
-    end
-
     def reset_lockdown_session
       [:expiry_time, :current_user_id, :access_rights].each do |val|
         session[val] = nil if session[val]

data/lib/lockdown/system.rb

@@ -11,7 +11,7 @@ module Lockdown
       # Lockdown::Rules defines process_rules
       process_rules
 
-      Lockdown::Database.sync_with_db unless skip_sync?
+#      Lockdown::Database.sync_with_db unless skip_sync?
 
       @initialized = true if Lockdown.caching?
     end

data/lib/lockdown.rb

@@ -7,7 +7,6 @@ require File.join("lockdown", "helper")
 require File.join("lockdown", "session")
 require File.join("lockdown", "context")
 require File.join("lockdown", "permission")
-require File.join("lockdown", "database")
 require File.join("lockdown", "rules")
 require File.join("lockdown", "system")
 require File.join("lockdown", "references")
@@ -16,7 +15,7 @@ module Lockdown
   extend Lockdown::References
   extend Lockdown::Helper
 
-  VERSION = '1.6.2'
+  VERSION = '1.7.0'
 
   class << self
     attr_accessor :logger
@@ -41,9 +40,9 @@ module Lockdown
     # Mixin Lockdown code to the appropriate framework and ORM
     def mixin
       if mixin_resource?("frameworks")
-        unless mixin_resource?("orms")
-          raise NotImplementedError, "ORM unknown to Lockdown!"
-        end
+#        unless mixin_resource?("orms")
+#          raise NotImplementedError, "ORM unknown to Lockdown!"
+#        end
       else
         Lockdown.logger.info "=> Note:: Lockdown cannot determine framework and therefore is not active.\n"
       end

data/revo-lockdown.gemspec

@@ -0,0 +1,83 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{revo-lockdown}
+  s.version = "1.7.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Andrew Stone", "Revo Pty. Ltd."]
+  s.date = %q{2010-03-02}
+  s.description = %q{Restrict access to your controller actions.  Supports basic model level restrictions as well}
+  s.email = %q{andy@stonean.com}
+  s.extra_rdoc_files = [
+    "README.txt"
+  ]
+  s.files = [
+    ".gitignore",
+     "README.txt",
+     "Rakefile",
+     "lib/lockdown.rb",
+     "lib/lockdown/context.rb",
+     "lib/lockdown/errors.rb",
+     "lib/lockdown/frameworks/rails.rb",
+     "lib/lockdown/frameworks/rails/controller.rb",
+     "lib/lockdown/frameworks/rails/view.rb",
+     "lib/lockdown/helper.rb",
+     "lib/lockdown/permission.rb",
+     "lib/lockdown/references.rb",
+     "lib/lockdown/rspec_helper.rb",
+     "lib/lockdown/rules.rb",
+     "lib/lockdown/session.rb",
+     "lib/lockdown/system.rb",
+     "revo-lockdown.gemspec",
+     "spec/lockdown/context_spec.rb",
+     "spec/lockdown/frameworks/rails/controller_spec.rb",
+     "spec/lockdown/frameworks/rails/view_spec.rb",
+     "spec/lockdown/frameworks/rails_spec.rb",
+     "spec/lockdown/permission_spec.rb",
+     "spec/lockdown/rspec_helper_spec.rb",
+     "spec/lockdown/rules_spec.rb",
+     "spec/lockdown/session_spec.rb",
+     "spec/lockdown/system_spec.rb",
+     "spec/lockdown_spec.rb",
+     "spec/rcov.opts",
+     "spec/spec.opts",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://stonean.com/wiki/lockdown}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{lockdown}
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Authorization system for Rails 2.x}
+  s.test_files = [
+    "spec/lockdown_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/lockdown/system_spec.rb",
+     "spec/lockdown/context_spec.rb",
+     "spec/lockdown/permission_spec.rb",
+     "spec/lockdown/session_spec.rb",
+     "spec/lockdown/rspec_helper_spec.rb",
+     "spec/lockdown/rules_spec.rb",
+     "spec/lockdown/frameworks/rails_spec.rb",
+     "spec/lockdown/frameworks/rails/view_spec.rb",
+     "spec/lockdown/frameworks/rails/controller_spec.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
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+    else
+      s.add_dependency(%q<rspec>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 0"])
+  end
+end
+

data/spec/lockdown/frameworks/rails/controller_spec.rb

@@ -83,7 +83,8 @@ describe Lockdown::Frameworks::Rails::Controller::Lock do
 
   describe "#path_allowed" do
     it "should return false for an invalid path" do
-      @controller.send(:path_allowed?,"/no/good").should be_false
+      @controller.stub!(:path_part_of_public_access?).and_return(false)
+      @controller.send(:path_allowed?, "/no/good", nil).should be_false
     end
   end
 
@@ -158,10 +159,16 @@ describe Lockdown::Frameworks::Rails::Controller::Lock do
     end
 
     it "should return false if path not in access_rights" do
+      @controller.stub!(:current_user_is_admin?).and_return(false)
+      @controller.stub!(:current_user).and_return(nil)
+      @controller.stub!(:path_part_of_public_access?).and_return(false)
       @controller.send(:authorized?,@a_path).should be_false
     end
 
     it "should return true if path is in access_rights" do
+      @controller.stub!(:current_user_is_admin?).and_return(false)
+      @controller.stub!(:current_user).and_return(nil)
+      @controller.stub!(:path_part_of_public_access?).and_return(true)
       @controller.send(:authorized?,@sample_url).should be_true
     end
 

data/spec/lockdown/rspec_helper_spec.rb

@@ -15,14 +15,15 @@ describe Lockdown::RspecHelper do
     @controller = TestAController.new
     @controller.stub!(:session).and_return({})
 
-    usr = mock  :user, 
+    usr_group = mock :usr_group
+
+    usr = mock  :user,
+                :user_group => usr_group,
                 :first_name => 'John',
                 :last_name  => 'Smith',
                 :password   => 'mysecret',
                 :password_confirmation  => 'mysecret'
 
-    usr_group = mock :usr_group
-
     Lockdown.should_receive(:maybe_parse_init)
     RspecEnv.send :include, Lockdown::RspecHelper
     @rspec_env = RspecEnv.new

data/spec/lockdown/session_spec.rb

@@ -35,34 +35,6 @@ describe Lockdown::Session do
     end
   end
 
-  describe "#current_user_access_in_group?" do
-    it "should return true if current user is admin" do
-      @actions = :all
-      @session = {:access_rights => @actions}
-      @controller.stub!(:session).and_return(@session)
-
-      @controller.send(:current_user_access_in_group?,:group).should == true
-    end
-
-    it "should return true if current_user has access" do
-      user_groups = {:public_group => [:public_access]}
-      hash  = {:public_access => ["posts/index", "posts/show"]}
-      Lockdown::System.stub!(:permissions).and_return(hash)
-
-      Lockdown::System.stub!(:user_groups).and_return(user_groups)
-      @controller.send(:current_user_access_in_group?,:public_group).should be_true
-    end
-
-    it "should return false if current_user has access" do
-      user_groups = {:public_group => [:public_access]}
-      hash  = {:public_access => ["books/edit", "books/update"]}
-      Lockdown::System.stub!(:permissions).and_return(hash)
-
-      Lockdown::System.stub!(:user_groups).and_return(user_groups)
-      @controller.send(:current_user_access_in_group?,:public_group).should be_false
-    end
-  end
-
   describe "#current_user_is_admin?" do
     it "should return true if access_rights == :all" do
       @actions = :all
@@ -73,40 +45,4 @@ describe Lockdown::Session do
     end
   end
 
-  describe "#add_lockdown_session_values" do
-    it "should set the access_rights from the user list" do
-      array  = ["posts/index", "posts/show"]
-      Lockdown::System.stub!(:access_rights_for_user).and_return(array)
-      usr = mock('user')
-      usr.should_receive(:id).and_return(1234)
-      @controller.send(:add_lockdown_session_values, usr)
-      @session[:access_rights].should == array
-    end
-  end
-
-
-  describe "#access_in_perm" do
-    it "should return false if permissions nil" do
-      Lockdown::System.stub!(:permissions).and_return({})
-      @controller.send(:access_in_perm?,:dummy).should be_false
-    end
-
-    it "should return true if permission found" do
-      hash  = {:public => ["posts/index", "posts/show"]}
-      Lockdown::System.stub!(:permissions).and_return(hash)
-      @controller.send(:access_in_perm?,:public).should be_true
-    end
-  end
-
-  describe "#session_access_rights_include?" do
-    it "should return true for posts/index" do
-      @controller.send(:session_access_rights_include?,'posts/index').
-        should == true
-    end
-
-    it "should return false for pages/index" do
-      @controller.send(:session_access_rights_include?,'pages/index').
-        should == false
-    end
-  end
 end

data/spec/lockdown/system_spec.rb

@@ -18,8 +18,6 @@ describe Lockdown::System do
  
       Lockdown::System.should_receive :process_rules
  
-      Lockdown::Database.should_receive :sync_with_db 
-     
       Lockdown.should_receive :caching?
 
       Lockdown::System.configure do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: revo-lockdown
 version: !ruby/object:Gem::Version 
-  version: 1.6.2.2
+  version: 1.7.0
 platform: ruby
 authors: 
   - Andrew Stone
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-11 00:00:00 +11:00
+date: 2010-03-02 00:00:00 +11:00
 default_executable: 
 dependencies: 
   - !ruby/object:Gem::Dependency 
@@ -37,52 +37,19 @@ files:
   - Rakefile
   - lib/lockdown.rb
   - lib/lockdown/context.rb
-  - lib/lockdown/database.rb
   - lib/lockdown/errors.rb
   - lib/lockdown/frameworks/rails.rb
   - lib/lockdown/frameworks/rails/controller.rb
   - lib/lockdown/frameworks/rails/view.rb
   - lib/lockdown/helper.rb
-  - lib/lockdown/orms/active_record.rb
   - lib/lockdown/permission.rb
   - lib/lockdown/references.rb
   - lib/lockdown/rspec_helper.rb
   - lib/lockdown/rules.rb
   - lib/lockdown/session.rb
   - lib/lockdown/system.rb
-  - rails_generators/lockdown/lockdown_generator.rb
-  - rails_generators/lockdown/templates/app/controllers/permissions_controller.rb
-  - rails_generators/lockdown/templates/app/controllers/sessions_controller.rb
-  - rails_generators/lockdown/templates/app/controllers/user_groups_controller.rb
-  - rails_generators/lockdown/templates/app/controllers/users_controller.rb
-  - rails_generators/lockdown/templates/app/helpers/permissions_helper.rb
-  - rails_generators/lockdown/templates/app/helpers/user_groups_helper.rb
-  - rails_generators/lockdown/templates/app/helpers/users_helper.rb
-  - rails_generators/lockdown/templates/app/models/permission.rb
-  - rails_generators/lockdown/templates/app/models/profile.rb
-  - rails_generators/lockdown/templates/app/models/user.rb
-  - rails_generators/lockdown/templates/app/models/user_group.rb
-  - rails_generators/lockdown/templates/app/views/permissions/index.html.erb
-  - rails_generators/lockdown/templates/app/views/permissions/show.html.erb
-  - rails_generators/lockdown/templates/app/views/sessions/new.html.erb
-  - rails_generators/lockdown/templates/app/views/user_groups/edit.html.erb
-  - rails_generators/lockdown/templates/app/views/user_groups/index.html.erb
-  - rails_generators/lockdown/templates/app/views/user_groups/new.html.erb
-  - rails_generators/lockdown/templates/app/views/user_groups/show.html.erb
-  - rails_generators/lockdown/templates/app/views/users/edit.html.erb
-  - rails_generators/lockdown/templates/app/views/users/index.html.erb
-  - rails_generators/lockdown/templates/app/views/users/new.html.erb
-  - rails_generators/lockdown/templates/app/views/users/show.html.erb
-  - rails_generators/lockdown/templates/config/initializers/lockit.rb
-  - rails_generators/lockdown/templates/db/migrate/create_admin_user.rb
-  - rails_generators/lockdown/templates/db/migrate/create_permissions.rb
-  - rails_generators/lockdown/templates/db/migrate/create_profiles.rb
-  - rails_generators/lockdown/templates/db/migrate/create_user_groups.rb
-  - rails_generators/lockdown/templates/db/migrate/create_users.rb
-  - rails_generators/lockdown/templates/lib/lockdown/README
-  - rails_generators/lockdown/templates/lib/lockdown/init.rb
+  - revo-lockdown.gemspec
   - spec/lockdown/context_spec.rb
-  - spec/lockdown/database_spec.rb
   - spec/lockdown/frameworks/rails/controller_spec.rb
   - spec/lockdown/frameworks/rails/view_spec.rb
   - spec/lockdown/frameworks/rails_spec.rb
@@ -126,13 +93,12 @@ summary: Authorization system for Rails 2.x
 test_files: 
   - spec/lockdown_spec.rb
   - spec/spec_helper.rb
-  - spec/lockdown/rules_spec.rb
-  - spec/lockdown/rspec_helper_spec.rb
+  - spec/lockdown/system_spec.rb
   - spec/lockdown/context_spec.rb
   - spec/lockdown/permission_spec.rb
-  - spec/lockdown/system_spec.rb
-  - spec/lockdown/database_spec.rb
   - spec/lockdown/session_spec.rb
+  - spec/lockdown/rspec_helper_spec.rb
+  - spec/lockdown/rules_spec.rb
   - spec/lockdown/frameworks/rails_spec.rb
   - spec/lockdown/frameworks/rails/view_spec.rb
   - spec/lockdown/frameworks/rails/controller_spec.rb

data/lib/lockdown/database.rb

@@ -1,127 +0,0 @@
-module Lockdown
-  class Database
-    class << self
-      # This is very basic and could be handled better using orm specific
-      # functionality, but I wanted to keep it generic to avoid creating 
-      # an interface for each the different orm implementations. 
-      # We'll see how it works...
-      def sync_with_db
-
-        @permissions = Lockdown::System.get_permissions
-        @user_groups = Lockdown::System.get_user_groups
-
-        unless ::Permission.table_exists? && Lockdown.user_group_class.table_exists?
-          Lockdown.logger.info ">> Lockdown tables not found.  Skipping database sync."
-          return
-        end
-        create_new_permissions
-
-        delete_extinct_permissions
-      
-        maintain_user_groups
-      rescue Exception => e
-        Lockdown.logger.error ">> Lockdown sync failed: #{e.backtrace.join("\n")}" 
-      end
-
-      # Create permissions not found in the database
-      def create_new_permissions
-        @permissions.each do |key|
-          next if Lockdown::System.permission_assigned_automatically?(key)
-          str = Lockdown.get_string(key)
-          p = ::Permission.find(:first, :conditions => ["name = ?", str])
-          unless p
-            Lockdown.logger.info ">> Lockdown: Permission not found in db: #{str}, creating."
-            ::Permission.create(:name => str)
-          end
-        end
-      end
-
-      # Delete the permissions not found in init.rb
-      def delete_extinct_permissions
-        db_perms = ::Permission.find(:all).dup
-        db_perms.each do |dbp|
-          unless @permissions.include?(Lockdown.get_symbol(dbp.name))
-            Lockdown.logger.info ">> Lockdown: Permission no longer in init.rb: #{dbp.name}, deleting."
-          ug_table = Lockdown.user_groups_hbtm_reference.to_s
-          if "permissions" < ug_table
-            join_table = "permissions_#{ug_table}"
-          else
-            join_table = "#{ug_table}_permissions"
-          end
-            Lockdown.database_execute("delete from #{join_table} where permission_id = #{dbp.id}")
-            dbp.destroy
-          end
-        end
-      end
-
-      def maintain_user_groups
-        # Create user groups not found in the database
-        @user_groups.each do |key|
-          str = Lockdown.get_string(key)
-          unless ug = Lockdown.user_group_class.find(:first, :conditions => ["name = ?", str])
-            create_user_group(str, key)
-          else
-            # Remove permissions from user group not found in init.rb
-            remove_invalid_permissions(ug, key)
-
-            # Add in permissions from init.rb not found in database
-            add_valid_permissions(ug, key)
-          end
-        end
-      end
-
-      def create_user_group(name_str, key)
-        Lockdown.logger.info ">> Lockdown: #{Lockdown::System.fetch(:user_group_model)} not in the db: #{name_str}, creating."
-        ug = Lockdown.user_group_class.create(:name => name_str)
-        #Inefficient, definitely, but shouldn't have any issues across orms.
-        #
-        Lockdown::System.permissions_for_user_group(key).each do |perm|
-
-          if Lockdown::System.permission_assigned_automatically?(perm)
-            Lockdown.logger.info  ">> Permission #{perm} cannot be assigned to #{name_str}.  Already belongs to built in user group (public or protected)."
-            raise  InvalidPermissionAssignment, "Invalid permission assignment"
-          end
-
-          p = ::Permission.find(:first, :conditions => ["name = ?", Lockdown.get_string(perm)]) 
-
-          ug_table = Lockdown.user_groups_hbtm_reference.to_s
-          if "permissions" < ug_table
-            join_table = "permissions_#{ug_table}"
-          else
-            join_table = "#{ug_table}_permissions"
-          end
-          Lockdown.database_execute "insert into #{join_table}(permission_id, #{Lockdown.user_group_id_reference}) values(#{p.id}, #{ug.id})"
-        end
-      end
-
-      def remove_invalid_permissions(ug, key)
-        ug.permissions.each do |perm|
-          perm_sym = Lockdown.get_symbol(perm)
-          perm_string = Lockdown.get_string(perm)
-          unless Lockdown::System.permissions_for_user_group(key).include?(perm_sym)
-            Lockdown.logger.info ">> Lockdown: Permission: #{perm_string} no longer associated to User Group: #{ug.name}, deleting."
-            ug.permissions.delete(perm)
-          end
-        end
-      end
-
-      def add_valid_permissions(ug, key)
-        Lockdown::System.permissions_for_user_group(key).each do |perm|
-          perm_string = Lockdown.get_string(perm)
-          found = false
-          # see if permission exists
-          ug.permissions.each do |p|
-            found = true if Lockdown.get_string(p) == perm_string 
-          end
-          # if not found, add it
-          unless found
-            Lockdown.logger.info ">> Lockdown: Permission: #{perm_string} not found for User Group: #{ug.name}, adding it."
-            p = ::Permission.find(:first, :conditions => ["name = ?", perm_string])
-            ug.permissions << p
-          end
-        end
-      end
-
-    end # class block
-  end # Database
-end #Lockdown

data/lib/lockdown/orms/active_record.rb

@@ -1,68 +0,0 @@
-module Lockdown
-  module Orms
-    module ActiveRecord
-      class << self
-        def use_me?
-          Object.const_defined?("ActiveRecord") && ::ActiveRecord.const_defined?("Base")
-        end
-
-        def included(mod)
-          mod.extend Lockdown::Orms::ActiveRecord::Helper
-          mixin
-        end
-
-        def mixin
-          Lockdown.orm_parent.class_eval do
-            include Lockdown::Orms::ActiveRecord::Stamps
-          end
-        end
-      end # class block
-
-      module Helper
-        def orm_parent
-          ::ActiveRecord::Base
-        end
-
-        def database_execute(query)
-          orm_parent.connection.execute(query)
-        end
-
-        def database_query(query)
-          orm_parent.connection.execute(query)
-        end
-
-        def database_table_exists?(klass)
-          klass.table_exists?
-        end
-      end
-
-      module Stamps
-        def self.included(base)
-          base.class_eval do
-            alias_method :create_without_stamps,  :create
-            alias_method :create,  :create_with_stamps
-            alias_method :update_without_stamps,  :update
-            alias_method :update,  :update_with_stamps
-          end
-        end
-
-        def current_who_did_it
-          Thread.current[:who_did_it]
-        end
-
-        def create_with_stamps
-          pid = current_who_did_it || Lockdown::System.fetch(:default_who_did_it)
-          self[:created_by] = pid if self.respond_to?(:created_by) 
-          self[:updated_by] = pid if self.respond_to?(:updated_by) 
-          create_without_stamps
-        end
-                  
-        def update_with_stamps
-          pid = current_who_did_it || Lockdown::System.fetch(:default_who_did_it)
-          self[:updated_by] = pid if self.respond_to?(:updated_by)
-          update_without_stamps
-        end
-      end
-    end
-  end
-end