zen 0.2.4.1 → 0.2.5

data/lib/zen/controller/frontend_controller.rb

@@ -1,7 +1,7 @@
 #:nodoc:
 module Zen
   #:nodoc:
-  module Controllers
+  module Controller
     ##
     # Controller that should be extended by other controllers that can be accessed from
     # the web without having to log in. Frontend controllers don't have a layout and
@@ -10,9 +10,10 @@ module Zen
     # @author Yorick Peterse
     # @since  0.1
     #
-    class FrontendController < Zen::Controllers::BaseController
-      engine :liquid
+    class FrontendController < Zen::Controller::BaseController
+      engine :etanni
       layout :none
+      helper :theme, :common
     end
   end
 end

data/lib/zen/controller/main_controller.rb

@@ -1,7 +1,7 @@
 #:nodoc:
 module Zen
   #:nodoc:
-  module Controllers
+  module Controller
     ##
     # The MainController controller is used to load the correct template files based
     # on the current URI. If no section is specified the default section will be retrieved
@@ -10,7 +10,7 @@ module Zen
     # @author Yorick Peterse
     # @since  0.1
     #
-    class MainController < Zen::Controllers::FrontendController
+    class MainController < Zen::Controller::FrontendController
       map '/'
       
       ##
@@ -25,52 +25,36 @@ module Zen
       # @param  [Array] uri Array containing all arguments (thus the URI).
       #
       def index(*uri)
-        @uri     = []
+        @request_uri = []
         
         # Clean the URI of nasty input
-        uri.each { |v| @uri.push(h(v)) }
+        uri.each { |v| @request_uri.push(h(v)) }
         
-        if !@uri[0] or @uri[0].empty?
-          @uri[0] = settings[:default_section]
+        if !@request_uri[0] or @request_uri[0].empty?
+          @request_uri[0] = ::Zen::Settings[:default_section]
         end
         
-        if !@uri[1] or @uri[1].empty?
-          @uri[1] = 'index'
+        if !@request_uri[1] or @request_uri[1].empty?
+          @request_uri[1] = 'index'
         end
         
         # A theme is always required
-        if @settings[:theme].nil? or @settings[:theme].empty?
+        if ::Zen::Settings[:theme].nil? or ::Zen::Settings[:theme].empty?
           respond(lang('zen_general.errors.no_theme'))
         end
 
-        theme    = ::Zen::Theme[@settings[:theme]]
-        group    = @uri[0]
-        template = @uri[1]
-        
-        # Pre-create a few Liquid variables
-        @flash         = {}
-        @current_user  = {}
-        flash.each { |k, v| @flash[k.to_s] = v }
-        
-        if !session[:user].nil?
-          session[:user].values.each { |k, v| @current_user[k.to_s] = v }
-        end
+        theme    = ::Zen::Theme[::Zen::Settings[:theme]]
+        group    = @request_uri[0]
+        template = @request_uri[1]
         
         # Create the group, template and partial paths
         theme_path    = theme.template_dir
-        group_path    = theme_path + "/#{group}"
-        template_path = theme_path + "/#{group}/#{template}.liquid"
-        
-        # Register our partial path
-        if theme.respond_to?(:partial_dir) and !theme.partial_dir.nil?
-          ::Liquid::Template.file_system = ::Liquid::LocalFileSystem.new(
-            theme.partial_dir
-          )
-        end
+        group_path    = File.join(theme_path, group)
+        template_path = File.join(theme_path, group, "#{template}.xhtml")
         
         # Is the website down?
-        if @settings[:website_enabled] == '0'
-          offline_path = theme_path + "/offline.liquid"
+        if ::Zen::Settings[:website_enabled] == '0'
+          offline_path = File.join(theme_path, 'offline.xhtml')
           
           if File.exist?(offline_path)
             render_file(offline_path)
@@ -82,7 +66,7 @@ module Zen
           if File.directory?(group_path) and File.exists?(template_path)
             render_file(template_path)
           else
-            not_found = theme_path + "/404.liquid"
+            not_found = File.join(theme_path, '404.xhtml')
             
             if File.exist?(not_found)
               render_file(not_found)

data/lib/zen/error/validation_error.rb

@@ -0,0 +1,10 @@
+#:nodoc:
+module Zen
+  ##
+  # Error class used by Zen::Validation.
+  #
+  # @author Yorick Peterse
+  # @since  0.2.5
+  #
+  class ValidationError < StandardError; end
+end

data/lib/zen/ext/string.rb

@@ -0,0 +1,185 @@
+##
+# Extension to the string class provided by Ruby that provides the following 2 methods:
+#
+# * String.pluralize
+# * String.singularize
+#
+# Note that these methods only work for English words, other languages such as Japanese
+# or French aren't supported at this time (January, 2011). This snippet also doesn't cover
+# every single english word, patches are welcome!
+#
+# @author Yorick Peterse, Michael Fellinger
+# @since  1.0
+#
+class String
+  ##
+  # Constant containing all regular expressions for singular strings (that will be pluralized)
+  # and their replacements.
+  #
+  # @since 1.0
+  # 
+  SingularToPlural = {
+    /ss$/ => 'sses',
+    /se$/ => 'ses',
+    /sh$/ => 'shes',
+    /ge$/ => 'ges',
+    /ch$/ => 'ches',
+    /ge$/ => 'ges',
+    /g$/  => 'gs',
+
+    # When the singular form ends in a voiceless consonant (other than a sibilant).
+    # 
+    # lap   => laps
+    # cat   => cats
+    # clock => clocks
+    # cuff  => cuffs
+    # death => deaths
+    /ap$/ => 'aps',
+    /at$/ => 'ats',
+    /ck$/ => 'cks',
+    /ff$/ => 'ffs',
+    /th$/ => 'ths',
+    
+    # Most nouns ending in o preceded by a consonant also form their plurals by adding -es
+    # 
+    # hero    => heroes
+    # potato  => potatoes
+    # volcano => volcanoes or volcanos
+    /o$/  => 'oes',
+    
+    # nouns ending in a y preceded by a consonant usually drop the y and add -ies
+    #
+    # cherry => cherries
+    # lady   => ladies
+    # ywzxvtsrqpnmlkjhgfdcb
+    # 
+    /([bcdfghjklmnpqrstvxzwy]+)y$/ => "\\1ies",
+    
+    # For all other words (i.e. words ending in vowels or voiced non-sibilants).
+    # 
+    # boy   => boys
+    # girl  => girls
+    # chair => chairs
+    # quiz  => quizes
+    /z$/  => 'zes',
+    /y$/  => 'ys',
+    /l$/  => 'ls',
+    /r$/  => 'rs'
+  }
+  
+  ##
+  # Constant containing all regular expressions used to convert plural words to
+  # singular words.
+  #
+  # @since 1.0
+  #
+  PluralToSingular = {
+    /sses$/ => 'ss',
+    /ses$/  => 'se',
+    /shes$/ => 'sh',
+    /ges$/  => 'ges',
+    /ches$/ => 'ches',
+    /ges$/  => 'ges',
+    /aps$/  => 'ap',
+    /ats$/  => 'at',
+    /cks$/  => 'ck',
+    /ffs$/  => 'ff',
+    /ths$/  => 'th',
+    /oes$/  => 'o',
+    /ies$/  => 'y',
+    /zes$/  => 'z',
+    /ys$/   => 'y',
+    /l$/    => 'ls',
+    /r$/    => 'rs',
+    /s$/    => ''
+  }
+  
+  ##
+  # Tries to convert a string to it's pluralized version. For example, "user" would
+  # result in "users" and "quiz" will result in "quizes". This method will return
+  # the pluralized string, use pluralize! to overwrite the current (singular) version
+  # of the string with the pluralized one.
+  #
+  # @example
+  #  
+  #  "user".pluralize # => users
+  #  "baby".pluralize # => babies
+  #
+  # @author Yorick Peterse, Michael Fellinger
+  # @return [String] The pluralized version of the string.
+  # @since  1.0
+  #
+  def pluralize
+    string = self.dup
+    
+    SingularToPlural.each do |regex, replace|
+      new_string = string.gsub(regex, replace)
+      
+      if new_string != string
+        return new_string
+      end
+    end
+    
+    return string
+  end
+  
+  ##
+  # Converts the current string into a pluralized form and
+  # overwrites the old value rather than returning it.
+  #
+  # @example
+  #
+  #  word = "user"
+  #  word.pluralize! # => nil
+  #
+  #  puts word # => users
+  #
+  # @since 1.0
+  #
+  def pluralize!
+    self.replace(self.pluralize)
+  end
+  
+  ##
+  # Tries to convert the current string into a singular version.
+  #
+  # @example
+  #
+  #  "users".singularize  # => user
+  #  "babies".singularize # => baby
+  #
+  # @author Yorick Peterse
+  # @return [String] a singular form of the string
+  # @since  1.0
+  #
+  def singularize
+    string = self.dup
+    
+    PluralToSingular.each do |regex, replace|
+      new_string = string.gsub(regex, replace)
+      
+      if new_string != string
+        return new_string
+      end
+    end
+    
+    return string
+  end
+  
+  ##
+  # Converts a plural string to it's singular form and replaces
+  # the current value of the string with this singular version.
+  #
+  # @example
+  #
+  #  word = "users"
+  #  word.singularize! # => nil
+  #
+  #  puts word # => user
+  #
+  # @since 1.0
+  #
+  def singularize!
+    self.replace(self.singularize)
+  end
+end

data/lib/zen/helper/acl.rb

@@ -3,132 +3,160 @@ module Ramaze
   #:nodoc:
   module Helper
     ##
-    # This helper provides an easy way of working with the ACL system that
-    # ships with Zen. Using this helper you can restrict access to methods,
-    # view elements and pretty much everything else based on the user's
-    # permissions.
+    # This helper provides an easy way of working with the ACL system that ships with Zen. 
+    # Using this helper you can restrict access to methods, view elements and pretty much 
+    # everything else based on the user's permissions.
     #
-    # In order to use the ACL helper you'll need to define a trait named
-    # "extension_identifier" in your classes. Once this trait have been set you
-    # can use the "user_authorized?" method to verify the permissions of the current user.
-    # The first parameter is an array of required permissions,
-    # the second a boolean that indicates if either all or just a single permission must 
-    # be set.
+    # In order to restrict certain actions to only those with the correct permissions you
+    # can use the method "user_authorized?". This method takes a list of required 
+    # permissions and when the user has the correct permissions it will return true:
     #
-    # For more information about the ACL system you should read the documentation
-    # in the ACL controller, Users::Controllers::AccessRules().
+    #     user_authorized?([:read]) # => true
+    #
+    # The method has 3 parameters: a list of permissions, a boolean that indicates whether
+    # all of them or just a single one is required and a third argument that can be used
+    # to manually specify the controller to validate against rather than the current node.
+    #
+    #     user_authorized?([:read], true 'FoobarController')
     #
     # @author Yorick Peterse
     # @since  0.1
-    # @see    Users::Controllers::AccessRules()
+    # @see    Users::Controller::AccessRules()
     #
     module ACL
+
       ##
-      # Retrieves all permissions for the current user
-      # along with the permissions set for all groups the user
-      # belongs to. Rather than loading a new instance of the User model
-      # we'll retrieve the model from the session variable set by the
-      # User helper provided by Ramaze. Doing this saves us a few queries.
+      # Builds a hash containing the permissions for all controllers. First all group
+      # based rules will be retrieved. If the user is in a super group he'll gain full
+      # access. However, if there's a user specific rule it will overwrite the rules set
+      # for the group. This means that if a group allows something but a user rule doesn't
+      # the user won't be able to gain access to the resource.
       #
       # @author Yorick Peterse
       # @since  0.1
-      # @return [Mixed] returns a hash containing all rules per identifier along
-      # with a boolean that indicates if the user is in a super group.
+      # @return [Hash]
       #
       def extension_permissions
-        m             = session[:user]
-        user_groups   = m.user_groups
-        super_group   = false
-        rules         = []
-        ordered_rules = {}
-        
-        user_groups.each do |group|
-          rules += group.access_rules
-          
-          if group.super_group == true
-            super_group = true
-          end
-        end
-        
-        m.access_rules.each do |rule|
-          rules.push(rule)
+        if session[:access_rules]
+          return session[:access_rules]
         end
-        
-        rules.each do |rule|
-          if !ordered_rules.key?(rule.extension)
-            ordered_rules[rule.extension] = []
-          end
-          
-          [:create_access, :read_access, :update_access, :delete_access].each do |perm|
-            if rule.send(perm) === true or super_group == true
-              perm = perm.to_s.gsub!('_access', '').to_sym
-              
-              if !ordered_rules[rule.extension].include?(perm)
-                ordered_rules[rule.extension].push(perm)
-              end
+
+        user            = session[:user]
+        user_groups     = user.user_groups
+        @used_rules     = {}
+        available_rules = [:create_access, :read_access, :update_access, :delete_access]
+
+        # First all group rules should be built
+        user_groups.each do |group|
+          # If it's a super group we'll add all rules
+          if group.super_group === true
+            ::Zen::Package::Controllers.each do |controller|
+              @used_rules[controller.to_s] = [:create, :read, :update, :delete]
             end
           end
+
+          group.access_rules.each do |rule|
+            process_permissions(rule, available_rules)
+          end
+        end
+
+        # Process all user specific rules
+        user.access_rules.each do |rule|
+          process_permissions(rule, available_rules)
         end
-        
-        return ordered_rules, super_group
+
+        # Store the rules in the user's session so that they don't have to be re-processed
+        # every time this method is called.
+        session[:access_rules] = @used_rules
+
+        return @used_rules
       end
       
       ##
-      # Checks if the user has the specified permissions for the current
-      # extension that was called. Returns true if this is the case and false
-      # otherwise.
+      # Checks if the user has the specified permissions for the current extension that 
+      # was called. Returns true if this is the case and false otherwise.
       #
       # @author Yorick Peterse
-      # @param  [Array] reqs Array of permissions that are required.
-      # @param  [Boolean] require_all Boolean that specifies that the user
-      # should have ALL specified permissios. Setting this to false causes
-      # this method to return true if any of the permissions are set for the
-      # current user.
-      # @param  [String] identifier A custom identifier to use for validating the user's 
-      # permissions instead of using a class trait.
-      # @return [Boolean]
+      # @param  [Array] required Array of permissions that are required.
+      # @param  [Boolean] require_all Boolean that specifies that the user should have 
+      # ALL specified permissios. Setting this to false causes this method to return true 
+      # if any of the permissions are set for the current user.
+      # @param  [String] controller When set this will overwrite the controller name of
+      # action.node. This is useful when you want to check the permissions of a different
+      # controller than the current one.
+      # @return [TrueClass]
       #
-      def user_authorized?(reqs, require_all = true, identifier = nil)
-        # Retrieve the identifier from the class trait if we didn't already have one
-        if identifier.nil?
-          identifier = ancestral_trait.values_at(:extension_identifier)
-          identifier = identifier[0]
-        end
-
-        # Still don't have an identifier?
-        if identifier.nil?
-          raise "You need to specify an extension identifier"
-        end
-        
+      def user_authorized?(required, require_all = true, controller = nil)
         # Get the ACL list
-        rules       = self.extension_permissions
-        super_group = rules[1]
-        rules       = rules[0]
-        
-        # Super groups have full access
-        if super_group == true
-          return true
+        rules = extension_permissions
+
+        if !controller
+          controller = action.node.to_s
         end
-        
-        # Deny access if the identifier is not found
-        if !rules.key?(identifier)
+
+        if !rules.key?(controller)
           return false
         end
-        
-        # Verify the permissions
-        perms = rules[identifier]
-        
-        reqs.each do |req|
-          if require_all == false and perms.include?(req)
+
+        required.each do |req|
+          if require_all === false and rules[controller].include?(req)
             return true
-          elsif !perms.include?(req)
+          elsif !rules[controller].include?(req)
             return false
           end
         end
-        
+
         return true
       end
 
+      private
+
+      ##
+      # Extracts and stores all the permissions from a given rule. 
+      #
+      # @author Yorick Peterse
+      # @since  0.2.5
+      # @param  [Users::Model::AccessRule] rule Database record containing the details of
+      # a single rule.
+      # @param  [Array] available_rules All the available rules that can be used.
+      #
+      def process_permissions(rule, available_rules)
+        available_rules.each do |available_rule|
+          # Add the rule to the list
+          if rule.send(available_rule) === true
+            method = :push
+          # Remove the rule
+          else
+            method = :delete
+          end
+
+          available_rule = available_rule.to_s.gsub('_access', '').to_sym
+          controllers    = []
+
+          # Process all controllers
+          if rule.controller === '*'
+            ::Zen::Package[rule.package].controllers.each do |name, controller|
+              controllers.push(controller.to_s)
+            end
+          # Process a single controller
+          else
+            controllers.push(rule.controller)
+          end
+
+          # Add the rules for all the controllers
+          controllers.each do |c|
+            @used_rules[c] ||= []
+
+            if method === :push and @used_rules[c].include?(available_rule)
+              next
+            end
+
+            # Add or remove the permission
+            @used_rules[c].send(method, available_rule)
+          end
+        end
+      end
+
     end
   end
 end