zen 0.2.8 → 0.3b

data/lib/zen/helper/controller.rb

@@ -0,0 +1,73 @@
+module Ramaze
+  module Helper
+    ##
+    # Helper that provides a few methods for commonly used code inside a
+    # controller.
+    #
+    # @since  0.3
+    #
+    module Controller
+      ##
+      # Extends the class that included this module with the ClassMethods
+      # module.
+      #
+      # @since  0.3
+      # @param  [Class] into The class that included this module.
+      #
+      def self.included(into)
+        into.extend(Ramaze::Helper::Controller::ClassMethods)
+      end
+
+      ##
+      # Methods that become available as class methods.
+      #
+      # @since  0.3
+      #
+      module ClassMethods
+        ##
+        # Sets the title for all the methods based on a language string. If
+        # there's no corresponding language key the title will not be set.
+        #
+        # @example
+        #  class Foo < Zen::Controller::AdminController
+        #    title 'foo.titles.%s'
+        #  end
+        #
+        # @since  0.3
+        # @param  [String] title The language key to use, a %s will be replaced
+        #  with the name of the current action.
+        #
+        def title(title)
+          stacked_before_all(:set_page_title) do
+            @page_title = lang(title % action.method) rescue nil
+          end
+        end
+
+        ##
+        # Protects the specified methods against CSRF attacks. If a CSRF token
+        # is missing the user will see the message defined in the language key
+        # "zen_general.errors.csrf" and the HTTP status code will be set to 403.
+        #
+        # @example
+        #  class Foo < Zen::Controller::AdminController
+        #    csrf_protection :save, :delete
+        #  end
+        #
+        # @since  0.3
+        # @param  [Array] *actions An array of action names to protect against
+        #  CSRF attacks.
+        #
+        def csrf_protection(*actions)
+          # before_all() calls don't stack. Because CSRF protected methods are
+          # usually used for POST calls (and are separate methods) this works
+          # around it.
+          stacked_before_all(:validate_csrf_token) do
+            csrf_protection(*actions) do
+              respond(lang('zen_general.errors.csrf'), 403)
+            end
+          end
+        end
+      end # ClassMethods
+    end # Controller
+  end # Helper
+end # Ramaze

data/lib/zen/helper/locale.rb

@@ -0,0 +1,42 @@
+module Ramaze
+  module Helper
+    ##
+    # Helper that can be used to display various variables based on the user's
+    # locale and settings.
+    #
+    # @since  0.3
+    #
+    module Locale
+      ##
+      # Returns the date format for the currently logged in user. If the user
+      # has no date format set (or isn't logged in) the system format is used.
+      #
+      # @since  0.3
+      #
+      def date_format
+        begin
+          format = user.date_format
+        rescue
+          format = get_setting(:date_format).value
+        end
+
+        return format
+      end
+
+      ##
+      # Formats a date according to Ramaze::Helper::Locale#date_format.
+      #
+      # @since  0.3
+      # @param  [#strftime] object An object that responds to #strftime().
+      # @return [String]
+      #
+      def format_date(object)
+        if object.respond_to?(:strftime)
+          return object.strftime(date_format)
+        else
+          return nil
+        end
+      end
+    end # Locale
+  end # Helper
+end # Ramaze

data/lib/zen/helper/message.rb

@@ -22,14 +22,12 @@ module Ramaze
     #
     # This will create and return the HTML for all the messages.
     #
-    # @author Yorick Peterse
     # @since  26-05-2011
     #
     module Message
       ##
       # Adds a new message to the list for the given type.
       #
-      # @author Yorick Peterse
       # @since  26-05-2011
       # @param  [Symbol/String] type The type of message to store (e.g. "error").
       # @param  [String] message The message to display.
@@ -47,7 +45,6 @@ module Ramaze
       ##
       # Renders all the messages for the specified types.
       #
-      # @author Yorick Peterse
       # @since  26-05-2011
       # @param  [Array] types Array containing all the messages to render.
       #

data/lib/zen/helper/search.rb

@@ -0,0 +1,54 @@
+module Ramaze
+  module Helper
+    ##
+    # The Search helper is a helper that can be used in controllers allowing the
+    # user to search the content of those controllers and models.
+    #
+    # @since  16-10-2011
+    #
+    module Search
+      ##
+      # Renders a search form that points to the given URL.
+      #
+      # @since  16-10-2011
+      # @param  [#to_s] url The URL to point the search form to.
+      # @return [String]
+      #
+      def render_search_form(url)
+        render_file(
+          __DIR__('../view/search.xhtml'),
+          :url => url.to_s
+        )
+      end
+
+      ##
+      # Calls the given block used to search a number of records. If the search
+      # action raises an error a message is displayed and the user will be
+      # redirected back to the previous page.
+      #
+      # If no search query is specified nil will be returned.
+      #
+      # @example
+      #  results = search do |query|
+      #    Sections::Model::Section.search(query)
+      #  end
+      #
+      # @since  16-10-2011
+      # @return [NilClass|Mixed]
+      #
+      def search
+        if request.params['query'].nil? or request.params['query'].empty?
+          return nil
+        end
+
+        begin
+          return yield(request.params['query'])
+        rescue => e
+          Ramaze::Log.error(e.inspect)
+          message(:error, lang('zen_general.errors.invalid_search'))
+          redirect_referrer(::Sections::Controller::Sections.r(:index))
+        end
+      end
+    end # Search
+  end # Helper
+end # Ramaze

data/lib/zen/helper/stacked_aspect.rb

@@ -0,0 +1,249 @@
+module Ramaze
+  module Helper
+    ##
+    # StackedAspect is a helper similar to {Innate::Helper::Aspect} but allows
+    # calls to methods such as ``before_all`` to stack on top of each other
+    # instead of overwriting previously defined ones.
+    #
+    # Although this helper works very similar to the Aspect helper there are two
+    # main differences besides the calls being stackable:
+    #
+    # 1. All methods are prefixed with ``stacked_``
+    # 2. All methods require you to specify a name for the block.
+    #
+    # Both these items exist to achieve compatibility with the Aspect helper as
+    # well as being able to reload code using the reloader without adding all
+    # the blocks each time the code is reloaded.
+    #
+    # Basic usage of this helper is as following:
+    #
+    #     class Posts < Ramaze::Controller
+    #       map    '/posts'
+    #       helper :stacked_aspect
+    #
+    #       stacked_before_all(:validate_ip) do
+    #         validate_ip
+    #       end
+    #
+    #       stacked_before_all(:validate_user) do
+    #         validate_user
+    #       end
+    #
+    #       def index
+    #
+    #       end
+    #     end
+    #
+    # In this example both methods (``validate_ip`` and ``validate_user``) would
+    # be executed before calling ``#index()``.
+    #
+    # @since 06-11-2011
+    #
+    module StackedAspect
+      # Hash that will contain all the STACKED_AOP actions.
+      STACKED_AOP = Hash.new { |h, k| h[k] = Hash.new { |hh, kk| hh[kk] = {} } }
+
+      ##
+      # Called whenever this module is included into a class.
+      #
+      # @since 06-11-2011
+      # @param [Class] into The class that included this module.
+      #
+      def self.included(into)
+        into.extend(ClassMethods)
+        into.add_action_wrapper(7.0, :stacked_aspect_wrap)
+      end
+
+      # @see Innate::Helper::Aspect.ancestral_aop
+      def self.ancestral_aop(from)
+        aop = {}
+
+        from.ancestors.reverse.map do |anc|
+          aop.merge!(STACKED_AOP[anc]) if anc < StackedAspect
+        end
+
+        return aop
+      end
+
+      ##
+      # Shows a warning to inform the developer that the aspect name is already
+      # in use.
+      #
+      # @since 06-11-2011
+      # @param [#to_s] name The name of the aspect.
+      #
+      def self.aspect_warn(name)
+        file, line = caller[1].split(':')
+
+        Ramaze::Log.warn(
+          "The aspect name \"#{name}\" is already in use, it was redefined " \
+            "in #{file} on line #{line}"
+        )
+      end
+
+      ##
+      # Calls a certain AOP action for the specified position and method name.
+      #
+      # @since 06-11-2011
+      # @param [Symbol] position The position of the AOP action (e.g. :after).
+      # @param [String] name The name of the method for which to call the
+      #  action.
+      #
+      def stacked_aspect_call(position, name)
+        return unless aop   = StackedAspect.ancestral_aop(self.class)
+        return unless block = aop[position]
+
+        name = name.to_sym
+
+        # Bail out if the position is :before or :after but the current method
+        # doesn't match.
+        if [:before, :after].include?(position) and !block[name].is_a?(Hash)
+          return
+        end
+
+        # Extract the sub hash for the current method, this is needed for
+        # :before and :after.
+        if block.is_a?(Hash) and block[name].is_a?(Hash)
+          block = block[name]
+        end
+
+        if block.respond_to?(:each)
+          block.each do |k, v|
+            instance_eval(&v)
+          end
+        else
+          instance_eval(&block)
+        end
+      end
+
+      # @see Innate::Helper::Aspect#aspect_wrap
+      def stacked_aspect_wrap(action)
+        return yield unless method = action.name
+
+        stacked_aspect_call(:before_all, method)
+        stacked_aspect_call(:before, method)
+
+        result = yield
+
+        stacked_aspect_call(:after, method)
+        stacked_aspect_call(:after_all, method)
+
+        return result
+      end
+
+      ##
+      # Module who's methods become available as class methods.
+      #
+      # @since 06-11-2011
+      #
+      module ClassMethods
+        include Traited
+
+        ##
+        # Defines a block to run before all the actions in a controller.
+        #
+        # @example
+        #  stacked_before_all(:check_ip) do
+        #    validate_ip
+        #  end
+        #
+        #  stacked_before_all(:check_username) do
+        #    validate_username
+        #  end
+        #
+        # @since 06-11-2011
+        # @param [#to_sym] name The unique name of the block.
+        # @param [Proc] block The block to execute.
+        #
+        def stacked_before_all(name, &block)
+          name = name.to_sym
+
+          if !STACKED_AOP[self][:before_all].key?(name)
+            STACKED_AOP[self][:before_all][name] = block
+          else
+            StackedAspect.aspect_warn(name)
+          end
+        end
+
+        ##
+        # Defines a block similar to
+        # {Ramaze::Helper::StackedAspect::ClassMethods#stacked_before} but only
+        # runs the block before the specified list of methods.
+        #
+        # @example
+        #  stacked_before(:check_ip, [:save, :delete]) do
+        #    validate_ip
+        #  end
+        #
+        # @since 06-11-2011
+        # @param [#to_sym] name A unique name for the block.
+        # @param [Array] methods An array of methods for which to run the block.
+        # @param [Proc] block The block to run.
+        #
+        def stacked_before(name, methods, &block)
+          name = name.to_sym
+
+          methods.each do |m|
+            m = m.to_sym
+            STACKED_AOP[self][:before][m] ||= {}
+
+            if !STACKED_AOP[self][:before][m].key?(name)
+              STACKED_AOP[self][:before][m][name] = block
+            else
+              StackedAspect.aspect_warn(name)
+            end
+          end
+        end
+
+        ##
+        # Runs a block after all the actions in a controller.
+        #
+        # @since 06-11-2011
+        # @see   Ramaze::Helper::StackedAspect::ClassMethods#stacked_before_all
+        #
+        def stacked_after_all(name, &block)
+          name = name.to_sym
+
+          if !STACKED_AOP[self][:after_all].key?(name)
+            STACKED_AOP[self][:after_all][name] = block
+          else
+            StackedAspect.aspect_warn(name)
+          end
+        end
+
+        ##
+        # Runs a block after a specific list of methods.
+        #
+        # @since 06-11-2011
+        # @see   Ramaze::Helper::StackedAspect::ClassMethods#stacked_before
+        #
+        def stacked_after(name, names, &block)
+          name = name.to_sym
+
+          methods.each do |m|
+            m = m.to_sym
+            STACKED_AOP[self][:after][m] ||= {}
+
+            if !STACKED_AOP[self][:after][m].key?(name)
+              STACKED_AOP[self][:after][m][name] = block
+            else
+              StackedAspect.aspect_warn(name)
+            end
+          end
+        end
+
+        ##
+        # Wraps the block around the list of methods.
+        #
+        # @since 06-11-2011
+        # @see   Ramaze::Helper::StackedAspect::ClassMethods#stacked_before
+        # @see   Ramaze::Helper::StackedAspect::ClassMethods#stacked_after
+        #
+        def stacked_wrap(name, names, &block)
+          before(name, names, &block)
+          after(name, names, &block)
+        end
+      end # ClassMethods
+    end # StackedAspect
+  end # Helper
+end # Ramaze

data/lib/zen/helper/theme.rb

@@ -1,5 +1,3 @@
-require __DIR__('../error/theme_error')
-
 #:nodoc:
 module Ramaze
   #:nodoc:
@@ -8,7 +6,6 @@ module Ramaze
     # Helper that provides a few methods that make certain tasks easier when
     # creating themes and templates.
     #
-    # @author Yorick Peterse
     # @since  0.2.5
     #
     module Theme
@@ -22,14 +19,13 @@ module Ramaze
       #  partial(:header) # => partials/header.xhtml
       #  partial(:header, :username => "YorickPeterse")
       #
-      # @author Yorick Peterse
       # @since  0.2.5
       # @param  [Symbol] file The name of the partial to render.
       # @param  [Hash] variables A hash with variables that should be made
-      # available for the partial.
+      #  available for the partial.
       #
       def partial(file, variables = {})
-        theme = plugin(:settings, :get, :theme).value
+        theme = get_setting(:theme).value
         theme = Zen::Theme[theme]
 
         if !theme.respond_to?(:partial_dir) or theme.partial_dir.nil?
@@ -59,15 +55,12 @@ module Ramaze
       #  show_404
       #  show_404(:uri => @request_uri)
       #
-      # @author Yorick Peterse
       # @since  0.2.5
       # @param  [Hash] variables Hash with variables to pass to the 404 template.
       #
       def show_404(variables = {})
-        theme    = ::Zen::Theme[plugin(:settings, :get, :theme).value]
+        theme    = ::Zen::Theme[get_setting(:theme).value]
         template = File.join(theme.template_dir, '404.xhtml')
-
-        # Render the template and replace the current buffer with it's output
         template = render_file(template, variables)
 
         respond(template, 404)