lockdown 0.3.7 → 0.3.8

data/History.txt

@@ -1,3 +1,9 @@
+== 0.3.8 2008-05-01
+* Fixed: corrected class loader to ensure ObjectSpace is used only once
+
+== 0.3.7 2008-05-01
+* Fixed: access rights list for permissions. maded modifications to permissions helper as well.
+
 == 0.3.6 2008-04-30
 * Fixed: The block in init.rb does not take a parameter.  This has been removed from the template.
 

data/lib/lockdown/controller_inspector.rb

@@ -46,7 +46,7 @@ module Lockdown
       # This is admin access
       # 
       def all_controllers
-        controllers = find_all_controller_classes
+        controllers = Lockdown::System.controller_classes
       
         controllers.collect do |controller|
           methods = available_actions(controller)
@@ -59,114 +59,16 @@ module Lockdown
       def paths_for(str_sym, *methods)
         str = str_sym.to_s if str_sym.is_a?(Symbol)
         if methods.empty?
-          klass = get_controller_class(str)
+          klass = Lockdown::System.fetch_controller_class(str)
           methods = available_actions(klass) 
         end
         methods.collect{|meth| ctr_path(str) + "/" + meth.to_s }
       end
     
-      def get_controller_class(str)
-        load_controller(str)
-        lockdown_const_get(str)
-      end
-
-      def find_all_controller_classes
-        load_all_controllers
-        return ObjectSpace.controller_classes
-      end
-
-      def ObjectSpace.controller_classes
-        subclasses = []
-        self.each_object(Class) do |klass|
-          subclasses << klass if klass.ancestors.include?(Lockdown.controller_parent)
-        end
-        subclasses
-      end
-      
-      def load_controller(str)
-        unless lockdown_const_defined?("Application")
-          require(Lockdown.project_root + "/app/controllers/application.rb")
-        end
-        
-        unless lockdown_const_defined?(kontroller_class_name(str))
-          require(Lockdown.project_root + "/app/controllers/#{kontroller_file_name(str)}")
-        end
-      end
-
-      def load_all_controllers
-        Dir["#{Lockdown.project_root}/app/controllers/**/*.rb"].sort.each do |c|
-         require(c) unless c == "application.rb"
-        end
-      end
-      
-      def lockdown_const_defined?(str)
-        if str.include?("__")
-          # this is a namespaced controller.  need to apply const_defined_to the namespace
-          parts = str.split("__")
-          eval("#{camelize(parts[0])}.const_defined?(\"#{kontroller_class_name(parts[1])}\")") 
-        else
-          const_defined?(camelize(str))
-        end
-      end
-
-      def lockdown_const_get(str)
-        if str.include?("__")
-          # this is a namespaced controller.  need to apply const_get the namespace
-          parts = str.split("__")
-          eval("#{camelize(parts[0])}.const_get(\"#{kontroller_class_name(parts[1])}\")") 
-        else
-          const_get(kontroller_class_name(str))
-        end
-      end
-
       def ctr_path(str)
         str.gsub("__","\/")
       end
 
-      #
-      # Convert the str parameter (originally the symbol) to the 
-      # class name.
-      #
-      # For a controller defined as :users in init.rb, the str
-      # parameter here would be "users". The result of this method
-      # would be "/users"
-      #
-      # For a namespaced controller:
-      # In init.rb it would be defined as :admin__users.
-      # The str paramter would be "admin__users".
-      # The result would be "/admin/users".
-      #
-      def controller_file_name(str)
-        if str.include?("__")
-          str.split("__").join("/")
-        else
-          str
-        end
-      end
-
-      #
-      # Convert the str parameter (originally the symbol) to the 
-      # class name.
-      #
-      # For a controller defined as :users in init.rb, the str
-      # parameter here would be "users". The result of this method
-      # would be "Users"
-      #
-      def controller_class_name(str)
-        if str.include?("__")
-          str.split("__").collect{|p| camelize(p)}.join("::")
-        else
-          camelize(str)
-        end
-      end
-
-      #
-      # The reverse of controller_class_name.  Convert the controllers
-      # class name to the string version of the symbols used in acces.rb.
-      #
-      # For a controller defined as :users in init.rb, the klass 
-      # parameter here would be Users (the class). The result of this method
-      # would be "users", the string version of :users.
       #
       # Luckily both Rails and Merb have the controller_name method. This 
       # is here in case that changes.
@@ -179,14 +81,6 @@ module Lockdown
     module Rails #:nodoc:
       include Lockdown::ControllerInspector::Core
       
-      def kontroller_class_name(str)
-        "#{controller_class_name(str)}Controller"
-      end
-
-      def kontroller_file_name(str)
-       "#{controller_file_name(str)}_controller.rb"
-      end
-
       def available_actions(klass)
         klass.public_instance_methods - klass.hidden_actions
       end
@@ -195,14 +89,6 @@ module Lockdown
     module Merb #:nodoc:
       include Lockdown::ControllerInspector::Core
       
-      def kontroller_class_name(str)
-        controller_class_name(str)
-      end
-
-      def kontroller_file_name(str)
-       controller_file_name(str) + ".rb"
-      end
-
       def available_actions(klass)
         klass.callable_actions.keys
       end

data/lib/lockdown/helper.rb

@@ -1,11 +1,5 @@
 module Lockdown
   module Helper
-    def syms_from_names(ary)
-      rvalue = []
-      ary.each{|ar| rvalue << symbolize(ar.name)}
-      rvalue
-    end
-
     #
     # If str_sym is a Symbol (:users), give me back "Users"
     # If str_sym is a String ("Users"), give me back :users
@@ -28,10 +22,6 @@ module Lockdown
 			str_sym.is_a?(String) ? convert_reference_name(str_sym) : str_sym
 		end
 
-    def symbolize(str)
-      str.downcase.gsub("admin ","admin__").gsub(" ","_").to_sym
-    end
-
     def camelize(str)
       str.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
     end
@@ -65,5 +55,16 @@ module Lockdown
         gsub(/([a-z\d])([A-Z])/,'\1_\2').
         tr("-", "_").downcase
     end
+
+    if Lockdown.rails_app?
+      def kontroller_class_name(str)
+        "#{str}Controller"
+      end
+    else
+      def kontroller_class_name(str)
+        str
+      end
+    end
   end
+
 end

data/lib/lockdown/system.rb

@@ -17,6 +17,8 @@ module Lockdown
       # :private_access will restrict access to model data to their creators.
       # attr_accessor :private_access #:nodoc:
 
+      attr_accessor :controller_classes #:nodoc:
+
       def configure(&block)
 				self.set_defaults
         self.instance_eval(&block)
@@ -177,9 +179,18 @@ module Lockdown
 				all_controllers
       end
 
+      def fetch_controller_class(str)
+        @controller_classes.each do |klass|
+          return klass if klass.name == controller_class_name(str)
+        end
+      end
+
       protected 
 
       def set_defaults
+        @controller_classes = []
+        load_controller_classes
+
         @permissions = {}
         @user_groups = {}
 
@@ -205,6 +216,50 @@ module Lockdown
 				false
 			end
 
+      def load_controller_classes
+        unless const_defined?("Application")
+          require(Lockdown.project_root + "/app/controllers/application.rb")
+        end
+
+        Dir.chdir("#{Lockdown.project_root}/app/controllers") do
+          Dir["**/*.rb"].sort.each do |c|
+            next if c == "application.rb"
+            klass = controller_class_name_from_file(c)
+            require(c) unless qualified_const_defined?(klass)
+            @controller_classes.push( qualified_const_get(klass) )
+          end
+        end
+      end
+
+      def controller_class_name_from_file(str)
+        str.split(".")[0].split("/").collect{|str| camelize(str) }.join("::")
+      end
+
+      def controller_class_name(str)
+        if str.include?("__")
+          kontroller_class_name(str.split("__").collect{|p| camelize(p)}.join("::"))
+        else
+          kontroller_class_name(camelize(str))
+        end
+      end
+
+      def qualified_const_defined?(klass)
+        if klass =~ /::/
+          namespace, klass = klass.split("::")
+          eval("#{namespace}.const_defined?(#{klass})") if const_defined?(namespace)
+        else
+          const_defined?(klass)
+        end
+      end
+
+      def qualified_const_get(klass)
+        if klass =~ /::/
+          namespace, klass = klass.split("::")
+          eval(namespace).const_get(klass)
+        else
+          const_get(klass)
+        end
+      end
     end # class block
   end # System class
 end # Lockdown

data/lib/lockdown/version.rb

@@ -2,7 +2,7 @@ module Lockdown #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 3
-    TINY  = 7
+    TINY  = 8
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: lockdown
 version: !ruby/object:Gem::Version 
-  version: 0.3.7
+  version: 0.3.8
 platform: ruby
 authors: 
 - Andrew Stone