zen 0.1a

data/lib/zen/controller/base_controller.rb

@@ -0,0 +1,39 @@
+module Zen
+  module Controllers
+    ##
+    # The BaseController is extended by both the FrontendController and the BackendController.
+    # This controller is mostly used to set and retrieve data that's used in both the
+    # backend and the frontend.
+    #
+    # @author Yorick Peterse
+    # @since  0.1
+    #
+    class BaseController < Ramaze::Controller
+      helper :csrf, :cgi
+      
+      ##
+      # The initialize method is called upon class initalization and is used to process several
+      # items before loading the controller(s) for the current module.
+      #
+      # @author Yorick Peterse
+      # @since  1.0
+      #
+      def initialize
+        super
+        
+        # The trait for the User helper has to be specified in the constructor as
+        # our user model is loaded after this class is loaded (but before it's initialized)
+        self.trait :user_model => ::Users::Models::User
+        
+        # Get all settings
+        if !session[:settings]
+          session[:settings] = ::Settings::Models::Setting.get_settings
+        end
+        
+        # Override the language
+        Zen.options.language = session[:settings][:language]
+        @zen_general_lang    = Zen::Language.load('zen_general')
+      end
+    end
+  end
+end

data/lib/zen/controller/frontend_controller.rb

@@ -0,0 +1,16 @@
+module Zen
+  module Controllers
+    ##
+    # 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
+    # use the Liquid template engine for all views.
+    #
+    # @author Yorick Peterse
+    # @since  0.1
+    #
+    class FrontendController < Zen::Controllers::BaseController
+      engine :liquid
+      layout :none
+    end
+  end
+end

data/lib/zen/controller/main_controller.rb

@@ -0,0 +1,93 @@
+module Zen
+  module Controllers
+    ##
+    # 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
+    # from the settings table.
+    #
+    # @author Yorick Peterse
+    # @since  0.1
+    #
+    class MainController < Zen::Controllers::FrontendController
+      map '/'
+      
+      ##
+      # The index method acts as a catch-all method. Based on the requested URI
+      # the correct template group/file will be loaded. If no templates are found
+      # a 404 template will be loaded. If that's not found either a default error
+      # will be shown. If the website is offline we'll try to load the template
+      # "offline", if it isn't there a regular message will be displayed.
+      #
+      # @author Yorick Peterse
+      # @since  0.1
+      # @param  [Array] uri Array containing all arguments (thus the URI).
+      #
+      def index(*uri)
+        settings = session[:settings]
+        @uri     = []
+        
+        # Clean the URI of nasty input
+        uri.each { |v| @uri.push(h(v)) }
+        
+        if !@uri[0] or @uri[0].empty?
+          @uri[0] = settings[:default_section]
+        end
+        
+        if !@uri[1] or @uri[1].empty?
+          @uri[1] = 'index'
+        end
+        
+        # A theme is always required
+        if settings[:theme].nil?
+          respond(@zen_general_lang.errors[:no_theme])
+        end
+        
+        theme    = ::Zen::Package[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
+        
+        # Create the group, template and partial paths
+        theme_path    = theme.directory + '/templates'
+        group_path    = theme_path + "/#{group}"
+        template_path = theme_path + "/#{group}/#{template}.liquid"
+        
+        # Register our partial path
+        partial_path                   = theme_path + "/partials"
+        ::Liquid::Template.file_system = ::Liquid::LocalFileSystem.new(partial_path)
+        
+        # Is the website down?
+        if settings[:website_enabled] == '0'
+          offline_path = theme_path + "/offline.liquid"
+          
+          if File.exist?(offline_path)
+            render_file offline_path
+          else
+            respond(@zen_general_lang.errors[:website_offline])
+          end
+        else
+          # Check if the group exists
+          if File.directory?(group_path) and File.exists?(template_path)
+            render_file template_path
+          else
+            not_found = theme_path + "/404.liquid"
+            
+            if File.exist?(not_found)
+              render_file not_found
+            else
+              respond(@zen_general_lang.errors[:no_templates], 404)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/zen/helper/acl.rb

@@ -0,0 +1,124 @@
+module Ramaze
+  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.
+    #
+    # 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.
+    #
+    # For more information about the ACL system you should read the documentation
+    # in the ACL controller, Users::Controllers::AccessRules().
+    #
+    # @author Yorick Peterse
+    # @since  0.1
+    # @see    Users::Controllers::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.
+      #
+      # @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.
+      #
+      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)
+        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
+            end
+          end
+        end
+        
+        return ordered_rules, super_group
+      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.
+      #
+      # @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.
+      # @return [Boolean]
+      #
+      def user_authorized?(reqs, require_all = true)
+        identifier = ancestral_trait.values_at(:extension_identifier)
+        identifier = identifier[0]
+        
+        if identifier.nil?
+          raise "You need to specify an extension identifier"
+        end
+        
+        # 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
+        end
+        
+        # Deny access if the identifier is not found
+        if !rules.key?(identifier)
+          return false
+        end
+        
+        # Verify the permissions
+        perms = rules[identifier]
+        
+        reqs.each do |req|
+          if require_all == false and perms.include?(req)
+            return true
+          elsif !perms.include?(req)
+            return false
+          end
+        end
+        
+        return true
+      end
+    end
+  end
+end

data/lib/zen/helper/asset.rb

@@ -0,0 +1,104 @@
+require 'ramaze/gestalt'
+
+module Ramaze
+  module Helper
+    ##
+    # The Asset helper can be used to load Javascript and CSS files without
+    # having to embedd them in your views. In order to tell the helper that
+    # a CSS or Javascript file has to be loaded you'll have to call the
+    # require_* method. For example, if we want to require a CSS file named
+    # "reset" we'd do the following:
+    #
+    # bc. register_css :reset
+    #
+    # Once you have your files required you can build the HTML by either calling
+    # build_css or build_js.
+    #
+    # @author Yorick Peterse
+    # @since  0.1
+    # @todo   Add support for compressing Javascript and CSS files.
+    #
+    module Asset
+      @css = []
+      @js  = []
+      
+      ##
+      # Requires a new CSS file.
+      #
+      # @author Yorick Peterse
+      # @param  [Symbol] files Paths to the CSS files to require.
+      # @since  0.1
+      #
+      def require_css *files
+        if @css.nil?
+          @css = []
+        end
+        
+        files.each do |file|
+          file = file.to_sym
+          
+          if !@css.include?(file)
+            @css.push(file)
+          end
+        end
+      end
+      
+      ##
+      # Requires a new Javascript file.
+      #
+      # @author Yorick Peterse
+      # @param  [Symbol] files Paths to the Javascript files to require.
+      # @since  0.1
+      #
+      def require_js *files
+        if @js.nil?
+          @js = []
+        end
+        
+        files.each do |file|
+          file = file.to_sym
+          
+          if !@js.include?(file)
+            @js.push(file)
+          end
+        end
+      end
+      
+      ##
+      # Builds the HTML for all CSS tags using Gestalt.
+      #
+      # @author Yorick Peterse
+      # @since  0.1
+      # @return [String]
+      #
+      def build_css
+        g = Ramaze::Gestalt.new
+        
+        @css.each do |css|
+          css = "/admin/css/#{css}.css"
+          g.link :rel => "stylesheet", :href => css, :media => "all", :type => "text/css"
+        end
+        
+        return g.to_s
+      end
+      
+      ##
+      # Builds the HTML for all Javascript tags using Gestalt.
+      #
+      # @author Yorick Peterse
+      # @since  0.1
+      # @return [String]
+      #
+      def build_js
+        g = Ramaze::Gestalt.new
+        
+        @js.each do |js|
+          js = "/admin/js/#{js}.js"
+          g.script(:src => js) {}
+        end
+        
+        return g.to_s
+      end
+    end
+  end
+end

data/lib/zen/helper/breadcrumb.rb

@@ -0,0 +1,71 @@
+module Ramaze
+  module Helper
+    ##
+    # Helper that can be used to quickly generate breadcrumbs without having
+    # to manually write the HTML separators and formatting the output correctly.
+    # In order to create a set of breadcrumbs we first need to call the set_breadcrumbs
+    # method:
+    #
+    # bc. set_breadcrumbs segment1, segment2, segment3, etc
+    #
+    # Each argument will be a segment of the breadcrumbs, separated by a custom character.
+    # Retrieving the breadcrumbs is super easy:
+    #
+    # bc. get_breadcrumbs
+    #
+    # This will generate the correct HTML and return it, all you have to do is output it.
+    #
+    # @author Yorick Peterse
+    # @since  0.1
+    #
+    module Breadcrumb
+      @breadcrumbs = []
+      
+      ##
+      # Appends each element to the list of breadcrumb segments.
+      #
+      # @example
+      #  set_breadcrumbs "Articles", "Edit"
+      #
+      # Note that you'll have to manually specify anchor tags, this method won't automatically
+      # generate URLs.
+      # 
+      # @author Yorick Peterse
+      # @param  [Array] args Array of segments for the breadcrumbs.
+      # @since  0.1
+      #
+      def set_breadcrumbs *args
+        @breadcrumbs = args
+      end
+      
+      ##
+      # Retrieves all breacrumbs and separates them either by "»" or a custom element
+      # set as the first argument of this method.
+      #
+      # @example
+      #  get_breadcrumbs # => "Articles » Edit"
+      #
+      # @example
+      #  get_breadcrumbs ">" # => "Articles > Edit"
+      #
+      # @author Yorick Peterse
+      # @param  [String] separator The HTML character to use for separating each segment.
+      # @return [String]
+      # 
+      def get_breadcrumbs separator = "»"
+        if !@breadcrumbs or @breadcrumbs.empty?
+          return
+        end
+        
+        html      = ''
+        separator = " #{separator} "
+        
+        @breadcrumbs.each do |segment|
+          html += segment + separator
+        end
+        
+        return html.chomp(separator)
+      end
+    end
+  end
+end